반응형

           

  JAVA Study





1. 객체지향 언어


- 객체지향의 기본개념 

: 실제 세계는 사물(객체)로 이루어져 있으며, 발생하는 모든 사건들은 사물간의 상호작용이다

: 상속, 캡슐화, 추상화 개념을 중심으로 구체적으로 발전됨


- 객체지향 언어

: 코드의 재사용성이 높다 - 기존코드를 이용하여 새로운 코드 작성이 쉬움

: 코드의 관리가 용이하다 - 코드간의 관계를 이용해 쉽게 코드변경 가능

: 신뢰성이 높은 프로그래밍을 가능하게 한다 - 제어자와 메서드를 이용해 데이터를 보호하고 올바른 값을 유지하게 하며, 코드 중복 제거, 코드 불일치로 인한 오동작 방지

: 객체지향 프로그래밍은 프로그래머에게 거시적 관점에서 설계할 수 있는 능력을 요구



2. 클래스와 객체


- 클래스

: 객체를 정의해 놓은 것

: 객체의 설계도

: 객체를 생성하는데 사용되며


- 객체

: 클래스에 정의된 내용대로 메모리에 생성됨

: 객체의 용도는 객체가 가지고 있는 기능과 속성에 따라 다름


- 먼저 클래스를 작성한 후, 클래스로부터 객체를 생성해 사용한다


- 인스턴스화

: 클래스로부터 객체를 만드는 과정

: 어떤 클래스로부터 만들어진 객체를 그 클래스의 인스턴스라고 함

: 객체는 모든 인스턴스를 대표, 인스턴스는 어떤 클래스에서 생성된 객체인지를 강조하는 보다 구체적 표현


- 객체의 속성과 기능

: 객체는 다수의 속성과 다수의 기능을 가짐 ( 속성과 기능의 집합 )

: 클래스는 객체를 정의한 것이므로, 클래스에 객체의 모든 속성과 기능이 정의되어있음

: 클래스로부터 객체 생성 -> 클래스에 정의된 속성과 기능을 가진 객체가 만들어짐

: 속성 - 멤버변수, 특성, 필드, 상태

: 기능 - 메서드, 함수, 행위


- 인스턴스 생성

: 클래스명 변수명= new 클래스명();   ( ex. Tv t = new Tv(); )

-> Tv 클래스 타입의 참조변수 t 선언& 초기화

-> 인스턴스 속성을 사용하려면 '참조변수.멤버변수'로 작성 ( ex. t.멤버변수 )

: 인스턴스는 오직 참조변수를 통해서만 다룰 수 있음

: 참조변수의 타입은 인스턴스의 타입과 일치해야 함

: 같은 클래스로부터 생성되어도 각 인스턴스의 속성은 서로 다른 값을 유지할 수 있음, 메서드의 내용은 모든 인스턴스에 동일


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Tv{
    // Tv 속성 (멤버변수)
    String color;     //색상
    boolean power;    //전원상태 (on/off)
    int channel;    //채널
 
    // Tv기능 (메서드)
    void power() {
        power = !power;    //Tv를 켜거나 끄는 메서드
    }
    void channelUp() {
        ++channel;        //채널을 높이는 메서드
    }
    void channelDown() {
        --channel;        //채널을 낮추는 메서드
    }
}
 
class TvTest2{
    public static void main(String args[]){
        Tv t1 = new Tv();
        Tv t2 = new Tv();
        
        System.out.println("t1의 channel 값은 : "+t1.channel +"입니다.");    //t1의 channel 값은 : 0
        System.out.println("t2의 channel 값은 : "+t2.channel +"입니다.");    //t2의 channel 값은 : 0
 
        t1.channel = 7//채널 7 저장
        System.out.println("t1의 channel 값은 : "+t1.channel +"입니다.");  //t1의 channel 값은 : 7
        System.out.println("t2의 channel 값은 : "+t2.channel +"입니다.");    //t2의 channel 값은 : 0
        
    }
}
cs


- 객체배열

: 많은 수의 객체를 다룰 때 배열 사용

: 객체 배열안에 객체의 주소 저장, 참조변수를 하나로 묶은 참조변수 배열


- 클래스의 또다른 정의 (프로그래밍적 관점)

: 변수 - 하나의 데이터를 저장할 수 있는공간

: 배열 - 같은 종류의 여러 데이터를 하나의 집합으로 저장할 수 있는 공간

: 구조체 - 서로 관련된 여러 데이터를 종류에 관계없이 하나의 집합으로 저장할 수 있는 공간

: 클래스 - 데이터와 함수의 결합 (구조체 + 함수)

: 자바와 같은 객체지향언어는 변수(데이터)와 함수를 하나의 클래스에 정의하여 서로 관계 깊은 변수와 함수를 함께 다룰 수 있게 한다



3. 변수와 메서드


- 선언 위치에 따른 변수의 종류

: 클래스 변수 / 인스턴스 변수 / 지역변수

: 변수의 선언된 위치가 변수의 종류를 결정

: 멤버변수를 제외한 나머지는 모두 지역변수

: 멤버변수 중 static이 붙은 것은 클래스변수, 붙지 않은 것은 인스턴스변수


1
2
3
4
5
6
7
8
9
10
11
class Tv{
 
    String color;     // 인스턴스 변수
    static int channel;    // 클래스변수, 공유변수, static변수
 
 
    void method() {
        String color = 0// 지역변수
    }
        
}










cs

: ㄴㅇ라ㅓ

- 인스턴스 변수 

: 클래스영역에 선언

: 클래스의 인스턴스를 생성할 때 만들어짐

: 인스턴스 변수의 값을 읽어 오거나 저장하기 위해서 먼저 인스턴스 생성해야 함

: 독립적 저장공간을 가지므로 서로 다른 값을 가질 수 있음

