배열 (array)
: 하나의 변수로 여러 data에 접근 가능
: 배열의 이름 - 주소 저장
: 변수는 하나, 연속된 주소는 여러 개
: 길이(length), 연속된 주소(index)
: same data type - 정수 배열은 정수만, 실수 배열은 실수만 저장
: group handling - 데이터를 그룹으로 다룸
: java object - array 변수는 주소를 담고, 다른 공간에 생성
선언, 생성, 초기화
data type [] name = new data type[num] (선언 및 생성)
: [] - array
: new - java instance
: [num] - 길이(length), 1에서 시작 / index는 0에서 시작
: data type [] name / data type name [] - 둘 다 가능한 선언
: 배열 생성시, 배열의 크기(길이)를 반드시 정해야 함
: 배열 초기화 - primitive data type 배열을 생성하면 기본값으로 초기화
: 선언 후 {배열값}을 통해 배열의 생성 및 초기화 가능
: ! 선언 이후 중괄호{}를 통한 초기화 및 대입 불가
◆Example 1 (배열 선언, 생성, 초기화)
package ch04_1;
public class Ch04_1Ex02 {
public static void main(String[] args) {
// 배열 선언 : data type [] name = new data type[num]
int [] iArr1; // 선언
int iArr2 []; // 선언
iArr1 = new int[3];
iArr1[0] = 777;
System.out.println(iArr1[0] + " " + iArr1[1]);
int [] iArr3 = new int[10]; // 생성
int [] iArr4 = {1, 2, 3, 4, 5}; // 생성 및 초기화
System.out.println(iArr3[0] + " " + iArr3[1] + " " + iArr3[2]);
System.out.println(iArr4[0] + " " + iArr4[1] + " " + iArr4[2] + " " + iArr4[3] + " " + iArr4[4]);
int [] iArr5;
// iArr5 = {6, 7, 8, 9}; //error
}
}출력 결과
777 0
0 0 0
1 2 3 4 5
◆Example 2 (same data type)
package ch04_1;
public class Ch04_1Ex09 {
// same data type
public static void main(String[] args) {
double dArr[] = new double[5];
dArr[0] = 3.14; // double
dArr[1] = 99.9F; // 자동 형변환(auto data type casting)
dArr[2] = 2100000000;
dArr[3] = 'A'; //ASCII code : 자판 신호 정수
//dArr[4] = true; //error
//dArr[5] = "String"; //error
int iArr[] = new int[7];
//iArr[0] = 3.14; //error, 강제 형변환 시 입력 가능
//iArr[1] = 2200000000L; //error, 강제 형변환 시 입력 가능
iArr[2] = 'a'; //ASCII code : 자판 신호 정수
//iArr[3] = false; //error
}
}: resize 불가 - 길이(크기) 변경 불가
▶ 생성 이후 크기 변경 후 생성시, 앞선 배열을 삭제 후 새롭게 0으로 초기화 된 배열 생성
▶ Gabage Collector -> Gabage Collection
: 자바에서 사용하다가, 더 이상 사용하지 않는 메모리 회수(해제)
package ch04_1;
public class Ch04_1Ex03 {
public static void main(String[] args) {
int iArr1[] = new int[3];
iArr1[0] = 7;
iArr1[1] = 8;
iArr1[2] = 9;
System.out.println(iArr1[0] + " " + iArr1[1] + " " + iArr1[2]);
iArr1 = new int[5]; // 기존의 배열 삭제 후 0으로 초기화 된 배열 재생성
iArr1[3] = 10;
iArr1[4] = 11;
System.out.println(iArr1[0] + " " + iArr1[1] + " " + iArr1[2] + " " + iArr1[3] + " " + iArr1[4]);
}
}
출력 결과
7 8 9
0 0 0 10 11
: 배열 복사 가능
▶ System.arraycopy(arr1, scrPos, arr2, destPos, length)
arr1[srcPos]에서 length만큼의 값을 arr2[destPos]부터 복사
package ch04_1;
public class Ch04_1Ex04 {
public static void main(String[] args) {
int iArr1[] = new int[3];
iArr1[0] = 7;
iArr1[1] = 8;
iArr1[2] = 9;
System.out.println(iArr1[0] + " " + iArr1[1] + " " + iArr1[2]);
int iArr2[] = new int[10];
System.arraycopy(iArr1, 0, iArr2, 0, iArr1.length);
//iArr1[0]에서 iArr1.length만큼, iArr2[0]부터 복사
System.out.println(iArr2[0] + " " + iArr2[1] + " " + iArr2[2] + " " + iArr2[3]);
int iArr3[] = new int[10];
System.arraycopy(iArr1, 0, iArr3, 0, 1);
//iArr1[0]에서 1만큼, iArr3[0]부터 복사
System.out.println(iArr3[0] + " " + iArr3[1] + " " + iArr3[2]);
int iArr4[] = new int[10];
System.arraycopy(iArr1, 2, iArr4, 5, 1);
//iArr1[2]에서 1만큼, iArr4[5]부터 복사
System.out.println(iArr4[4] + " " + iArr4[5] + " " + iArr4[6]);
}
}출력 결과
7 8 9 0
7 0 0
0 9 0
반복문의 활용
: index를 통해 순차적 접근이 가능
package ch04_1;
public class Ch04_1Ex05 {
public static void main(String[] args) {
// 배열은 index를 통해 순차 접근 가능
int iArr1[] = new int[9];
// iArr1.length == 9 / iArr1.index : 0 ~ 8
// for문을 통한 배열 입력 및 출력
for (int i = 0; i < iArr1.length; i++) {
iArr1[i] = (i + 1) * 2;
System.out.print(iArr1[i] + " ");
}
}
}출력 결과
2 4 6 8 10 12 14 16 18
2차원 배열
: (1차원 배열)의 배열
선언, 생성, 초기화
: data type [][] name / data type [] name [] / data type name [][] - 셋 다 가능한 선언
: 2차원 배열 생성시, 1차원 배열의 수(첫 번째 [])는 반드시 지정 / 각각의 1차원 배열 길이(두 번째 [])는 다를 수 있음
: 선언 후, {{배열값1}, {배열값2}}을 통해 초기화 가능
◆Example 1
package ch04_1;
public class Ch04_1Ex06 {
public static void main(String[] args) {
// 2차원 배열 선언 방식
int [][] multiArr1;
int [] multiArr2[];
int multiArr3[][];
// 2차원 배열 생성
multiArr1 = new int[2][3];
// int[3]인 배열 2개
multiArr1[0][0] = 1;
multiArr1[0][1] = 2;
multiArr1[0][2] = 3;
multiArr1[1][0] = 4;
multiArr1[1][1] = 5;
multiArr1[1][2] = 6;
System.out.println(multiArr1[1][1]);
int [][] multiArr4 = new int[3][3]; // 선언, 생성
int [][] multiArr5 = {{1, 2}, {3, 4, 5}, {6, 7, 8, 9}};
//선언, 생성, 초기화 // 2차원 배열에 들어가는 1차원 배열의 크기는 각각 다를 수 있다.
int [][] multiArr6 = new int[3][];
// 생성시, 2차원 배열에 들어갈 1차원 배열의 수만 지정 가능 (반대 X)
multiArr6[0] = new int[2];
multiArr6[1] = new int[3];
multiArr6[2] = new int[4];
// int [][] multiArr7 = new int[][5]; //error
}
}◆ Example 2
package ch04_1;
public class Ch04_1Ex08 {
public static void main(String[] args) {
int [][] iMultiArr = {{1, 2}, {3, 4, 5}, {6, 7, 8, 9}};
System.out.println("iMultiArr.length : " + iMultiArr.length);
System.out.println("iMultiArr.length[0] : " + iMultiArr[0].length);
System.out.println("iMultiArr.length[1] : " + iMultiArr[1].length);
System.out.println("iMultiArr.length[2] : " + iMultiArr[2].length);
}
}출력 결과
iMultiArr.length : 3
iMultiArr.length[0] : 2
iMultiArr.length[1] : 3
iMultiArr.length[2] : 4
반복문의 활용
: index를 활용해 순차적 접근이 가능 (중첩 반복문 사용)
package ch04_1;
public class Ch04_1Ex07 {
public static void main(String[] args) {
int iMultiArr[][] = new int[10][10];
// for문을 통한 배열 입력 및 출력
for (int i = 0; i < iMultiArr.length; i++) {
// 2차원 배열에서 arr.length는 arr에 있는 1차원 배열의 수
for (int j = 0; j < iMultiArr[i].length; j++) {
iMultiArr[i][j] = (i + 1) * (j + 1);
System.out.print(iMultiArr[i][j] + "\t");
}
System.out.println();
}
}
}출력 결과
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
String 배열
: class typedml 배열
◆Example 1
package ch04_1;
public class Ch04_1Ex10 {
public static void main(String[] args) {
// String 배열 : class type 배열
String [] sArr = new String[6];
sArr[0] = new String("hi.");
sArr[1] = new String("hello.");
sArr[2] = new String("how are you?");
sArr[3] = new String("fine, thank you.");
sArr[4] = new String("and you?");
sArr[5] = new String("i am fine, too.");
for (int i = 0; i < sArr.length; i++) {
System.out.println(sArr[i]);
}
}
}출력 결과
hi.
hello.
how are you?
fine, thank you.
and you?
i am fine, too.
◆ Example 2
package ch04_1;
public class Ch04_1Ex11 {
public static void main(String[] args) {
// String의 2차원 배열에 구구단 식 넣기
String strArr[][] = new String[10][10];
for (int i = 0; i < strArr.length; i++) {
for (int j = 0; j < strArr[i].length; j++) {
strArr[i][j] = (i + 1) + " x " + (j + 1) + " = " + ((i + 1) * (j + 1));
System.out.print(strArr[i][j] + "\t");
}
System.out.println();
}
}
}출력 결과
1 x 1 = 1 1 x 2 = 2 1 x 3 = 3 1 x 4 = 4 1 x 5 = 5 1 x 6 = 6 1 x 7 = 7 1 x 8 = 8 1 x 9 = 9 1 x 10 = 10
2 x 1 = 2 2 x 2 = 4 2 x 3 = 6 2 x 4 = 8 2 x 5 = 10 2 x 6 = 12 2 x 7 = 14 2 x 8 = 16 2 x 9 = 18 2 x 10 = 20
3 x 1 = 3 3 x 2 = 6 3 x 3 = 9 3 x 4 = 12 3 x 5 = 15 3 x 6 = 18 3 x 7 = 21 3 x 8 = 24 3 x 9 = 27 3 x 10 = 30
4 x 1 = 4 4 x 2 = 8 4 x 3 = 12 4 x 4 = 16 4 x 5 = 20 4 x 6 = 24 4 x 7 = 28 4 x 8 = 32 4 x 9 = 36 4 x 10 = 40
5 x 1 = 5 5 x 2 = 10 5 x 3 = 15 5 x 4 = 20 5 x 5 = 25 5 x 6 = 30 5 x 7 = 35 5 x 8 = 40 5 x 9 = 45 5 x 10 = 50
6 x 1 = 6 6 x 2 = 12 6 x 3 = 18 6 x 4 = 24 6 x 5 = 30 6 x 6 = 36 6 x 7 = 42 6 x 8 = 48 6 x 9 = 54 6 x 10 = 60
7 x 1 = 7 7 x 2 = 14 7 x 3 = 21 7 x 4 = 28 7 x 5 = 35 7 x 6 = 42 7 x 7 = 49 7 x 8 = 56 7 x 9 = 63 7 x 10 = 70
8 x 1 = 8 8 x 2 = 16 8 x 3 = 24 8 x 4 = 32 8 x 5 = 40 8 x 6 = 48 8 x 7 = 56 8 x 8 = 64 8 x 9 = 72 8 x 10 = 80
9 x 1 = 9 9 x 2 = 18 9 x 3 = 27 9 x 4 = 36 9 x 5 = 45 9 x 6 = 54 9 x 7 = 63 9 x 8 = 72 9 x 9 = 81 9 x 10 = 90
10 x 1 = 10 10 x 2 = 20 10 x 3 = 30 10 x 4 = 40 10 x 5 = 50 10 x 6 = 60 10 x 7 = 70 10 x 8 = 80 10 x 9 = 90 10 x 10 = 100
객체 지향 프로그래밍 (Object Oriented Programming, OOP)
modeling
: 주체에 따라 같은 사물을 모델링해도 형태가 달라질 수 있음
: 하나의 주체에서 필요한 부분만 선별적으로 모델링 가능
▶ 개념 모델링
: 모델링 하고자 하는 대상의 개념 탐색
▶ 논리 모델링
: 모델링 하고자 하는 대상의 개념을 논리적으로 정리, 선별
▶ 물리 모델링
: 프로그래밍에 필요한 형태로 논리 모델링 결과를 반환
◎ 개념 > 논리 > 물리
◎ java 물리 모델링 결과
: public class name {멤버 변수 , 멤버 메소드}
EX. 사람 모델링
▷ 개념 모델링 : 이름, 나이, 키, 몸무게, 혈액형, 최종학력, 직업, 자격증, 주소, 전화번호, etc.
▷ 논리 모델링 (이력서)
: 이름, 생년월일, 최종학력, 경력, 자격증, 주소, 전화번호, etc.
▷ 물리 모델링 (java)
public class person {
String name;
String birthday;
String address;
String phoneNum;
// etc
}Class
: 현실을 모델링한 결과를 프로그램에 적용하기 위해 만든 java 설계도
: ~.java 파일 내부에 있는 class 선언은 new를 통해 메모리에 load
: 메모리에 올라간 class를 instance라 부름
: 하나의 class는 instance를 제한없이 생성 가능
: java에서 모델링 > class 파일 설계
: 재사용성을 위해 사용
◎ static
: 선언된 부분은 즉시 메모리 load
→ main은 static이기 때문에 new 없이 메모리 load
→ 프로그램 실행 내내 메모리에 load 된 상태로 유지(비효율)
구성 요소
: package, import, 멤버 변수, 멤버 메소드(method), 생성자(특수한 메소드)
▶ 메소드 (method)
: 동적인 수행을 담당
: 어떤 목적을 수행하기 위해, class 내부에 선언된 코드 블럭
▷ 접근 제한자 + return type + 메소드 이름 + 파라미터(arguments)
: return type - 이 메소드의 수행 결과로 도출되는 data의 type
: 파라미터(arguments) - 이 메소드를 수행하기 위해 필요한 data를 입력 받는 공간
: return - 메소드 수행 결과
package ch04_2;
public class Ch04_2Ex01 {
public static void main(String[] args) {
Ch04_2Ex01 ch4 = new Ch04_2Ex01();
ch4.print();
ch4.plus(777, 8);
System.out.println(ch4.comPareStringLength("hello", "world"));
}
public void print() {
// void : 없다 - return type X (실행만 할 뿐, 값 반환 X)
System.out.println("출력 메소드");
}
public void plus(int iVar1, int iVar2) { // arguments
System.out.println(iVar1 + iVar2);
}
public boolean comPareStringLength(String str1, String str2) {
if (str1.length() == str2.length()) return true;
else return false;
}
}출력 결과
출력 메소드
785
true
▶ 멤버 변수
: 정적인 data