: 인스턴스마다 고유한 상태를 유지해야 하는 속성의 경우 인스턴스변수로 선언


- 클래스 변수

: 인스턴스 변수 앞에 static을 붙이면 클래스 변수 선언됨

: 모든 인스턴스가 공통된 저장공간을 공유

: 한 클래스의 모든 인스턴스들이 공통적인 값을 유지해야 하는 경우 클래스 변수로 선언

: 인스턴스를 생성하지 않고 바로 사용 가능

: 클래스가 메모리에 로딩될 때 생성되어 프로그램이 종료될 때까지 유지

: public을 앞에 붙이면 같은 프로그램 내 어디서나 접근가능한 ' 전역변수 ' 성격을 가짐


- 지역 변수 

: 메서드 내에 선언되어 메서드 내에서만 사용 가능, 메서드 종료 시 소멸

: for문, while문의 블럭 내에 선언된 지역변수는 블럭을 벗어나면 소멸되어 사용 불가


- 메서드

: 특정 작업을 수행하는 일련의 문장들을 하나로 묶은 것

: 높은 재사용성 / 중복된 코드 제거 / 프로그램의 구조화

: 선언부와 구현부로 이루어짐

: 메서드 선언부 

- 메서드의 이름, 매개변수의 선언, 반환타입으로 구성  ( ex. int add ( int z, int b) )

: 매개변수 선언 

- 메서드가 작업을 수행하는데 필요한 값을 제공받기 위한 것

- 필요한 값의 개수만큼 변수를 선언하며 구분은 ','로 함

- 선언할 수 있는 매개변수의 개수는 거의 제한이 없지만, 배열이나 참조변수 사용

- 값을 받을 필요가 없다면 괄호안에 아무것도 적지 않음

: 메서드의 이름

- 동사인 경우가 많고, 메서드의 기능을 쉽게 알 수 있도록 함축적이면서 의미있는 이름을 사용

: 반환타입

- 메서드 작업수행 결과인 '반환값'의 타입

- 반환값이 없는 경우 반환타입으로 'void' 작성

: 메서드의 구현부

- 메서드를 호출했을 때 수행될 문장을 넣음

: return문

- 반환타입이 void가 아닌경우, 구현구 안에 'return 반환값;'을 반드시 포함

- 작업 수행 결과를 호출한 메서드로 전달

- 반환타입과 일치하거나 자동 형변환이 가능한 것

- 단 하나의 값만 반환할 수 있음


- 메서드의 호출

: 메서드 정의 후 호출하지 않으면 아무일도 발생하지 않음

: 인자와 매개변수

- 메서드를 호출할 때 괄호안에 지정한 값을 '인자' 또는 '인수'라고 함

- 인자의 개수와 순서는 호출된 메서드에 선언된 매개변수와 일치해야 함

- 인자는 메서드가 호출되면서 매개변수에 대입되므로 , 인자의 타입은 매개변수의 타입과 일치하거나 자동형변환되어야 함

: 메서드의 실행흐름

- 같은 클래스 내의 메서드끼리는 참조변수를 사용하지 않고도 서로 호출이 가능

- static메서드는 같은 클래스 내의 인스턴스 메서드를 호출할 수 없음

- 메서드가 호출되면 지금까지 실행중이던 메서드는 실행을 멈추고 호출된 메서드의 문장이 실행됨


- return문

: 현재 실행중인 메서드를 종료하고 호출한 메서드로 돌아감

: 반환타입이 void가 아닌 경우, 반드시 return문을 작성해야함


- JVM메모리 구조

: method area / heap / call stack

: method aret (메서드 영역)

- 클래스에 대한 정보 저장

: heap

- 인스턴스가 생성되는 공간, 인스턴스 변수들이 생성되는 공간

: call stack or executive stack (호출스택)

- 메서드의 작업에 필요한 메모리 공간 제공

- 메서드가 작업을 마치면 할당된 메모리 공간이 반환되어 비워짐

- 호출스택 제일 상위에 위치하는 메서드가 현재 실행중인 메서드이며 나머지는 대기상태

- 아래에 있는 메서드가 바로 위의 메서드를 호출한 메서드임


- 기본형 매개변수 

: 변수의 값을 읽기만 할 수 있음


- 참조형 매개변수

: 변수의 값이 저장된 곳이 주소를 알 수 있기 때문에 값을 읽고 변경할 수 있음


- 참조형 반환타입

: 메서드가 '객체의 주소'를 반환


- 재귀호출

: 매서드 내부에서 매서드 자신을 다시 호출하는 것

: 재귀호출하는 메서드를 '재귀메서드'라 함

: 재귀호출만 하게되면 무한히 자기 자신을 호출하기 때문에 조건문을 필수적으로 사용


- 클래스 메서드( static 메서드 ) 와 인스턴스 메서드

: 메서드 앞에 static을 붙이면 클래스 메서드, 붙어있지 않으면 인스턴스 메서드

: 메서드작업 수행 시 인스턴스 변수를 필요로하는 메서드를 인스턴스메서드로 정의, 인스턴스를 생성해야 호출가능

: 인스턴스와 관계 없는 메서드를 클래스 메서드로 정의 


- 클래스 설계 시, 모든 인스턴스에 공통적으로 사용하는 것에 static을 붙임

- 클래스 변수(static변수)는 인스턴스를 생성하지 않아도 사용 가능

- 클래스 메서드(static 메서드)는 인스턴스 변수를 사용할 수 없음

- 메스드 내에서 인스턴스 변수를 사용하지 않는다면, static을 붙이는 것을 고려

- 클래스 멤버가 인스턴스 멤버를 참조, 호출 할 때는 인스턴스를 생성해야 함

- 같은 클래스 내의 메서드는 서로 객체의 생성이나 참조변수 없이 직접호출이 가능하지만 static 메서드는 인스턴스 메서드를 호출할 수 없음

- 인스턴스멤버 간의 호출은 가능, 하나의 인스턴스멤버가 존재한다는 것은 이미 인스턴스가 생성되었다는 의미이기 때문



4. 오버로딩


- 한 클래스 내에 같은 이름을 가진 메서드가 있더라도 매개변수의 개수 또는 타입이 다르면, 같은 이름을 사용해서 메서드를 정의할 수 있음

- 한 클래스 내에 같은 이름의 메서드를 여러 개 정희하는 것을 '메서드 오버로딩', '오버로딩(overloading)'이라 함


- 오버로딩 조건

: 메서드 이름이 같아야 함

: 매개변수의 개수 또는 타입이 달라야 함


- 오버로딩의 장점

: 메서드 이름 절약 - 하나의 이름으로 여러개의 메서드를 정의할 수 있음


- 가변인자와 오버로딩

: 가변인자는 '타입...변수명' 과 같은 형식으로 선언

: 가변인자를 매개변수 중 가장 마지막에 선언

: 가변인자가 선언된 메서드를 호출할 때마다 배열이 새로 생성



5. 생성자


- 인스턴스가 생성될 때 호출되는 '인스턴스 초기화 메서드' 


- 인스턴스 변수의 초기화 작업에 주로 사용됨


- 클래스 내에 선언되며, 리턴값이 없음


- 생성자의 이름은 클래스 이름과 같아야 함


- 오버로딩이 가능하므로 하나의 클래스에 여러개의 생성자가 존재할 수 있음


1
2
3
4
5
6
7
8
9
10
class Tv{
    
    Tv() {
        //매개변수 없는 생성자
    }
 
    Tv(int a, String b) {
        //매개변수 있는 
    }        
}
cs


- 모든 클래스에는 반드시 하나 이상의 생성자가 정의되어야 함


- 소스파일(*.java)의 클래스에 생성자가 하나도 정의되지 않은 경우 컴파일러는 자동적으로 기본 생성자를 추가하여 컴파일 함

: 기본생성자 - 매개변수와 내용이 없는 생성자

: 컴파일러가 자동적으로 기본 생성자를 추가하는 경우는 클래스 내에 생성자가 하나도 없을 때 뿐


- 매개변수가 있는 생성자


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Tv{
    int channel;
    String brand;    
 
    Tv() {
        //매개변수 없는 생성자
    }
 
    Tv(int a, String b) {
        channel = a;
        brand = b;
    }        
 
}
 
class TvTest{
    public static void maint(String args[]){
        Tv t = new Tv();
        t.channel = 2;
        t.brand = samsung;
 
        Tv t2 = new Tv(8,"LG");
 
    }
}
cs


- 생성자에서 다른 생성자 호출 

: 생성자 간에도 서로 호출이 가능

- 생성자의 이름으로 클래스이름 대신 this를 사용

- 한 생성자에서 다른생성자를 호출할 때는 반드시 첫번째 출에서만 호출이 가능

: 매개변수의 이름과 인스턴스변수 이름이 같을 경우 서로 구별되지 않기때문에 인스턴스 변수이름 앞에 'this.'을 붙인다

- 만약 붙이지 않은 상태로 작성하면 둘 다 지역변수로 간주된다.


- this 

: 인스턴스 자신을 가리키는 참조변수, 인스턴스의 주소가 저장되어 있음

: 모든 인스턴스메서드에 지역변수로 숨겨진 채 존재함


- this(), this(매개변수)

: 생성자, 같은 클래스의 다른 생성자를 호출할 때 사용


- 생성자를 이용한 인스턴스 복사

: 현재 사용 중인 인스턴스와 같은 상태를 갖는 인스턴스를 하나 더 만들고자 할 때 생성자 활용 가능



6. 변수의 초기화


- 변수를 선언하고 처음으로 값을 저장하는 것

: 멤버변수는 초기화를 하지 않아도 자동적으로 변수의 자료형에 맞는 기본값으로 초기화 됨 

  ( 변수 타입 별 기본값 확인하기 http://blog.naver.com/kegljk/221034527671 )

: 지역변수는 사용하기 전에 반드시 초기화 해야 함


- 멤버변수의 초기화 방법

: 명시적 초기화

: 생성자

: 초기화 블럭

- 인스턴스 초기화 블럭 : 인스턴스 변수를 초기화 하는데 사용

- 클래스 초기화 블럭 : 클래스 변수를 초기화 하는데 사용


- 명시적 초기화

: 변수 선언과 동시에 초기화하는 것  ( ex. int age = 20; )


- 초기화 블럭

: 클래스 초기화 블럭

- 클래스 변수의 복잡한 초기화에 사용

- 클래스가 메모리에 처음 로딩될 때 한번만 수행

: 인스턴스 초기화 블럭

- 인스턴스 변수의 복잡한 초기화에 사용

- 인스턴스를 생성할 때마다 수행

- 생성자보다 인스턴스 초기화 블럭이 먼저 수행됨


- 멤버변수의 초기화 시기와 순서

: 클래스변수의 초기화시점

- 클래스가 처음 로딩될 때 단 한번 초기화

: 인스턴스 변수의 초기화 시점

- 인스턴스가 생성될 때마다 각 인스턴스 별로 초기화가 이루어짐

: 클래스변수의 초기화 순서

- 기본값 -> 명시적 초기화 -> 클래스 초기화 블럭

- 기본값 -> 명시적 초기화 -> 인스턴스 초기화 블럭 -> 생성자







반응형

'프로그래밍 > JAVA' 카테고리의 다른 글

[JAVA] 7 객체지향 프로그래밍 2-2  (0) 2017.07.21
[JAVA] 7 객체지향 프로그래밍 2-1  (0) 2017.07.11
[JAVA] 배열 예제  (0) 2017.07.04
[JAVA] 5 배열 (Array)  (0) 2017.07.03
[JAVA] 제어구조 예제 6 - while문  (0) 2017.07.02
반응형

           

  JAVA Study





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
import java.util.Arrays;
public class tistory {
    public static void main(String[] args) {
        //배열 출력
        int[] score = new int[5];
        int k=1;
        
        score[0= 50;
        score[1= 60;
        score[k+1= 70;
        score[3= 80;
        score[4= 90;
        
        int tmp  = score[k+2+score[4];
        
        for(int i=0; i<score.length; i++){ //score.length는 score배열의 길이값
            System.out.println("score ["+i+"] :"+score[i]); //score[0]~score[4] 의 합
        }
        
        System.out.println("tmp : "+tmp); // score[3] + score[4]의 값
//        System.out.println("score[7] : "+score[7]); //배열 범위를 벗어나므로 오류
        
System.out.println("====================");
        
        //배열의 복사
        int[] arr = new int[5];
        
        for(int i=0; i<arr.length; i++){
            arr[i] = i+1//배열arr에 1~5를 저장한다
        }
        
        System.out.println("[변경전]");
        System.out.println("arr.length:"+arr.length);
        
        for(int i=0;i<arr.length;i++){
            System.out.println("arr["+i+"] : "+arr[i]);
        }
        
        int[] temp = new int[arr.length*2];  // arr배열보다 두배 긴 길이의 temp 배열 생성
        
        for(int i=0; i<arr.length;i++){
            temp[i] = arr[i]; // arr배열의 값들을 temp배열에 저장
        } 
        
        arr = temp; //tmp에 저장된 값들을 arr에 저장
        
        System.out.println("[변경후]");
        System.out.println("arr.length:"+arr.length);
        
        for(int i=0;i<arr.length;i++){
            System.out.println("arr["+i+"] : "+arr[i]);
        }
        
System.out.println("====================");
        
        // 배열 일부 복사
        char[] abc = {'A','B','C','D'};
        char[] num = {'0','1','2','3','4','5','6','7','8','9'};
        System.out.println(abc);
        System.out.println(num);
        
            //배열 abc와 num을 붙여서 하나의 배열(result)로 만듦
        char[] result = new char[abc.length+num.length];
        System.arraycopy(abc,0,result,0,abc.length); 
        System.out.println(result);//ABCD
        
        System.arraycopy(num,0,result,abc.length,num.length);
        System.out.println(result);//ABCD0123456789
        
        System.arraycopy(abc, 0, num, 0, abc.length);
        System.out.println(num);//ABCD456789
        
        System.arraycopy(abc, 0, num, 63);
        System.out.println(num);//ABCD45ABC9
    
System.out.println("====================");
        
        //배열 값 총합과 평균
        int sum = 0;
        float avg = 0f;
        
        int[] score1 = {100,88,100,100,90};
        
        for(int i=0;i<score1.length;i++){
            sum += score1[i];
        }
        avg = sum /(float)score.length;
        
        System.out.println("총점 : "+sum);
        System.out.println("평균 : "+avg);
    
System.out.println("====================");
        
        //최대값 최소값
        int max = score1[0];
        int min = score1[0];
        
        for(int i=1; i<score1.length;i++){
            if(score1[i] >max){
                max = score1[i];
            } else if(score1[i]<min){
                min = score1[i];
            }
        }
        
        System.out.println("최대값 : "+max);
        System.out.println("최소값 : "+min);
System.out.println("====================");
        //섞기
        int[] numArr = new int[10];
        
        for(int i=0; i<numArr.length; i++){
            numArr[i] = i;
            System.out.print(numArr[i]);
        }
        System.out.println();
        
        for(int i=0;i<100; i++){
            int n = (int)(Math.random()*10);
            int tmp1 = numArr[0];
            numArr[0= numArr[n];
            numArr[n] = tmp1;
        }
        
        for(int i=0;i<numArr.length; i++){
            System.out.print(numArr[i]);
        }
        System.out.println();
System.out.println("====================");
        
        //로또번호 생성예제
        int[] ball = new int[45]; //45개 정수를 저장할 수 있는 배열
        
            //배열의 각 요소에 1~45의 값을 저장한다.
        for (int i=0; i<ball.length; i++){
            ball[i] = i+1;
        }
        
        int temp3 =0//두 값을 바꾸는데 사용할 임시변수
        int j=0// 임의 값을 얻어서 저장할 변수
        
            //배열의 i번째 요소와 임의의 요소에 저장된 값을 서로 바꿔서 값을 섞는다.
            //0번재 부터 5번째 요소까지 모두 6개만 바꾼다.
        for (int i=0; i<6; i++){
            j=(int)(Math.random()*45); // 0~44까지 임의의 값
            temp3 = ball[i];
            ball[i] = ball[j];
            ball[j] = temp3;
        }
        
            //배열 ball의 앞에서 부터 6개 요소 출력
        for(int i=0; i<6; i++){
            System.out.println("ball ["+i+"] = "+ball[i]);
        }
        
System.out.println("====================");
        
        //임의의 값으로 배열 채우기
        int[] code = {-4,-1,3,6,11}; //불 연속적 값으로 구성된 배열
        int[] arr4 = new int[10];
        
        for(int i=0; i<arr4.length; i++){
            int tmp4 = (int)(Math.random() * code.length);
            arr4[i] = code[tmp4];
        }
        System.out.println(Arrays.toString(arr4));
System.out.println("====================");
        //정렬하기
        int[] numArr5 = new int[10];
        
        for(int i=0; i<numArr5.length; i++){
            System.out.print(numArr5[i] = (int)(Math.random() *10));
        }
        System.out.println();
        for(int i=0; i<numArr5.length-1; i++){
            boolean changed= false//자리바꿈이 발생했는지 체크
            
            for(int j5=0; j5<numArr5.length-1-i; j5++){
                if(numArr5[j5] > numArr5[j5+1]){ //옆 자리 값이 작으면 서로 바꿈
                    int tmp5 = numArr5[j5];
                    numArr5[j5] = numArr5[j5+1];
                    numArr5[j5+1= tmp5;
                    changed = true//자리바꿈 발생 시 true로 변환
                }
            }
            
            if (!changed) break//자리바꿈 없으면 반복문 벗어남
            
            for(int k5=0; k5<numArr5.length; k5++){
                System.out.print(numArr5[k5]);
            }
            System.out.println();
        }
        
    }
}
 
cs
반응형
반응형

           

  JAVA Study






1. 배열(array) 
 

- 같은 타입의 여러 변수를 하나의 묶음으로 다루는 것


- 저장공간이 연속적으로 배치되어 있음


- 배열의 선언

: 원하는 타입의 변수를 선언하고 대괄호를 붙임 ( ex. int[] arr;  int arr[]; )


- 배열의 생성

: 연산자 'new'와 함께 배열의 타입과 길이 지정 ( ex. int[] arr = new int[5]; )


배열의 요소 : 생성된 배열의 각 저장공간


- 인덱스

: 배열의 요소마다 붙여진 일련번호, 0부터 '배열길이-1'까지 

: 인덱스로 상수 대신 변수나 수식도 사용가능하다

for(int i=0; i<5; i++) {

score[i] = i*10;

 }

: 인덱스 범위를 벗어난 값을 인덱스로 사용하면 실행 시 에러 발생


- 배열의 길이

: 배열의 요소개수, 저장 가능한 공간의 개수

: 양의 정수로 작성해야 함

: 길이가 0인 배열 생성 가능


- 배열이름,length

: JVM이 모든 배열의 길이를 별도로 관리하며, '배열이름.length'를 통해 배열 길이 정보를 얻을 수 있음

: 배열은 생성 후 길이변경이 안되므로 '배열이름.length'는 상수


- 배열 길이 변경

: 배열에 저장공간이 부족할 경우 더 큰 길이의 새로운 배열 생성 후 기존배열의 값을 복사

: 기존 배열길이의 2배 정도의 길이로 생성하는 것이 유용


- 배열의 초기화

: 생성과 동시에 자동적으로 자신의 타입에 해당하는 기본값으로 초기화 됨     ( 변수 타입 별 기본값 확인하기 http://keepitupjk.tistory.com/231 )


: 배열의 생성과 초기화를 동시에 한 예

int[] score = new int[] {5,6,7,8,9}; 

int[] score = {5,6,7,8,9};  (new int[] 생략 가능)


: 매개변수로 배열을 받는 메서드를 호출할 경우 'new int[]'를 생략할 수 없음

int add( int[] arr ) { 메서드 내용  }

int result = add ( new int[] {1,2,3,4,5} );


- 배열의 출력

: Arrays.toString(배열이름)' 메서드 사용

int[] Arr = {1,2,3,4,5};

System.out.println( Arrays.toString (Arr) );  ( 타입@주소 형식으로 출력 )


char[] chArr={'a','b','c'};

System.out.printlnArrays.toString (chArr) ); (abc 출력) 


- 배열의 복사

: 기존 배열길이의 두배 긴 배열 생성 후 내용 복사

int [] arr = new int [5];


int[] tmp = new int [arr.length * 2];     (기존 보다 2배 긴 배열 생성)


for(int i=0; i < arr.length; i++) {

tmp [i] = arr[i];    (arr[i]의 값을 tmp[i]에 저장)

}

arr = tmp;    (참조변수 arr이 새로운 배열을 가리키게 함

: System.arraycopy()를 이용해 지정된 범위의 값을 한번에 통째로 복사

System.arraycopy ( arr, 0 , tmp, 0, num.length);   (num[0] 에서 tmp[0]으로 num.length개 만큼 복사)


- 버블정렬 알고리즘 (bubble sort)

: 크기 순으로 배열 정렬

for( int i=0; i<numArr.length-1; i++ ){


changed = false;  // 매 반복마다 changed를 false로 초기화


for( int j=0; j<numArr.length-1-i; j++ ){

if ( numArr[j] > numArr[j+1] ){ // 왼쪽 값이 크면 자리를 바꿈

int tmp = numArr[j];

numArr[j] = numArr[j+1];

numArr[j+1] = tmp;


changed = true; // 자리바꿈 발생 시 true변환

}

}


if (!changed) break; // 자리바꾸면 반복문 탈출


for (int k =0; i<numArr.length; k++) {

System.out.print(numArr[k];  //정렬 결과 출력

System.out.println();

}



2. String배열
 

- String 배열 생성

String[] name = new String[3];


- String 배열 초기화

String[] name = new String[3];

name[0] = "kim";

name[1] = "Lee";

name[2] = "park";


String[] name = new String[]{"kim","Lee","park"};

String[] name = {"kim","Lee","park"};


- 참조형 배열의 경우 객체의 주소를 배열에 저장함


- String 클래스는 char 배열에 메서드를 추가한 것


- String 객체(문자열)는 읽기만 가능, 내용변경 불가


- String 클래스 주요 메서드

 메서드

설명 

char charAt(int index) 

문자열에서 해당 위치(index)에 있는 문자 반환 

 int length()

문자열 길이 반환 

String substring(int from,int to) 

문자열에서 해당범위(from~to바로 앞까지) 문자열 반환 

 boolean equals(String str)

문자열 내용이 같은지 확인, 같으면 true, 다르면 false 

char[] toCharArray() 

문자열을 문자배열(char[])로 변환해서 반환 


- char배열과 String 클래스의 변환

char chArr={'A','B','C'};

String str = new String(chArr);  // char -> String

char[] tmp = str.toCharArray(); // String-> char
 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class tistory {
 
    public static void main(String[] args) {
        
        String  src = "ABCDE";
        
        for(int i=0; i<src.length; i++){
            char ch = src.charAt(i); // src의 i번째 문자를 ch에 저장
            System.out.println("src.charAt("+i+"):" + ch);
        }
 
        // String을 char[]로 변환
        char[] chArr = src.toCharArray();
 
        // char배열(char[])을 출력
        System.out.println(chArr);
    }
}
cs



3. 다차원 배열
 

- 2차원 배열 선언

: 타입[][] 변수이름; int[][] abc;

  int[][] abc = new int[3][5];

: 각 요소에 접근하는 방법은 'abc[행 index] [열 index]'


- 2차원 배열 초기화

: int[][] abc = {{1,2,3,4,5},{10,20,30,40,50},{100,200,300,400,500}};


- for문을 통한 2차원 배열 초기화

for(int i=0; i<abc.length; i++){ // 행 index 값

for(int j=0; j<abc[i].length; j++){ // 열 index 값

abc[i][j] = 10; //모든 값을 10으로 초기화

}

}


- 가변배열

: 다차원 배열 생성 시 전체 배열 차수 중 마지막 차수의 길이를 지정하지 않고, 각기 다른 길이의 배열을 생성함으로 유동적 가변배열을 구성

int[][] score = new int[5][]; // 열의 개수 설정 안함

score[0] = new int[4]; // 행 0번에 열 4개생성

score[1] = new int[3]; // 행 1번에 열 3개생성

score[2] = new int[4]; // 행 2번에 열 4개생성

score[3] = new int[2]; // 행 3번에 열 2개생성

score[4] = new int[1]; // 행 4번에 열 1개생성


int[][] score = {

{1,2,3,4}, 

{1,2,3},

{1,2,3,4},

{1,2},

{1}

};





자바의 정석 저자 강의

- 배열



반응형

'프로그래밍 > JAVA' 카테고리의 다른 글

[JAVA] 6 객체지향 프로그래밍1  (0) 2017.07.05
[JAVA] 배열 예제  (0) 2017.07.04
[JAVA] 제어구조 예제 6 - while문  (0) 2017.07.02
[JAVA] 제어구조 예제 5 - for문  (0) 2017.07.01
[JAVA] 제어구조 예제 4 - switch문  (1) 2017.06.30
반응형

           

  JAVA Study





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
import java.util.Scanner;
 
public class tistory {
 
    public static void main(String[] args) {
        // while문
        int i=5;
        
        while(i--!=0){ // i를 1씩 감소시켜 0이 아니면 다음 문장 실행
            System.out.println(i+" - I can do it");
        } // i--가 후위형 이므로 조건식이 평가된 후에 i값이 감소 -> 4~0까지 출력
        
        // 카운트 다운
        int j = 11;
        
        System.out.println("카운트다운 시작");
        
        while(j--!=0){
            System.out.println(j);
            
            for(int k=0; k<2_000_000_000;k++){
                ; // 아무 내용 없는 빈 문장
            }
        }
        System.out.println("GAME OVER");
        
        // 사용자가 입력한 숫자 , 각 자리의 합을 구하는 예
        int num = 0, sum = 0;
        System.out.print("숫자를 입력하세요>>");
        
        Scanner scn = new Scanner(System.in);
        String tmp = scn.nextLine();
        num = Integer.parseInt(tmp);
        
        while(num!=0){
            sum +=( num%10); //num을 10으로 나눈 몫을 계속 더해 sum에 저장
            num = num/10// num값 재설정
        }
        System.out.println("각 자리수의 합 : "+sum);
        
        //do-while문
        int input1 = 0, answer1 = 0;
        
        answer1 = (int)(Math.random() * 100+1;
        Scanner scn1 = new Scanner(System.in);
        
        do{
            System.out.println("1과 100사이 정수를 입력하세요>");
            input1 = scn1.nextInt();
            
            if(input1 > answer1){
                System.out.println("더 작은 수로 다시 시도해보세요");
            } else if(input1 < answer1){
                System.out.println("더 큰 수로 다시 시도해보세요");
            }
        } while (input1 != answer1);
            System.out.println("정답입니다.");
        
            
        //break 문
        int s = 0;
        int a = 0;
        
        while (true){
            if(s<100)
                break;
            ++a;
            sum += a;
        }
        
        System.out.println("a="+a);
        System.out.println("sum="+sum);
        
        //continue문
        int menu = 0;
        int number = 0;
        
        Scanner scanner = new Scanner(System.in);
        while(true){
            System.out.println("(1) square");
            System.out.println("(2) square root");
            System.out.println("(3) log");
            System.out.print("원하는 메뉴(1~3)를 선택하세요.(종료 : 0)");
            
            String temp = scanner.nextLine();
            menu = Integer.parseInt(temp);
            
            if (!(1<=menu && menu <=3)){
                System.out.println("메뉴를 잘못 선택했어요.(종료 : 0)");
                continue
            } else if(menu == 0){
                System.out.println("프로그램을 종료합니다.");
                break;
            }
            
            System.out.println("선택하신 메뉴는 " + menu +"번 입니다.");
        }
    
    }
}
 
cs
반응형

'프로그래밍 > JAVA' 카테고리의 다른 글

[JAVA] 배열 예제  (0) 2017.07.04
[JAVA] 5 배열 (Array)  (0) 2017.07.03
[JAVA] 제어구조 예제 5 - for문  (0) 2017.07.01
[JAVA] 제어구조 예제 4 - switch문  (1) 2017.06.30
[JAVA] 제어구조 예제 3 - if문  (0) 2017.06.29
반응형

           

  JAVA Study






1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import java.util.Scanner;
 
public class tistory {
 
    public static void main(String[] args) {
        // for문
        for(int i=1; i<=5; i++){
            System.out.print(i); //i의 값 12345 출력
        }
        
        int sum=0;
        for(int i=1; i<=10; i++){
            sum+=i;
        }
        System.out.println(sum); // 1~10까지의 합 출력
        
        // 중첩 for문
        int num=0;
        
        System.out.println("*을 출력할 라인의 수를 입력하세요>");
        
        Scanner scn = new Scanner(System.in);
        int number = scn.nextInt();
        
        for(int i=0; i<number;i++){ // 입력한 라인을 출력하기 위한 for문
            for(int j=0; j<=i; j++){ // *을 반복출력하기 위한 for문
                System.out.print("*");
            }
                System.out.println();
        }
    
        // 구구단 
        for(int i=2; i<10; i++){
            for(int j=2; j<10; j++){
                System.out.println(i+" * "+j+" = "+(i*j));
            }
        }
        
        // 배열
        for(int i=1; i<5; i++){ // 행
            for(int j=1; j<5; j++){ // 열
                 System.out.printf("["+i+","+j+"]");
            }
            System.out.println();
        }
        
        for(int i=1; i<=5; i++){
            for(int j=1;j<=5; j++){
                if (i==j){
                    System.out.printf("["+i+","+j+"]");
                } else {
                    System.out.print("     ");
                }
            }
            System.out.println();
        }
        
        // 향상된 for문
        int[] arr = {1,2,3,4,5};
        int sum1=0;
        
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        
        for(int tmp : arr){
            System.out.println(tmp);
            sum1+=tmp;
        }
        
        System.out.println("sum1 = "+sum1);
        
    }
}
 
cs
반응형

'프로그래밍 > JAVA' 카테고리의 다른 글

[JAVA] 5 배열 (Array)  (0) 2017.07.03
[JAVA] 제어구조 예제 6 - while문  (0) 2017.07.02
[JAVA] 제어구조 예제 4 - switch문  (1) 2017.06.30
[JAVA] 제어구조 예제 3 - if문  (0) 2017.06.29
[JAVA] 제어구조 예제 2  (0) 2017.06.28
반응형

           

  JAVA Study





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
public class tistory {
 
    public static void main(String[] args) {
        
        //switch 문
        System.out.print("현재 월을 입력하세요>>");
        
        Scanner scn = new Scanner(System.in);
        int month = scn.nextInt();
 
        switch(month){
            case 3:
            case 4:
            case 5:
                System.out.println("현재 계절은 봄입니다.");
                break;
            case 6case 7:    case 8:
                System.out.println("현재 계절은 여름입니다.");
                break;
            case 9case 10case 11:
                System.out.println("현재 계절은 가을입니다.");
                break;
            default:
            //case 12: case 1: case 2:
                System.out.println("현재 계절은 겨울입니다.");
        }
 
 
        //switch 문
        System.out.print("가위 (1), 바위 (2), 보 (3) 중 하나를 입력하세요>>");
        
        Scanner scn1 = new Scanner(System.in);
        int user = scanner.nextInt(); // 화면으로 입력받은 값을 user에 저장
        int com = (int)(Math.random() * 3)+1// 1,2,3 중 하나가 com에 저장    
        
        System.out.println("당신은 "+user);
        System.out.println("컴은 "+com);
 
        switch(user-com){
 
            case 2case -1:
                System.out.println("당신이 졌음");
                break;
            case 1case -2:
                System.out.println("당신이 이겼음");
                break;
            case 0
                System.out.println("비겼음");
                break;
        
        }
 
        //switch 문
        System.out.print("당신의 주민번호를 입력하세요.(011234-1111222)>>");
 
        Scanner scn2 = new Scanner(System.in);
        String regNo = scn2.nextInt();
 
        char gender = regNo.charAt(7);
        
        switch(gender) {
 
            case '1'case '3':
                System.out.println("당신은 남자");
                break;
            case '2'case '4':
                System.out.println("당신은 여자");
                break;
            default : 
                System.out.println("유효하지 않은 주민번호 입니다.");
        }
 
        //switch문 중첩
        System.out.print("당신의 주민번호를 입력하세요.(011234-1111222)>>");
        
        Scanner scn3 = new Scanner(System.in);
        String regNo3 = scn3.nextInt();
        char gender3 = regNo3.charAt(7);
        
        switch(gender3) {
            case '1'case '3':
                    
                    switch(gender3){
                        case'1' :
                        System.out.println("당신은 2000년 이전 출생 남자");
                        break;
                        case'3' :
                        System.out.println("당신은 2000년 이후 출생 남자");
                        break;
                    }                
 
            break;
            case '2'case '4':
 
                    switch(gender3){
                        case'2' :
                        System.out.println("당신은 2000년 이전 출생 여자");
                        break;
                        case'4' :
                        System.out.println("당신은 2000년 이후 출생 자");
                        break;
                    }
 
            break;
            default : 
                System.out.println("유효하지 않은 주민번호 입니다.");
        }
 
    }
}
cs
반응형

'프로그래밍 > JAVA' 카테고리의 다른 글

[JAVA] 제어구조 예제 6 - while문  (0) 2017.07.02
[JAVA] 제어구조 예제 5 - for문  (0) 2017.07.01
[JAVA] 제어구조 예제 3 - if문  (0) 2017.06.29
[JAVA] 제어구조 예제 2  (0) 2017.06.28
[JAVA] 제어구조 예제 1  (0) 2017.06.27
반응형

           

  JAVA Study





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class tistory {
 
    public static void main(String[] args) {
        int x = 0;
        System.out.printf("x=0 일때, 참인것은",x);
        
        if(x==0){
            System.out.println("x==0"); // 참
        }
        if(x!=0){
            System.out.println("x!=0"); // 거짓
        }
        if(!(x==0)){
            System.out.println("!(x==0)"); //거짓
        }
        if(!(x!=0)){
            System.out.println("!(x!=0)"); //참
        }
        
        x=1;
        System.out.printf("x=1 일때, 참인것은",x);
        
        if(x==0){
            System.out.println("x==0"); // 거짓
        }
        if(x!=0){
            System.out.println("x!=0"); // 참 
        }
        if(!(x==0)){
            System.out.println("!(x==0)"); // 참
        }
        if(!(x!=0)){
            System.out.println("!(x!=0)"); // 거짓
        }
    
    }
}
 
cs



 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
public class tistory {
 
    public static void main(String[] args) {
        
        //if 문
        int input;
        System.out.print("숫자를 하나 입력하세요.>");
        
        Scanner scn = new Scanner(System.in);
        String tmp = scn.nextLine(); //화면으로 입력받은 내용을 tmp에 저장
        input = Integer.parseInt(tmp); // 입력받은 문자열(tmp)을 숫자로 변환
    
        if(input==0){
            System.out.println("입력한 숫자는 0");
        }
        if(input!=0){
            System.out.printf("입력한 숫자는 "+input); 
        }
 
 
        //if-else 문        
        System.out.print("숫자를 하나 입력하세요>>");
        Scanner scn1 = new Scanner(System.in);
        int input1 = scn1.nextInt();
 
        if(input1==0){
            System.out.println("입력하신 숫자는 0 입니다.");
        } else{
            System.out.println("입력하신 숫자는 0이 아닙니다.");
        }
 
 
        //if-else-if 문
        int score = 0;
        char grade = ' ';
 
        System.out.print("점수를 입력하세요");
        Scanner scn2 = new Scanner(System.in);
        score = scn2.nextInt();
 
        if (score >=90){ 
            grade = 'A';    // score가 90 보다 같거나 크면 A
        } else if (score >=80){
            grade = 'B';    // score가 80 보다 같거나 크면 B
        } else if (score >=70){
            grade = 'C';    // score가 70 보다 같거나 크면 C
        } else if (score >=60){
            grade = 'D';    // score가 60 보다 같거나 크면 D
        } else {
            grade = 'F';    // 나머지는 F
        } 
        System.out.println(score+"점 으로 당신의 학점은"+grade+"입니다.");
 
        //중첩 if문
        int score1 = 0;
        char grade1 = ' ';
        char opt = '0';
        System.out.print("점수를 입력하세요");
        Scanner scn3 = new Scanner(System.in);
        score1 = scn3.nextInt();
        if (score1 >=90){ 
            grade1 = 'A';    // score가 90 보다 같거나 크면 A
            if (score1 >=98){
                opt = '+';    // 90이상 중 98이상은 A+
            } else if (score1 <94){
                opt = '-';    // 90이상 중 94미만은 A-
            }
 
        } else if (score1 >=80){
            grade1 = 'B';    // score가 80 보다 같거나 크면 B
 
 
        } else if (score1 >=70){
            grade1 = 'C';    // score가 70 보다 같거나 크면 C
 
 
        } else if (score1 >=60){
            grade1 = 'D';    // score가 60 보다 같거나 크면 D
 
 
        } else {
            grade1 = 'F';    // 나머지는 F
 
 
        } 
        System.out.println(score1+"점 으로 당신의 학점은"+grade1+opt+"입니다.");
 
    }
}
cs
반응형
반응형

           

  JAVA Study



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
public class tistory {
 
    public static void main(String[] args) {
        
        //3단 출력    
        for(int i=2; i<10; i++){
            System.out.println("3 * "+i+" = "+(3*i));
        }
        
        
        //한 line에 7개 씩 출력
        for(int a=1; a<=31; a++){
            System.out.print(a+"일");
            
            if(a%7==0){
                System.out.println();
            }
        }
        
        
        //if문을 switch문으로 바꾸기
        int a = 10;
        int b = 20;
        int result = 0;
        String value="*";
        
        if(value=="+"){
            result = a+b;
        } else if(value=="-"){
            result = a-b;
        } else if(value=="*"){
            result = a*b;
        } else{
            result = a/b;
        }
        System.out.println(result);
        
        int result2 = 0;
        String value2="+";
        switch(value2){
        case "+" : result2 = a+b;
        break;
        case "-" : result2 = a-b;
        break;
        case "*" : result2 = a*b;
        break;
        case "/" : result2 = a/b;
        break;
        default : result2 = 100;
        }
        System.out.println(result2);
        
        
        //1차원 배열 출력
        int[] bb = {11,12,13};
        for(int i=0; i<bb.length;i++){
            System.out.println(bb[i]);
        }
        
        
        //구구단 1~9단 출력
        for(int i=1; i<10; i++){
            for(int j=2;j<10;j++){
                System.out.println(i+"*"+j+"="+(i*j));
            }
        }
        
        
        //for 문을 이용한 출력
        int[][] numberB={{11,12,13},{71,72,73}};
        for(int i=0; i<numberB.length; i++){
            for(int j=0;j<numberB[i].length;j++){
                System.out.println(numberB[i][j]);
            }
        }
        
        
        //합을 구하시오
        int[][] numberC = {{11,12,13},{71,72,73}};
        int sum=0;
        for(int i=0; i<numberC.length; i++){
            for(int j=0;j<numberC[i].length;j++){
                sum += numberB[i][j];
            }
        }
        System.out.println(sum);
        
        
        //아래의 결과처럼 출력하시오
        //        (결과)
        //        1*
        //        4****
        //        5*****
        
        int[] arr={1,4,5};
        for(int i=0; i<arr.length; i++){
            System.out.print(arr[i]);
            
            for(int j=0; j<arr[i];j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
 
cs


반응형

+ Recent posts