플레이데이터 백엔드 개발 8기 2주차 회고

1. 배웠던 것

---

1. 표준 입/출력

자바의 표준 출력은 크게 3가지로 나누어진다.

1. 줄 개행을 포함하지 않는 print();
2. 자동으로 줄 개행 기능을 포함하는 println();
3. 형식 지정 표준 출력 함수 printf();

System.out.print("개행없이 출력해볼까요");
System.out.println(" 개행 기능 포함 출력");
System.out.print("안녕하세요");
System.out.println(" 안녕히 가세요");

/*
개행없이 출력해볼까요 개행 기능 포함 출력
안녕하세요 안녕히 가세요
*/

• 코드를 보면 print()의 경우, 내용을 출력한 후 다음 출력을 위한 커서가 그 자리에 머물게 되어, 다음 문장이 가로로 이어서 붙어서 줄력
• 이와 반대로 println()은 내용 출력한 후, 다음 출력을 위한 커서가 한 줄 아래에 머물게 됨.

 

• printf()는 서식 문자를 활용하여 먼저 문자열을 완성시키고, 서식 문자에 들어갈 값을 지정해서 출력하는 방식이다.
• printf()는 print()와 마찬가지로 줄 개행 기능이 없어, "\n"과 같이 따로 줄 개행 명령을 내려줘야한다.

/*
		 # 포맷팅 서식 문자 종류
		 %d: 부호가 있는 정수 데이터 (decimal)
		 %f: 실수 데이터 (floation point)
		 %s: 문자열 (String)
		 
		 # 탈출 문자 (escape sequence) -> printf에만 동작하는 게 아니에요.
		 - 반드시 따옴표 내에 위치해야 합니다
		 - 문자열 내에서 특정 명령을 내리고 싶을 때 사용하는 특수 기호입니다.
		 \n: 줄 개행 명령
		 \t: 가로 공백 (스페이스 4칸)
		 \\: 백슬래시 문자를 나타낼 때 사용.
     \': 홑 따옴표를 문자로 출력할 때 사용
     \": 쌍 따옴표를 문자로 출력할 때 사용
		 */
		
		int month = 12;
		int day = 25;
		String anni = "크리스마스";
		
		//12월 25일은 크리스마스 입니다.
		System.out.println(month + "월 " + day + "일은 " + anni + " 입니다.");
		System.out.printf("%d월 %d일은 %s입니다.\n", month, day, anni);

		//실수를 표현하는 서식문자 %f -> 기본 6자리까지 표현.
		//%.[자리수를 지정하는 숫자]f -> 원하는 자리수까지 표현.
		//%라는 문자 자체를 표현할 때는 %% 쓰시면 됩니다.
		double rate = 64.126;
		System.out.printf("합격률은 %.2f%%입니다.", rate);

1 - 1. 표준 입력

• Scanner라는 이름을 가진 객체를 기본적으로 제공해서 입력을 받을 수 있게함.
• Scanner 객체 생성 방법

import java.util.Scanner; // 1. Scanner 클래스의 정보를 import
Scanner sc = new Scanner(System.in); // 2. Scanner 객체를 생성한다.

/*
new Scanner(System.in);
-> 새로운 스캐너 객체를 생성한다. 괄호 안에는 자바의 표준 입력 명령을 전달한다.
그리고 나서 sc라는 변수에 스캐너 객체를 담는다. 그렇다면 sc의 타입은
스캐너를 담고 있으니 타입이 Scanner 겠구나~ 
정도로 해석하면 충분하다.
변수명은 in, input, sc, scan 뭐든 좋다. 이 네 개를 주로 많이 쓴다.
*/

/*
		 3. Scanner의 함수들을 이용하여 데이터를 입력받을 수 있습니다.
		 - next(): 공백이 없는 문자열을 입력 받습니다.
		 - nextLine(): 공백을 포함한 문자를 입력 받습니다.
		 - next + 기본타입이름(): 해당 타입에 맞는 데이터를 입력 받습니다.
		 ex)
		 	nextInt(): 정수 데이터를 입력 받습니다.
		 	nextDouble(): 실수 데이터를 입력 받습니다.
			nextBoolean(): 논리형 데이터를 입력 받습니다.
			nextLong(): 정수(long) 데이터를 입력 받습니다. 

			**char 데이터를 받는 메서드는 따로 없습니다. 한 글자여도 문자열로 받으세요.
*/
		
// 3. Scanner가 제공하는 메서드를 이용해서 입력값을 받기
System.out.print("이름: "); //무엇을 입력할 지 간단한 출력문을 쓰자.
String name = sc.next(); //입력받은 문자열을 next()가 받아서 name에 할당해 준다.
		
System.out.print("나이를 입력하세요: ");
int age = sc.nextInt(); //입력받은 정수를 nextInt()가 받아서 age에 할당해 준다.
		
System.out.println("제 이름은 " + name + "이고, 나이는 " + age + "세 입니다.");
System.out.printf("제 이름은 %s이고, 나이는 %d세 입니다.", name, age);

sc.close(); // Scanner 객체를 반납

• 여기서 헷갈릴 수 있는 next(), nextLine()의 차이점

-  우선 2개 다 String을 받는다는 공통점이 있지만, next()는 공백을 기준으로 공백 전 까지의 문장만을 읽어 들인다.

반대로 nextLine()은 한 줄에 입력된 여러 문장을 공백까지 포함해서 읽을 수 있다.

---

2. 조건문

- 특정 조건에 따라 별도의 명령을 수행하도록 제어하는 명령문.

2 - 1. if / else if / else

• if 옆에 작성된 괄호 안에 논리형 조건식을 작성, 그리고 그 조건식이 true면 if  안에 있는 코드 블럭을 실행.
• else if의 경우에는 if 뒤에 따라붙어야 하는 조건문으로, 앞의 if 문이 실행되지 않는 조건에서 else if문의 조건이 참이면 else if 안에 있는 코드 블럭을 실행한다.
• else문은 앞에 있는 모든 조건이 false일 때 실행되는 블록. 즉, else if / if문 모두 실행되지 않았을 때 실행.

// if문의 형태
if (조건식) {
    // 괄호 안의 조건이 true일 때, 실행 할 코드
} else if (조건식2) {
    // 위의 if문의 조건식이 false이고, 조건식2가 true일 때 실행 할 코드
} else {
    // 위의 조건식, 조건식2 모두 false일 때 실행할 코드
}

• 만약 첫 번째 조건이 참이고, 이것을 더 세부적으로 조건을 나누고 싶다면 if문 안에 또 다른 if문을 넣을 수 있다. (중첩 if문)

if (조건식1) {
    if (조건식2) {
        // 조건식1과 조건식2가 모두 참일 때 실행할 코드
    }
} else {
    // 조건식1이 거짓일 때 실행할 코드
}

2 - 2. switch, case 문

• switch문은 기준이 되는 변수나 식의 결과에 따라서 여러 개의 case문 중 하나를 선택하여 실행하는 제어문이다.

switch (변수 또는 수식) {
	case 첫번째 값:
        // 첫번째 값이 맞을 경우, 출력되는 코드 
        break;
    case 두번째 값:
        // 두번째 값이 맞을 경우, 출력되는 코드
        break;
    case 세번째 값:
    case 네번째 값:
        // 세번쨰, 네번째 값이 맞을 경우, 출력되는 코드
        break; // switch문을 빠져나가게 해주는 역할, 작성하지 않을 경우 코드가 이어서 진행하게됨.
    default: // 일치하는 case문이 없으면 실행되는 곳 (안써도 무방하다.)
        // 모든 case문이 해당되지 않을 때, 출력되는 코드
        break;
}

• switch문 내부의 변수 또는 수식은 반드시 정수/문자/문자열 타입만 가능. 
• case문 뒤에는 반드시 콜론(:)을 붙인다.

---

3. 반복문

특정한 조건이나 횟수에 따라서 코드 블럭을 반복적으로 실행시키고 싶을 때 사용하는 문법
여러 곳에 자주쓰이는 형태 중 하나이다.
보통 while / for 키워드를 사용한다.

3 - 1. while 문

// while문의 기본적인 형태

while (조건식) {
	// 실행될 코드
}

• 이 때, 조건식이 true인 동안 반복문이 계속해서 실행된다. (false가 되면 종료)
• 그러므로 무한 반복문을 만들 목적이 아니라면, 따로 변수를 선언하여 반복문의 횟수를 조절해야한다.

// while문 예시

int cnt = 1; // 제어 변수 : 반복문의 횟수를 제어할 변수. (begin)
int total = 0; 

while(cnt <= 5) { // 논리형 조건식 : 반복문의 끝을 지정. (end)
    total += cnt;
    cnt++; // 증감식 : 반복문의 종료를 위해 제어 변수의 값을 조정 (step)
}

System.out.println(total); // 15

• while문을 실행시키기 위한 필수 3요소인 begin, end, step이 있음.
• 만약 이 3요소 중 하나라도 누락될 경우에는 반복문이 이상하게 돌아갈 수 있음.
• while문의 진행 순서.

1. 제어 변수를 선언함. (시작값이 정해짐)
2. while문의 조건식을 검사하여 true면 반복문이 시작. false라면 반복문 종료.
3. while문 블록 내부가 한번 진행되면 다시 조건식을 검사하여 true라면 반복문 계속 진행. false라면 종료.
4. 반복문 내에 증감식을 넣어 제어 변수 값을 조정.

3 - 2. for문

// for문
for (초기화; 조건식; 증감식) {
	// 실행될 코드
}

• for문의 경우, 초기화/ 조건식/ 증감식/ 코드로 구성되어 있음. 즉, while의 3요소가 괄호 안에 한번에 지정되는 것.

// for문의 간단 예제

int total = 0;

for (int i = 0; i <= 10; i++) {
	total += i;
}

System.out.println(total); // 55

• 그럼 어떤 상황에서 while 또는 for을 써야할까?

- 시작과 끝 범위가 확실한 반복의 경우에는 for문을 더 많이 사용.

- 횟수보다는 조건에 따라 반복을 진행할 때는 while을 더 많이 사용.

3 - 3. 반복문 중첩

• 반복문 안에 다른 반복문이 들어간 구조.
• 말 그대로 반복문 자체를 반복해야 하는 경우에 사용하는 구조.

// 반복문 중첩 예시

for(int dan=2; dan<=9; dan++) {
	System.out.println("구구단 " + dan + "단");
	System.out.println("---------------");
	for(int hang=1; hang<=9; hang++) {
		System.out.printf("%d x %d = %d\n"
				, dan, hang, dan*hang);
	}
	
	System.out.println("---------------");	
}

• 반복문 중첩의 진행 순서

1. 바깥쪽 반복문을 우선 실행한다.
2. 안쪽 반복문을 실행한다.
3. 안쪽 반복문이 모두 실행이 되었다면, 다시 바깥쪽 반복문으로 돌아가서 반복을 진행한다.
4. 바깥쪽 반복문이 false가 될 때까지 반복한다.

• 반복문 중첩에서는 조건식 / 증감식 등을 세밀하게 조정해야 한다. 보통 바깥쪽 반복문의 제어 변수가 내부 반복문에 영향을 미치게 된다.
• 따라서 중첩 반복문을 작성할 때, 반복문의 흐름을 정확하게 파악할 수 있어야 한다.

// 중첩 반복문을 이용한 별표 피라미드 만들기



/*
         *
         **
         ***
         ****
         *****
 */
       Scanner scanner = new Scanner(System.in);
        int star = scanner.nextInt();
        for (int i = 1; i <= star; i++) {
            for (int j = 0; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        };

        /*
            *
           **
          ***
         ****
        *****
         */


         for (int i = 1; i <= star; i++) {
            // 졀 찍기 전에 공백부터 만드는 for문
            for (int k = star - 1; k >= i; k--) {
                System.out.print(" ");
            }
            // 별찍는 for문
            for (int j = 0; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        };

        /*
        *****
        ****
        ***
        **
        *
         */
        for (int i = 1; i <= star; i++) {
            // 졀 찍기 전에 공백부터 만드는 for문
            for (int k = 0; k < i - 1; k++) {
                System.out.print(" ");
            }
            // 별찍는 for문
            for (int j = star; j >= i; j--) {
                System.out.print("*");
            }
            System.out.println();
        }

---

4. 탈출문

프로그램의 실행을 특정 상황에서 강제로 종료시키는 역할을 당담.
자바에서는 break, continue, return 키워드를 사용한다.

4 - 1. break

• 반복문이나 switch문을 빠져 나올 때 주로 사용.
• 반복문에서 break문을 사용하면 해당 키워드가 들어있는 반복문 블록을 빠져 나온다.
• switch문에서 break문을 사용하면, 해당 case문을 탈출.

for (int i = 0; i <= 5; i++) {
	if (i == 3) {
    	break; // i가 3일 때, break문을 만나 반복문을 빠져나오기 떄문에 0부터 2까지만 출력.
    }
    System.out.println(i);
}
System.out.println("\n반복문 종료!");

• label을 사용하면 원하는 특정 반복문까지 한번에 탈출 가능.

4 - 2. 무한 루프

반복 횟수를 정하지 않고, 무한하게 반복하는 구조.
주로 사용자 입력을 받는 프로그램에서 많이 사용된다.

// while문의 무한 루프

while (true) {
	// 반복할 코드
}

// for문의 무한 루프

for (;;) {
	// 반복할 코드
}

• 이러한 무한 루프는 조건식으로는 탈출할 수 없어서, 반드시 특정 조건을 통해 탈출문을 사용하여 루프를 빠져나올 수 있게 해야한다.

4 - 3. continue

continue는 반복문에서 현재 반복을 건너뛰고 다음 반복을 실행하도록 한다.
반복문을 중간에 깨부수고 탈출하는 break와 달리, continue는 지정된 반복 횟수를 다 돌고 종료가 된다.

• for문에서 사용하면 증감식이 실행되고, while문에서는 조건식으로 흐름이 이동된다.

* return문은 메서드에서 값을 반환하고, 메서드를 종료시키는 역할. (후에 말할 메서드에서 언급)

---

5. 배열

같은 타입의 데이터를 하나의 변수에 저장하는 자료구조이다.
같은 데이터 유형 변수를 여러 개 선언해야 하는 불편함을 줄이기 위해 사용.
자바에서 배열은 고정된 크기로 선언되며, 크기를 변경할 수 없다.
배열은 동종모음 구조이기 때문에, 같은 데이터 타입끼리만 모여있을 수 있다.

// 배열 선언 및 초기화

int[] arr = new int[5];
System.out.println(Arrays.toString(arr)); // [0, 0, 0, 0, 0]

// int데이터 타입에 대한 배열이므로 int형을 제외하고는 배열안에 접근할 수 없다.
arr[0] = 1;
arr[1] = 2;
arr[2] = arr[0];
arr[3] = (int) 3.145;
arr[4] = 100;
// arr[2] = "str"; (x)
// arr[10] = 1500; (x)

System.out.println(Arrays.toString(arr)); // [1, 2, 1, 3, 100]

• 인덱스는 0부터 시작하기 때문에, 마지막 인덱스는 항상 배열의 길이보다 하나 작다.
• 배열변수명.length 프로퍼티를 이용하면 쉽게 배열의 길이를 파악할 수 있음.

System.out.println("arr 배열의 길이: " + arr.length); //5

• 배열 생성 시, 값을 지정하여 초기화할 수 있다.

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

• 배열의 사용

// 값을 꺼내고 싶을 때, 인덱스를 사용하면 된다.

int[] nums = {1, 2, 3, 4, 5};
System.out.println(numbers[2]); // 3
System.out.println(numbers[4]); // 5

// 배열의 요소를 반복적으로 처리하기 위해서는 for문을 이용할 수 있음.

for (int i = 0; i < nums.length; i++) {
	System.out.println(i);
} 
/*
1
2
3
4
5
*/

// 배열 내부를 문자열 형태로 확인하고 싶다면 toString()을 사용.

System.out.println(Arrays.toString(numbers)); // [1, 2, 3, 4, 5]

// 배열 변수를 그대로 출력할 경우,해당 주소값이 나온다. (이유는 배열은 객체 타입이기 때문이다!)

System.out.println(numbers); // 알수없는 주소값이 출력.

5 - 1. for - each 문 (향상된 for 문)

• 자바 5부터 추가된 기능으로 배열과 컬렉션에서 사용할 수 있음.
• 인덱스의 사용 없이, 배열 내부 요소를 전체 참조할 수 있게 도와줌.

for (배열 요소를 받을 수 있는 변수 : 배열 또는 컬렉션 이름) {
    // 실행문;
}

// 예시

String[] week = {"월", "화", "수", "목", "금", "토", "일"};

/*
for(int i=0; i<week.length; i++) {
	System.out.println(week[i] + "요일 좋아~!");
}
*/

for(String day : week) {
	System.out.println(day + "요일 좋아~");
}

• 반복문의 인덱스 변수의 선언이 필요없어 코드가 깔끔해지고, 구조적 변화가 없는 한 for문 보다 빠르다는 장점이 있다.
• 하지만, 인덱스 정보를 알 수 없고 범위를 세밀하게 지정할 수 없다. 또한 요소를 삭제할 수 없는 단점이 있다.

5 - 2. 배열의 수정

// 배열 내부의 데이터 수정은 해당 인덱스에 접근하여 값을 밀어넣으면 된다.

String[] foods = {"삼겹살", "족발", "피자", "햄버거"};
foods[0] = "치킨";
foods[2] = "탕수육";

System.out.println(Arrays.toString(foods)); // {"치킨", "족발", "탕수육", "햄버거"}

5 - 3. 배열 인덱스 탐색

Scanner sc = new Scanner(System.in);
System.out.print("탐색할 음식을 입력하세요: ");
String name = sc.next();

// 첫번째 방법
// boolean 타입의 변수를 선언하여 존재 유무를 확인해 준다.
// 찾았으면 true로, 반복문 다 돌릴 때 까지 못찾았으면 false로.
// 반복문이 끝나고 나서 확인해 주자.
boolean flag = false;
for(int i=0; i<foods.length; i++) {
	if(name.equals(foods[i])) {
		System.out.println("탐색 완료!");
		System.out.println("인덱스: " + i + "번");
		flag = true;
		break;
	} 		
}

if(!flag) { //flag == false
	System.out.println("없는 음식입니다.");
}


// 두번째 방법.
// 탐색하지 못한다면 반복문이 끝까지 돌아가면서 i의 값이 배열의 길이와 같아지며
// 반복문의 조건식을 false로 만들면서 탈출하는 것을 이용.
// i가 배열의 길이와 같아졌다면 탐색하지 못했다는 증거.
int i;
for(i=0; i<foods.length; i++) {
	if(name.equals(foods[i]) {
		System.out.println("탐색 완료!");
		System.out.println("인덱스: " + i + "번");
		break;
	}
}

if(i == foods.length) {
		System.out.println("없는 음식입니다.");
}

5 - 4. 배열의 삭제

// 원하는 위치의 값 삭제하기
int[] number = {1, 3, 5, 7, 9, 11};
int targetIndex = 3;

// 타켓 인덱스를 기준으로 뒤에 있는 값을 한 칸씩 땡겨오기 (마지막 데이터 전까지)
for (int i = targetIndex; i < (number.length - 1); i++) {
	number[i] = number[i + 1];
}

// 크기가 하나 작은 배열 선언
int[] temp = new int[number.length - 1];

// 배열 내부 데이터 복사
for (int i = 0; i < temp.length ; i++) {
     temp[i] = number[i];
 }

// 주소값 이전
number = temp; temp = null;

System.out.println(Arrays.toString(number));

// numbers[2] = numbers[3]; // 1, 3, 7, 7, 9, 11
// numbers[3] = numbers[4]; // 1, 3, 7, 9, 9, 11
// numbers[4] = numbers[5]; // 1, 3, 7, 9, 11, 11
// numbers[5] = numbers[6]; (x)

5 - 5. 배열 삽입

// [10 50 66 90 100 150]
int[] arr = {10, 50, 90, 100, 150};
int newNumber = 66;
int targetIndex = 2;

// 50과 90사이에 66을 삽입하고 싶다.

// 1. 사이즈가 1개 큰 새로운 배열을 생성
int[] temp = new int[arr.length + 1];

// 2. 기존 데이터를 새 배열에 복사
for (int i = 0; i < arr.length; i++) {
	temp[i] = arr[i];
}

// 3. 삽입 위치에서 데이터를 뒤로 한 칸씩 이동시키자.
// 이동 순서는 끝에서부터 시작해야 한다.

for (int i = arr.length; i > targetIndex ; i--) {
	temp[i] = temp[i - 1];
}

// 4. 새로운 데이터를 타겟 인덱스에 할당
temp[targetIndex] = newNumber;

        // 5. 주소값 이전
        arr = temp; temp = null;
        System.out.println(Arrays.toString(arr));

5 - 6. 배열 pop

// pop: 배열의 맨 끝 데이터를 삭제하면서 꺼내옴.
int[] nums = {10, 20, 30, 40, 50, 60};

// 1. 기존 배열보다 크기가 1개 작은 배열을 생성
int[] temp = new int[nums.length - 1];

// 2. 원본 배열에서 맨 끝 인덱스를 제외한 나머지 내용 복사
for (int i = 0; i < temp.length ; i++) {
	temp[i] = nums[i];
}

// 3. 삭제값 백업
int removedNumber = nums[nums.length - 1];

// 4. 주소값 이전
nums = temp; temp = null;

System.out.println(Arrays.toString(nums));
System.out.println("삭제된 값은 " + removedNumber + "입니다.");

---

6. 2차원 배열

• 기본적인 형태

// 3행 4열의 int형 2차원 배열

int[][] arr2d = new int[3][4];

/* {
	{0, 0, 0, 0},
	{0, 0, 0, 0},
	{0, 0, 0, 0}
} */

6 - 1. 2차원 배열의 값 삽입 및 수정

// 2차원 배열에 값 넣기
arr2d[1][2] = 50;
arr2d[2][0] = 70;


// 결과
{
	{0, 0, 0, 0},
	{0, 0, 50, 0},
	{70, 0, 0, 0}
}

6 - 2. 2차원 배열의 반복문

for(int i=0; i<arr2d.length; i++) {
	// i는 지금 작은 배열 덩어리를 지목하는 것.
	for(int j=0; arr2d[i].length; j++) {
		// j는 작은 배열 덩어리 안의 데이터를 지목하는 것.
		System.out.println(arr2d[i][j]);
	}	
}

• 관련 예시

        int[][] score = {
                {79, 80, 99}, // A 학생
                {49, 65, 12}, // B 학생
                {86, 75, 90}, // C 학생
                {100, 34, 89}, // D 학생
        };


        String[] stuName = {"A학생", "B학생", "C학생", "D학생"};
        String[] subName = {"국어", "영어", "수학"};

        /*
         1. 각 학생의 평균을 소수점 첫째 자리까지 출력해 보세요.
         2. 각 과목의 평균을 출력해 보세요.
         3. 반 평균을 출력해 보세요. (모든 학생들의 평균을 더해서 학생수로 나누기)
         */
        double totalAvg = 0.0; // 학생들의 평균점수의 총합.


        int idx = 0; //stuName 배열에서 학생 이름을 지목할 용도
        for (int[] ints : score) {
            int total = 0;
            for (int i : ints) {
                total += i;
            }
            double avg = (double) total / subName.length;
            totalAvg += avg;
            System.out.printf("%s의 평균: %.1f점\n", stuName[idx], avg);
            idx++;
        }

        System.out.println("==================================================");

        for (int i = 0; i < subName.length; i++) {
            int total = 0;
            for (int j = 0; j < stuName.length ; j++) {
                total += score[j][i];
            }
            double avg = (double) total / subName.length;
            System.out.printf("%s의 평균 점수: %.1f점\n", subName[i], avg);
        }

        System.out.println("===================================");


        double classAvg = totalAvg / stuName.length;
        System.out.printf("우리반 평균: %.1f점\n", classAvg);

---

7. 메서드 (Method)

메서드는 반복되는 코드 블록에 이름을 붙여 놓은 것을 말한다.
반복되는 코드를 줄여주고, 좀 더 구조화를 만들어 코드의 가독성을 높여준다.

// 메서드의 기본적인 구조

[리턴타입] [메서드명](매개변수) {
    // 메서드의 기능 구현
}

1. 리턴 타입 : 메서드가 실행 후 반환하는 데이터 타입을 설정. (반환할 값이 없는 경우에는 void)
2. 메서드명 : 메서드의 이름을 설정. 식별자의 규칙에만 맞게 지어주면 됨.
3. 매개변수 : 메서드를 실행할 때 필요로 하는 값의 데이터 타입과 이름을 설정. 물론 매개변수가 없는 경우에는 비워주면 된다.
4. 메서드의 기능 구현 : 메서드가 수행할 기능을 구현하는 코드 블록.

• 메서드를 선언할 때, 클래스 블록에 선언해야 한다. (메서드 안에서는 메서드를 선언할 수 없음.)
• 코드를 작성하던 public static void main(String[] args)도 메서드이다. 즉, main 안에는 메서드를 선언할 수 없다.

public class Main {

// 메서드 선언 가능

    public static void main(String[] args) {

    }
    
    // 메서드 선언 가능 
}

public class MethodExample1 {

    // 메서드의 선언
    static int calcTotal(int end) {
        int total = 0;
        for (int i = 1; i <= end; i++) {
            total += i;
        }
        return total;
    }

    public static void main(String[] args) {
        int total = calcTotal(10);
        System.out.println(total);
        System.out.println(calcTotal(100));
        System.out.println(calcTotal(200));
        System.out.println(calcTotal(300));
        System.out.println(calcTotal(400));
        System.out.println(calcTotal(500));

• 메서드의 호출은 곧 메서드를 사용하겠다는 것과 같은 말이다.

1. 메서드가 필요로 하는 데이터를 호출부에서 전달하면
2. 그 값을 받아 메서드 내부로 전달하고, 로직이 실행.
3. 실행 결과값을 메서드를 호출한 곳을 다시 반환
4. 변환된 값은 변수에 담아서 저장하거나, 출력하는 등 다양하게 사용.

7 - 1. 매개변수 (parameter)

메서드를 호출할 때, 메서드 실행에 필요한 값들을 메서드 내부로 전달하는 매개체 역할을 하는 것.
어떤 매개체를 전달하느냐에 따라 메서드의 실행 결과는 언제든지 달라질 수 있음.
()안에 미리 개수와 타입을 지정함. 물론 하나도 선언하지 않을 경우에는 () 내부를 비워서 호출

// 일반적인 매개변수 사용 
    
    static int calcRangeTotal(int start, int end) {
        int total = 0;
        for (int i = start; i <= end; i++) {
            total += i;
        }
        return total;
    }
    
        int result = calcRangeTotal(3, 7);
        System.out.println("result = " + result);
        
// 매개변수 없을 경우

    static String selectRandomFood() {
        double rn = Math.random();
        if (rn > 0.66) {
            return "치킨";
        } else if (rn > 0.33) {
            return "족발";
        }
        return "햄버거";
    }
    
        String string = selectRandomFood();
        System.out.println("오늘 점심 뭐먹지??: " + selectRandomFood());
        
// 정수 n개를 전달하면 그 정수들의 평균을 리턴하는 메서드 (매개변수에 배열을 넣어 해결한다.)
    static double calcAverage(int[] nums) {
        int total = 0;
        for (double num : nums) {
            total += num;
        }
        return (double) total / nums.length;
    }
    
        int[] arr = {30, 50, 70, 90, 12, 33};
        double average = calcAverage(arr);
        System.out.println("average = " + average);
        
// 가변 파라미터를 사용한 매개변수 작성
// ...로 나열되어 들어오는 여러개의 값을 배열로 묶어서 메서드 내부로 전달합니다.
    static double calcAverage2(int... nums) {
        int total = 0;
        for (double num : nums) {
            total += num;
        }
        return (double) total / nums.length;
    }
    
        double average2 = calcAverage2(1, 2, 3, 4, 2, 2384, 23423, 435);
        System.out.println("average2 = " + average2);

* 자바는 반드시 매개변수의 개수와 타입에 맞게 인수를 전달해야 한다.

7 - 2. return

반환값이란, 메서드의 실행 결과값을 의미.
여러 개 존재할 수 있는 매개변수와 달리, 반환값은 오직 한 개만 존재해야 한다.
return이라는 키워드를 사용하고, return뒤에 전달할 값을 지정한다.
반환값이 있는 메서드는 호출문 자체가 하나의 값으로 처리될 수 있기 때문에 반환값을 다른 변수에 대입하거나, 다른 메서드의 매개값으로도 처리될 수 있음.

static int add(int n1, int n2) {
	return n1 + n2;
}

/////////////////////////////////////

int r1 = add(3, 8); //int r1 = 11;
int r2 = add(10, 15); //int r2 = 25;

// 리턴값이 있는 메서드는 메서드 호출문이 곧 리턴값으로 처리될 수 있기 때문에, 
// 다른 메서드의 매개값으로도 사용이 가능.

int r3 = add(add(4,6), add(7,8)); // int r3 = add(10, 15) -> int r3 = 25

static int[] operateTotal(int n1, int n2) {
		//return n1 + n2;
		//return n1 - n2; 하나의 메서드가 여러 번 리턴할 수는 없다.

		//여러개의 값 리턴하고 싶으면 배열에 싸서 보내셈.
		return new int[] {add(n1, n2), n1-n2, n1*n2, n1/n2};
}

// void일 경우에는 return을 생략해도 된다.
// 반환값이 없는 void 타입의 메서드는 값이 돌아오지 않기 때문에 
// 실행 결과를 변수에 저장할 수 없으며, 다른 메서드의 매개값으로도 사용이 불가능. (반드시 단독 호출 사용)
// void메서드는 단순히 동작을 지시하는 역할을 수행.

static void multi(int n1, int n2) {
		int result = n1 * n2;
		System.out.printf("%d x %d = %d\n", n1, n2, result);
}

//////////////////////////////////////////////////

//		int r4 = multi(10, 7); (x)
//		System.out.println(multi(10, 7)); (x)
		multi(10, 7);
		multi(add(3,4), add(4,7));
//		add(multi(4,4), multi(5,6)); (x)


// 모든 메서드는 return을 만나면 강제로 메서드가 종료됨.
// 따라서 조건 없이 return문 아래에 코드를 작성할 수 없음.
// void메서드에서는 return키워드를 탈출 기능으로 사용이 가능.

static void divide(int n1, int n2) {
		if(n2 == 0) {
			System.out.println("0으로 나누지 마세요!");
			return;
		}
		int result = n1 / n2;
		System.out.printf("%d / %d = %d\n", n1, n2, result);
	}

---

8. 객체 지향 프로그래밍

객체란, 데이터와 그 데이터를 처리하는 함수들을 묶어놓은 하나의 독립적인 단위. 
이렇게 하나의 단위로 묶어 놓으면 코드의 가독성이 좋아지고, 유지 보수가 편리하여 대규모 프로그램을 개발할 때 유용함.

//빨간 펜
int redPenPrice = 500;
String redPenColor = "빨강";
String redPenNo = "a001";

//파랑 펜
int bluePenPrice = 800;
String bluePenColor = "파랑";
String bluePenNo = "a002";

//검정 펜
int blackPenPrice = 1000;
String blackPenColor = "검정";
String blackPenNo = "a003";

void redPenWrite() {
	System.out.println("빨간 펜으로 글씨를 씁니다.");
}

void redPenDraw() {
	System.out.println("빨간 펜으로 그림을 그립니다.");
}

void redPenInfo() {
	System.out.println("제품번호: " + redPenNo);
	System.out.println(redPenColor + "색 펜의 가격은 " + redPenPrice + "원 입니다.");
}

////////////////////////////////////////////////////

void bluePenWrite() {
	System.out.println("파랑 펜으로 글씨를 씁니다.");
}

void bluePenDraw() {
	System.out.println("파랑 펜으로 그림을 그립니다.");
}

void bluePenInfo() {
	System.out.println("제품번호: " + bluePenNo);
	System.out.println(bluePenColor + "색 펜의 가격은 " + bluePenPrice + "원 입니다.");
}

• 이 코드는 틀린 것은 없지만, 몇 개의 불편한 점이 있다.

1. 펜의 속성들과 기능들이 동일하지만, 구분을 위해서 일일히 다른 변수 이름을 사용하고, 메서드 이름도 다르게 지정.
2. 지금 현재 펜의 개수가 3개 밖에 안되지만, 계속해서 추가가 된다면 변수와 메서드들이 기하급수적으로 늘어날 것이다.
3. 만약 같은 색상의 펜이 두 개라면, 그 두 펜을 구분하기 위해 또 다른 변수 이름과 메서드 이름으로 똑같은 속성 및 기능으로 표현해야 함.

• 이 불편한 점을 해결하기 위해서는 "설계도"를 만들고 찍어내면 된다!

//객체 설계용 클래스(라이브러리 클래스)는 메인 메서드를 작성하지 않습니다.
public class Pen {
	
	//객체의 속성을 필드(멤버변수)라고 부릅니다.
	String color;
	int price;
	String productNo;
	
	
	//객체의 기능을 메서드라고 합니다.
	void write() {
		System.out.println(color + "색 글을 씁니다.");
	}

	void draw() {
		System.out.println(color + "색 그림을 그립니다.");
	}
	
	void priceInfo() {
		System.out.println("제품번호: " + productNo);
		System.out.println(color + "색 펜의 가격은 " 
							+ price + "원 입니다.");
	}
}

• 이렇게 설계도를 작성했지만, 이것만 가지고는 무엇도 할 수 없다.
• 따라서 실물을 만들기 위해, MainClass를 하나 제작해서 객체를 생성해야한다.

        Pen redpen = new Pen();
        Pen bluepen = new Pen();

        System.out.println("redpen = " + redpen);
        System.out.println("bluepen = " + bluepen);
       
       
        redpen.color = "red";
        redpen.price = 2500;
        bluepen.color = "blue";
        bluepen.price = 600;

        redpen.write();
        redpen.priceInfo();
        bluepen.write();
        bluepen.priceInfo();

---

9. 필드와 지역변수, 참조값과 문자열 equals()

• 같은 변수이지만, 어디에 선언되었냐에 따라 필드 또는 지역변수라는 이름이 붙게되며 그 둘은 특징에 차이가 있음.

 

- 선언 위치와 범위

• 필드 : 클래스 내부에 선언, 해당 클래스의 모든 메서드에서 접근이 가능
• 지역 변수 : 메서드나 블록 내부에 선언, 해당 영역 내에서만 접근 가능

- 초기화 여부

• 필드 : 초기값이 지정되지 않으면 기본값으로 자동 초기화
• 지역 변수 : 반드시 초기화가 되어야 한다. 초기화되지 않은 지역 변수는 사용할 수 없음.

- 메모리 할당 위치

• 필드 : 객체가 생성될 때마다 각각의 객체마다 독립적인 메모리 공간에 할당.
• 지역 변수 : 해당 변수가 선언된 블록이 실행될 때마다 스택 메모리에 할당되며, 블록이 종료되면 할당된 메모리가 해체

public class FieldVariable {

    int a; // field

    /*
        - 지역 변수는 반드시 초기화가 되어 있어야 참조가 가능합니다.
        - 필드는 초기화를 하지 않아도 자동으로 각 타입의 기본값으로 초기화됩니다.
        - 매개 변수는 메서드 호출시 강제로 값이 대입되므로 따로 초기화할 필요가 없습니다.
     */
    void m1(int c) { // c: parameter -> 매개변수도 일종의 지역 변수.
        int b = 1; // local variable
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);
    }

    public static void main(String[] args) {

        FieldVariable fv = new FieldVariable();
        fv.m1(10);

        System.out.println(fv.a);
    }
}

9 - 1. 문자열 동등 비교 equals()

• 먼저 문자열 String은 기본 데이터 타입이 아닌 객체 타입.
• 따라서 두 개의 문자열을 비교할 때는 객체가 가지고 있는 동등성을 비교해야 한다. 이를 위해서는 "==" 대신 equals()메서드를 사용.

String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); // true

String s1 = "hello";
String s2 = new String("hello");
System.out.println(s1 == s2); // false

• 위의 코드 비교값이 서로 다른 이유

• 기본 타입처럼 문자열을 선언하게 되면 문자열 상수 풀이라는 곳에 저장됨. 
• 그리고나서, 새로운 변수에 기본 타입처럼 문자열을 저장하게 될 때, 기존에 이미 존재하는 문자열을 저장하려고 시도하면, 이미 상수 풀에 존재하는 문자열을 재사용하게 된다.
• 하지만 new String();처럼 문자열을 생성하게 되면, 상수풀에 존재하는 것을 재활용하는 것이 아닌 새로운 문자열 객체를 생성하게 된다. 따라서 주소값이 다르다고 나옴.
• 반면 equals() 메서드는 2개의 객체의 내용이 같은지를 비교한다. 말 그대로 객체들이 가지고 있는 문자열 자체를 비교하게 되는 것.

String s1 = "hello";
String s2 = "hello";
System.out.println(s1.equals(s2)); // true

String s3 = new String("hello");
System.out.println(s1.equals(s3)); //true

 

---

10. 생성자

생성자는 객체를 생성하는 역할을 해주는 것.

• 특징

1. 생성자의 이름은 클래스의 이름과 대/소문자까지 완벽하게 동일해야 한다.
2. 객체를 생성할 때, 반드시 호출
3. 일종의 메서드지만, 리턴 타입이 없고 리턴값은 주소값으로 고정되어 있음.
4. 생성자를 하나도 선언하지 않을 경우, 기본 생성자 하나 생성해주기 때문에 생성자 선언 없이 객체 생성이 가능.
5. 객체를 생성하는 기능 뿐만 아니라, 객체 생성과 동시에 해야 할 일 등을 진행할 수 있음.

public class Phone {
    String model;
    String color;
    int price;
    
    // 생성자를 선언하지 않으면 가장 기본 형태의 생성자를 하나 만들어준다.
    Phone() {
    	// 이게 가장 기본 형태의 생성자이다.
        // 클래스와 이름이 동일하고, 리턴 타입이 존재하지 않는다.
    }

    Phone() {
        System.out.println("기본 생성자 호출");
        model = "폴더폰";
        color = "회색";
        price = 200000;
        // 이렇게 기본 생성자에 코드를 추가해줄 수 있다.
    }
    
    
    
         /*
             # 생성자 오버로딩 (중복 선언)

             1. 생성자는 중복해서 여러 개 선언이 가능합니다.
             2. 단, 생성자의 매개변수의 타입, 개수, 순서 중 하나가 달라야
                중복을 인정합니다.
             */
    
        Phone(String pModel) {
        System.out.println("2번 생성자 호출");
        model = pModel;
        color = "while";
        price = 100000;
    }

    Phone(String pModel, String pColor) {
        System.out.println("3번 생성자 호출");
        model = pModel;
        color = pColor;
        price = 120000;
    }

}

• 생성자를 호출함으로써 객체를 생성할 수 있으며, 생성자가 여러 개 존재한다면 원하는 대로 골라서 호출하는 것이 가능하다.

public class Main {
    public static void main(String[] args) {
        Phone basic = new Phone();
        basic.showSpec();

        System.out.println("================");

        Phone galaxy = new Phone("갤럭시 s25");
        galaxy.showSpec();

        System.out.println("=================");

        Phone iPhone = new Phone("아이폰 16", "스페이스 그레이");
        iPhone.showSpec();
    }
}

* 기본 생성자 없이 매개값을 받는 생성자만 선언해 놓았을 경우에는 그 생성자만을 사용해서 객체를 생성할 수 있음. (기본 생성자를 호출해서 객체를 생성할 수 없음.)

* 이 말은 자바가 생성자를 자동으로 선언해주는 경우는 생성자를 단 하나도 선언하지 않았을 경우뿐이다.

---

11. 패키지

비슷한 성격을 가진 자바 클래스나 인터페이스들을 모아 놓은 자바의 디렉토리이다.

• 특징

1. 패키지를 만들어서 클래스에 배치하면, 클래스 최 상단에 패키지 구문이 포함.
2. 패키지 이름은 소문자로 지어주는 것이 관례.
3. 상위 패키지와 하위 패키지를 구분할 때는 .(dot)을 사용.
4. 패키지 이름을 정할 때는 식별자 규칙이 적용됨.

//패키지 내에 클래스를 생성하면 클래스 최상단에 패키지 선언문이 추가된다.
package fruit;

public class Apple {

	public Apple() {
		System.out.println("생과일 사과 입니다.");
	}

}

package fruit;

public class Banana {
}

package fruit;

public class Grape {
}

fruit라는 3개의 클래스를 선언

package syrup;

public class Apple {
	public Apple() {
		System.out.println("사과 시럽 입니다.");
	}
}

// 이미 Apple이라는 클래스가 존재하지만, 패키지가 서로 다르기 때문에 
// 동일한 이름으로 클래스를 만들어도 구분이 된다.

package test;

//패키지 외부에 있는 클래스는 import 선언을 통해 정보를 불러 와야 사용이 가능하다. 
//import fruit.Apple;
//import fruit.Banana;
//import fruit.Grape;

//fruit 패키지 내의 모든 클래스를 import 하겠다는 선언문.
import fruit.*;

public class Test {

    public static void main(String[] args) {

				//패키지가 다르고 이름이 동일한 클래스의 객체를 생성할 때는
				//패키지 풀 경로를 모두 써 주어야 구분이 된다.
        Apple apple = new Apple();
				syrup.Apple a2 = new syrup.Apple();				

        new Banana();
        new Grape();

				//import 선언을 하지 않으면 패키지 경로를 모두 작성해야 한다.
				//java 패키지 내의 util이라는 패키지 내에 있는 Scanner 클래스.
        new java.util.Scanner(System.in);

    }
}

---

12. this

현재 객체를 참조하는 키워드로, 클래스 내에서 자기 자신의 인스턴스 변수를 참조할 때 사용.
이 키워드를 사용하면, 메서드 내에서 로컬 변수와 인스턴스 변수를 구분할 수 있음.

public class Player {

    String name; // 닉네임
    int level; // 레벨
    int hp;    // 체력

    // 생성자
    Player() {
        System.out.println("1번 생성자 호출!");
	      name = "이름없음";
	      level = 1;
        hp = 50;
    }
		
		Player(String name) {
        System.out.println("2번 생성자 호출!");
	      name = name; //문제가 발생하는 코드
	      level = 1;
        hp = 50;
    }
		
	......

}

///////////////////////////////////////////////////////////////////

Player p2 = new Player("플레이어2");
System.out.println(p2.name); // null!;

• 위 코드에서 값이 제대로 전달되지 못한 이유는 필드의 name과 생성자의 매개변수 name이 이름이 동일하기 때문이다. (둘 다 생성자내에서 매개변수를 우선시 여겨, 코드가 이상해진다.)
• 따라서 매개변수 name과 필드 name을 구분할 수 있게 this를 사용하면 된다.

Player(String name) {
    System.out.println("2번 생성자 호출!");
    this.name = name; //this가 가지는 주소값은 이 생성자를 부른 객체의 주소값이 된다.
    level = 1;
    hp = 50;
}
///////////////////////////////////////////////////////////////////

Player p2 = new Player("플레이어2");
System.out.println(p2.name); // 플레이어2;

Player p3 = new Player("플레이어3");
System.out.println(p3.name); // 플레이어3;

• this는 생성자나 메서드를 호출한 그 객체의 주소값과 동일한 주소값을 갖게 된다.

12 - 1. this() 를 이용하여 생성자 호출하기

• this를 사용하면 같은 클래스 내의 다른 생성자를 호출할 수 있다.

Player() {
    System.out.println("1번 생성자 호출!");
    name = "이름없음";
    level = 1;
    hp = 50;
}

Player(String name) {
    System.out.println("2번 생성자 호출!");
    this.name = name;
    level = 1;
    hp = 50;
}

• 여기에서 level을 1로, hp를 50으로 초기화 해주는 것은 두 생성자가 동일하다.
• 나중에 멤버 변수 또는 생성자 수가 많아지면, 그만큼 중복이 많아져 쓸데없이 코드가 길어진다. 그러므로 this()로 내 다른 중복 생성자를 불러 주는 것이 좋다.

Player() {
    System.out.println("1번 생성자 호출!");
    name = "이름없음";
    level = 1;
    hp = 50;
}

Player(String name) {
		this();
    System.out.println("2번 생성자 호출!");
    this.name = name;
}

Player(String name, int hp) {
		this(name); //name을 매개값으로 받는 생성자 호출!
    System.out.println("3번 생성자 호출!");
		this.hp = hp;
}

//////////////////////////////////////////////////////////////////

Player p1 = new Player("플레이어1");
System.out.println(p1.name); // 플레이어1
System.out.println(p1.level); // 1
System.out.println(p1.hp); // 50

* 자신의 다른 생성자를 호출하는 코드는 반드시 생성자의 최상단에 위치해야 한다.

* 생성자 또는 메서드 내에서 필드값을 참조할 때, 기본적으로 "this."이 생략되어 있다.

---

13. 접근 제한자

클래스/필드/메서드/생성자에 대한 접근 권한을 제한하는 키워드

• 접근 제한자의 종류

1. public : 어떤 클래스에서든 접근 가능한 최대한의 범위. 다른 패키지에서도 접근이 가능. 즉, 접근 제한 자체가 없는 경우이다.
2. protected : 같은 패키지에서는 모든 클래스에서 접근 가능. 다른 패키지의 경우 상속받은 자식 클래스에서만 접근 가능.
3. default (아무런 접근 제한자를 사용하지 않음) : 같은 패키지 내에서만 접근이 가능하고, 다른 패키지에서는 접근이 불가능하다.
4. private : 같은 클래스 내에서만 접근 가능. 다른 클래스에선 접근할 수 없다. (가장 폐쇄적인 제한자)

• 접근 제한자를 사용하여, 클래스/변수/메서드 등의 멤버에 대한 접근 범위를 제한함으로써 코드의 안정성을 높일 수 있음.
• 사용자가 알 필요 없는, 또는 알아서는 안되는 정보들은 숨겨주거나 변경할 수 없어야 한다.

* class의 경우, public / default 제한자만 들어갈 수 있음. (private과 protected는 사용 불가능)

---

14. 정보 은닉과 캡슐화

14 - 1. 정보 은닉

객체의 상태를 숨기고, 외부에서 접근할 수 없도록 보호하는 것을 의미.
정보 은닉을 사용하지 않으면, 객체 필드에 불필요한 값이나 문제가 발생할 수 있는 값들이 들어오는 것을 막을 수 없음.

public class MyBirth {
    int year;
    int month;
    int day;

    void birthInfo() {
        System.out.printf("내 생일은 %d년 %d월 %d일 입니다.\n"
                , this.year, this.month, this.day);
    }


}

public class Main {

    public static void main(String[] args) {

        MyBirth birth = new MyBirth();
        birth.year = 200051;
        birth.month = -394;
        birth.day = 13444;

        birth.birthInfo();

    }
}

• 위 코드는 정보 은닉이 구현되어 있지 않다. 그래서 생일 년/월/일에 정해진 범위를 넘어서는 숫자, 심지어는 음수를 넣어도 코드가 동작한다. 이러한 것을 막기 위해 정보 은닉이 필수적이다.

public class MyBirth {

    // 외부에서 변수의 직접 접근할 수 없도록 필드에 private 제한을 붙임.
    private int year;
    private int month;
    private int day;
    
        public void setYear(int year) {
        if (year < 1900 || year > 2025) {
            return;
        }
        this.year = year;
    }


    public void setMonth(int month) {
        if (month < 1 || month > 12) {
            System.out.println("잘못된 접근입니다.");
            return;
        }
        this.month = month;
    }

    public void setDay(int day) {
        if (day < 1 || day > 31) {
            System.out.println("잘못된 접근입니다.");
        } else {
            if (this.month == 0) {
                System.out.println("일자를 입력하기 위해서는 월 입력이 선행되어야합니다.");
                return;
            }
            if (!isValidateMonth(day)) {
                System.out.println("월에 따른 일자가 올바르지 않습니다.");
                return;
            } else {
                this.day = day;
            }
        }
    }

    void birthInfo() {
        if (year == 0 || month == 0 || day == 0) {
            System.out.println("날짜 필드 중에 초기화되지 않은 데이터가 있습니다.");
            return;
        }
        System.out.printf("내 생일은 %d년 %d월 %d일 입니다.\n", this.year, this.month, this.day);
    }


    public int getYear() {
        return year;
    }

    public int getMonth() {
        return month;
    }

    public int getDay() {
        return day;
    }
    
    // 각 월에 적합한 일자가 세팅되어 있는지를 판별하는 메서드
    private boolean isValidateMonth(int day) {
        switch (this.month) {
            case 2:
                if (day > 28) return false;
            case 4, 6, 9, 11:
                if (day > 30) return false;
            default:
                return true;
        }
    }

• 모든 필드를 private으로 지정하여 외부로부터의 접근을 막아, 정보를 보호할 수 있지만, 데이터 접근 자체가 힘들어진다.
• 따라서 데이터의 유효성을 검증할 수 있는 제어문이 포함된 메서드를 이용하여 데이터의 접근을 허용하도록 설계하는데, 이 때 사용되는 것이 getter / setter 메서드라고 부른다.
• setter 메서드는 숨겨진 변수에 값을 저장하기 위한 메서드로 내부에 데이터 유효성 검증 로직을 작성하여 적절한 데이터만 저장시킨다. (메서드 이름은 일반적으로 set + 필드이름으로 설정.)
• getter 메서드는 숨겨진 변수의 값을 참조할 때 사용하는 메서드로, setter메서드와 마찬가지로 public 제한을 두어 외부에 공개함. (일반적으로 get + 필드이름으로 설정.)

* boolean 타입 필드의 getter 메서드는 get이 아닌, is로 시작하는 것이 관례이다.

    public boolean isYear() {
        return year;
    }

14 - 2. 캡슐화

객체의 상태와 동작을 하나의 단위로 묶어서 구현하는 것.
즉, 하나의 목적을 이루기 위해 관련 있는 모든 것들을 하나의 캡슐에 담아 두는 것을 의미함.

// 시동 거는 기능
public void engineStart() {
    System.out.println("시동 버튼을 눌렀습니다.");
    System.out.println("시동이 걸렸습니다.");
}


// 엔진에 연료가 주입되는 기능
private void injectGasoline() {
    System.out.println("연료가 엔진에 주입됩니다.");
}
// 엔진오일이 주입되는 기능
private void injectOil() {
    System.out.println("엔진 오일이 순환합니다.");
}
// 실린더가 움직이는 기능
private void moveCylinder() {
    if (start) {
        System.out.println("실린더가 움직입니다.");
    } else {
        System.out.println("차가 고장났습니다.");
    }
}

// 시동 거는 기능
public void engineStart() {
    System.out.println("시동버튼을 눌렀습니다.");
    injectOil();
    injectGasoline();
    this.start = true;
    moveCylinder();
    System.out.println("시동이 걸렸습니다.");
}

• 캡슐화를 통해 사용자 쪽에서 좀 더 간결한 문법으로 객체를 동작시킬 수 있는 편의성이 있다.
• 또한, 내부 로직이 변경되더라도 외부 코드에는 영향을 미치지 않도록 설계되기 때문에 유지 보수의 편의성이 증가한다.

---

15. 상속

부모 클래스가 가진 속성과 기능을 자식 클래스가 물려받는 것.

• 위 코드는 불편한 점이 몇 가지가 존재한다.
• 각각 클래스는 다르지만 가지고 있는 속성과 기능이 서로 비슷한 것을 찾아볼 수 있음.
• 이 상황에서 동물 클래스를 더 추가한다면 클래스를 더 작성하기가 힘듬.

• 이것은 위의 코드를 상속화해서 만든 것이다.
• 부모 클래스인 Animal 클래스는 기존 Dog / Cat / Monkey / Dolphin이 가지고 있는 속성 및 기능을 모두 모아놓은 클래스로 작성.
• 그리고 나머지 동물 클래스가 Animal 클래스를 상속받는 형식으로 구축
• 이렇게 작성하면 중복되는 속성 및 기능을 일일히 작성할 필요가 없으며 각각이 가지는 고유한 속성들만을 클래스에 추가하여 개념 확장가능.

15 - 1. 상속 정리

• 단일 상속 만을 지원한다. (부모는 한명이어야 한다.)

* 왜 다중 상속은 되지 않는가? 

(death of diamond)

위 그림에서 B, C 클래스는 A의 클래스를 상속받는 자식 클래스이다. 

그리고 D클래스는 B, C 클래스에게 상속받는다. 

이 때, B, C  클래스에 존재하는 A클래스를 중복으로 상속받게 되어 오류가 발생할 수 있다.

• 어떤 클래스가 다른 클래스로부터 상속을 받아 만들어지면 새롭게 만들어진 클래스를 자식 클래스라고 부르며, 필드와 메서드를 물려준 클래스는 부모 클래스라고 부른다.
• 상속을 하면 부모 클래스의 필드와 메서드가 자식 클래스에게 상속, 단 부모 클래스의 생성자는 상속이 되지 않음.
• 부모의 private 멤버는 상속 대상에서 제외

15 - 2. 오버라이딩 (overriding)

• 부모 클래스로부터 상속 받은 메서드를 자식 클래스에서 행위를 바꾸거나 보완하기 위해 다시 정의해서 사용하는 것.
• 부모 클래서에서 어떠한 용도로 사용하던 메서드를 자식 클래스에서 다른 용도로 사용할 때, 필요함.

• 오버라이딩의 규칙

1. 부모가 물려주는 메서드와 이름이 동일.
2. 부모가 물려주는 메서드와 매개 변수 선언이 동일.
3. 부모가 물려주는 메서드롸 리턴 타입이 같아야 함.
4. 접근 제한자는 같거나 더 넓어야 함.

15 - 3. super

상속 받고 있는 부모 객체를 지목할 때 사용하는 키워드이다.
이 키워드를 통해 부모의 필드 & 메서드를 지목할 수 있으며, 부모의 생성자를 호출하는 것 또한 가능.

//부모 클래스
public class Person {
		String name;
		int age;

		public Person() {}

		public Person(String name) {
			this.name = name;
		}

		String info() {
		return "이름: " + name + ", 나이: " + age;
		}
}

//////////////////////////////////////////////////////

public class Student extends Person {
	
		String studentId;

		public Student(String name, String studentId) {
			super(name);
			this.studentId = studentId;
		}
		
		@override
		String info() {
			return super.info() + "학번: " + studentId;
		}

		void study() {
				System.out.println("공부를 합니다.");
		}
}

• 위 코드에서 부모가 물려준 메서드인 info에 Student가 가지는 고유한 속성인 studentId 정보만 추가해주는 식으로 오버라이딩 진행
• 그렇기 때문에, 완전히 뜯어 고치는 것이 아닌, 부모 메서드 기반으로 자식의 고유 속성만 추가해줄려고 함.
• 그래서 super.info()를 통해 부모의 메서드를 가져왔고, 리턴된 문자열에 studentId만 추가.
• 생성자의 경우, 자식 클래스의 생성자는 name / studentId를 받고 있는 모습.
• 자식 생성자 내에서 name과 studentId를 초기화 할 수도 있지만, 자식 생성자는 부모 생성자를 호출 해야 객체를 생성할 수 있기 때문에 부모의 생성자를 불러 초기화를 하는 모습. (super(name)을 사용)

* 자식 클래스의 생성자에는 항상 super()가 기본적으로 들어 있음. (기본적으로 컴파일러가 super()을 삽입해주기 때문에)

* 기본적으로 자식 객체는 부모 객체가 우선적으로 생성 되어야 함.

* 그렇기 때문에 super()를 생략하더라도 자식 객체가 생성이 되지만, 직접 super키워드를 사용하여 부모 생성자를 골라서 호출할 수 있음.

---

16. static

public class MyClass {
		public int a; //인스턴스 필드
    public static int b; //정적 필드
}

• 먼저 클래스에 인스턴스 필드와 정적 필드 하나를 작성 해본다.

Count c1 = new Count();

c1.a += 5;
c1.b += 5;

System.out.println("인스턴스 변수 c1.a: " + c1.a); //5
System.out.println("정적 변수 c1.b: " + c1.b); //5

• 처음에는 서로 같은 값이 나오는 것을 볼 수 있지만,

Count c2 = new Count();
		
c2.a += 7;
c2.b += 7;

System.out.println("인스턴스 변수 c2.a: " + c2.a); //7
System.out.println("정적 변수 c2.b: " + c2.b); //12

• 나중에는 서로 다른 값이 나온 것을 볼 수 있다.
• 객체의 필드는 각 객체마다 고유하게 가지고 있는 값이다. 이런 이유로 객체를 생성할 때마다 그 객체들 내에 a라는 필드가 각각 존재하기 때문에 값이 다 다르다.
• 반면 정적 변수는 객체마다 생성되는 것이 아닌, 따로 생성되어서 모든 객체가 공유하는 전역 변수로서 동작하기 때문에 값이 누적됨.
• 그렇기 때문에 일반 필드를 부르는 것처럼 static 필드를 부르는 것은 혼란을 줄 수 있어, static을 부르는 방식으로 불러야 한다.

public class Count {
	
	public int a; //인스턴스 변수
	public static int b; //정적 변수
	
	//일반 메서드
	public int method1() {
		return this.a + Count.b;
	}
	
	//static 메서드
	public static int method2() {
		//this.a = 10; (x)
		Count ccc = new Count();
		return ccc.a + Count.b;
	}

}

• 인스턴스 메서드 안에는 정적 변수와 인스턴스 변수, 모두를 사용할 수 있음.
• 반면 정적 메서드 내부에서는 static이 붙은 변수나 메서드만 사용 가능.
• 나타낼 주소값이 없기 때문에 this는 사용할 수 없음.
• static 블록 내부에서 non-static 멤버를 사용할려면 반드시 객체를 생성해서 주소값을 통해 참조해야 한다.

* 우리가 평소에 사용하는 main 메서드도 정적 메서드이다. 

• static은 모든 객체가 공유해도 문제가 없는 필드나 메서드에 붙임.

---

17. final

17 - 1. final 필드

public class Person {
	
	final String nation; //에러
	String name;
	int age;

}

• 클래스를 선언할 때 final 필드를 선언하고, 그냥 가만히 있으면 에러 발생. (반드시 초기화를 해서 마지막 값을 지정해주어야 함.)

public class Person {
	
	final String nation = "대한민국"; 
	String name;
	int age;

}

public class Person {
	
	final String nation = "대한민국"; 
	final String name;
	int age;

	//생성자를 이용해서 초기화.
	public Person(String name) {
		this.name = name;
	}

}

• final 필드에 직접 초기화 하는 방식 뿐만 아니라, 객체 생성 시 동시 초기화 할 수 있도록 생성자에 필드 초기화 로직을 작성할 수 있음.

public class Main {
	
	Person p = new Person("김철수");
	p.nation = "미국"; //에러
	p.name = "김마이클"; //에러
}

17 - 2. final method

• final이 붙은 메서드는 오버라이딩을 막는다.

public class Parent {

	void method1() {}
	void method2() {}
	final void method3() {}

}

public class Child extends Parent {

	@Override
	void method1() {
		// TODO Auto-generated method stub
		super.method1();
	}

	@Override
	void method2() {
		// TODO Auto-generated method stub
		super.method2();
	}

//	void method3() {
//		System.out.println("오버라이딩 해야지~");
//	} (x) final 메서드는 오버라이딩을 막습니다. (주는 대로 써라~)

}

15 - 3. final class

• 클래스 선언 시, final을 사용하면 그 클래스는 상속이 불가능.

public final class Parent {
	...
}

• 상속 자체가 막히며 코드 에러가 발생함.
• final 클래스는 자식 클래스를 가질 수 없고, 오직 외부에서 직접 객체 생성을 통해서만 사용할 수 있음.

15 - 4. 상수

고정된 불변의 값.
모든 객체가 해당 값을 공유할 수 있는 전역성을 가져야 하고, 동시에 값이 변하지 않는 불변성을 가져야 함.
-> static 과 final의 성질을 둘 다 갖고 있어야함.

public class Earth {
	static final double RADIUS = 6400;
	
	static final double SURFACE_AREA;
	
	static {
		SURFACE_AREA = RADIUS * RADIUS * Math.PI * 4;
	}
}

• 상수는 다른 일반 변수와의 차이를 위해 모든 글자를 대문자로 선언.
• 만약 뛰어쓰기를 할려면, _를 이용하여 연결해준다.

---

16. 다형성

하나의 객체가 여러가지 타입으로 사용되는 것을 의미.
상속을 전제 조건으로 함. 
다형성을 위해, 자바는 자식 클래스가 부모 클래스의 타입을 가질 수 있도록 허용함.

class A {}
class B extends A {}
class C extends A {}
class D extends B {}
class E extends C {}

public class Basic {
	//다형성을 적용하지 않았을 때
	A a = new A();
	B b = new B();
	C c = new C();
	D d = new D();
	E e = new E();

	//다형성을 적용했을 때
	A v1 = new B(); //클래스 타입 B -> A타입으로 자동 형 변환(promotion)
	A v2 = new C();
	A v3 = new D();
	A v4 = new E();
}

• 다형성이 없을 때는 참조 변수의 타입을 객체에 맞게 작성해 주어야 한다.
• 하지만 다형성이 적용이 되었다면, 최상위 부모인 A 타입에 모두 객체의 주소값이 저장될 수 있음.

16 - 1 . 다형성의 이점

Dog dog = new Dog();
Cat cat = new Cat();
Duck duck = new Duck();

Animal[] animals = {dog, cat, duck};

• 각자 다른 3개의 자식 객체를 하나의 배열에 넣고 싶다.
• 배열은 동종 모음 구조이기 때문에 같은 타입 끼리만 배열에 모여 있을 수가 있는데 배열을 부모 타입으로 선언했더니, 모든 자식의 객체가 하나의 배열로 모여있어 쉽게 관리할 수 있음.

//매개변수에 다형성이 적용되어 있지 않다면
//메서드 오버로딩을 통해 일일히 구현 해 주어야함.
public void makeSound(Dog dog) {...}

public void makeSound(Cat cat) {...}

public void makeSound(Duck duck) {...}

////////////////////////////////////////////////////////////////

//매개변수에 다형성을 준 경우
public void makeSound(Animal animal) {
	animal.sound(); //dog, cat, duck 모두 sound() 호출 가능.
}

• 만약 매개변수에 다형성을 사용하지 않는다면, 일일히 타입이 다른 메서드를 선언해야 한다.
• 하지만 다형성을 적용함으로써 굳이 여러 개의 메서드를 선언할 필요 없이 하나의 메서드 만으로 여러 개의 객체를 받아 처리할 수 있음.

public Dog returnDog() {...}

public Cat returnCat() {...}

public Duck returnDuck() {...}

//////////////////////////////////

public Animal returnAnimal(String name) {
	if(name.equals("강아지")) {
		return new Dog();
	} else if(name.equals("고양이")) {
		return new Cat();
	} else if(name.equals("꽥꽥이")) {
		return new Duck();
	}
}

• 다형성을 리턴 타입에 적용하여, 해당 부모 타입에 맞는 모든 자식 객체가 리턴 될 수 있음.

16 - 2. 타입 캐스팅

public class Parent {
	public int n1;

	void method1() {...}
	void method2() {...}
}

public class Child extends Parent {
	public int n2;

	@override
	void method2() {...}
	void method3() {...}
}

//////////////////////////////////////////////////////////////////////

public class Main {
	Parent p = new Child();
	p.n1 = 1;
	//p.n2 = 2; (x)
	
	p.method1();
	p.method2();
	//p.method3(); (x)
}

• 위 코드에서 부모가 물려준 것들과 자식이 오버라이드 한 메서드까지는 정상적으로 호출이 되었지만, 자식 고유의 속성 및 기능을 사용하지 못하는 모습을 볼 수 있음.
• 이러한 이유는 부모의 정보로는 자식이 어떻게 개념을 확장 했는지에 대한 정보를 얻을 수 없기 때문이다.
• 그래서 부모타입의 변수를 자식 타입으로 형변환을 진행해야 함.

Child c = (Child) p;
c.n2 = 2;
c.method3(); //주소값을 자식 타입으로 내리니까 속성 및 기능 사용 가능.

16 - 3. instanceOf 

public void sayHello(Animal ani) {
	if(ani instanceof Dog) {
		System.out.println("강아지가 꼬리를 흔들어요.");
	} else if(ani instanceof Cat) {
		System.out.println("고양이가 나를 못 본척 해요");
	} else if(ani instanceof Duck) {
		System.out.println("오리가 꽉꽉 울어요.");
	}
}

• 위 메서드는 매개변수에 다형성이 적용되어 있음.
• 하지만 어떤 객체냐에 따라 다른 인사법을 가지고 있기 때문에, 객체 구분이 필요함.
• 이 때, instanceof 키워드를 통해, 해당 객체가 어떤 타입을 가지고 있는 지를 물어 볼 수 있음.

---

17. 추상 클래스 & 추상 메서드

17 - 1. 추상 메서드

메서드 선언만 되어있고 메서드의 바디가 없는 메서드.
즉, 틀만 구축하고 알맹이가 없는 껍데기 메서드이다.
추상 메서드는 추상 클래스에서만 선언할 수 있음.

17 - 2. 추상 클래스

추상 메서드가 하나 이상 포함되어 있는 클래스.
미완성 된 메서드를 포함되었기 때문에 스스로의 객체를 생성할 수 없다.
반드시 추상 클래스를 상속받아 추상 메서드를 구현한 자식 클래스를 통해 생성해서 사용해야 함.

• 추상 개념을 사용하는 이유

1. 다형성 구현 목적이 뚜렷해 진다. (자식 클래스 쪽에서 구체적인 구현을 담당하게 함으로써 유지보수성을 더 높일 수 있음.)
2. 코드 디자인 패턴 적용 (강제화를 시킬 수 있는 성격으로 틀에 잡힌 코드 패턴을 강제하기 쉬움.)
3. 코드 재사용성을 통한 객체지향적 프로그래밍

---

18. 인터페이스

구현하고자 하는 클래스에 동일한 목적 하에 동일한 기능을 수행하게끔 강제하는 클래스의 틀 역할을 하는 것.

18 - 1. 인터페이스의 문법

public interface Animal {
		//int i;  (x)
		//public Animal() {} (x)
		public static final String name = "Animal";
		void move();
}

public interface Mammals {
	void feeding();
}

public interface Bird extends Animal {
	void fly();
}

• 인터페이스는 추상 메서드 밖에 가질 수 없음.
• 애초에 객체를 생성하기 위한 개념이 아니기 때문에 어떠한 데이터도 저장할 수 없음.
• 생성자는 선언될 수 없고, 메서드 또한 실체가 없는 추상 메서드만 선언 가능.
• 단, 상수는 선언 가능 (static 메서드도 선언할 수 있음.)
• 인터페이스들 끼리 상속이 가능할 뿐만 아니라, 다중 상속도 가능. (껍데기들끼리 물려주는 것이기 때문에)

18 - 2. 구현

• 구현의 키워드는 상속의 키워드인 extends가 다르게, implementsfmf 사용.
• 인터페이스가 가지고 있는 추상 메서드를 반드시 구현해야함.
• 인터페이스는 동시에 여러 개 구현할 수 있음.
• 다형성에서 클래스 타입들 보다 훨씬 유연하게 동작.
• 구현 클래스는 자신이 구현한 인터페이스 타입을 모두 가질 수 있음.

18 - 3. 인터페이스와 추상 클래스의 차이

• 인터 페이스는 추상 클래스보다 더 추상화 된 개념.

1. 추상 클래스는 추상 메서드와 일반 메서드 둘 다 가질수 있는 반면에, 인터페이스는 추상 메서드와 상수 필드만을 가질 수 있음.
2. 인터페이스는 다중 상속이 가능하여, 여러 개의 인터페이스를 구현하는 것이 가능.

• 인터페이스는 동일한 구현 및 동일한 동작을 강제하는데 초점이 맞춰져 있다.
• 즉, 인터페이스는 다형성과 유연성을 제공하는 데 주로 사용하고, 추상 클래스는 코드의 재사용성과 확장성을 고려할 때 사용한다.

---

• 전반적인 느낀 점 (일주일 동안 한 일)

- 2월 4주차에는 본격적인 자바의 문법에 대해 배웠다. 부트캠프에 들어오기 전 자바 문법을 조금 공부해서 그런지, 수업을 따라오는 것에는 문제가 없었다. 하지만 수업을 계속 들어보니 이해가 가지 않은 부분 또는 처음 봤던 부분들이 계속해서 보여, 내가 공부한 지식에 더 디테일한 부분을 보충해야겠다고 생각했다.

• 좋았던 점 (좋았거나 내가 잘했던 점)

- 마치 구멍을 메꾸는 것처럼, 수업을 통해 내 빈약했던 자바 지식을 채울 수 있어서 매우 좋았다.

또한 이미 알던 내용이더라도 한 번 더 복습할 수 있는 계기가 되어서 좋았다.

• 아쉬웠던 점

- 아직 모르는 개념들이 있어서 조금 더 보충이 필요할 것 같다. (다형성, this() 등등....)

물론 이와 관련된 알고리즘 문제의 접근도 아직 힘든 건 덤.

• 개선할 점

- 자바에서 모르는 부분이나 지식을 좀 더 보충하기.

• 다음 주 계획

- 본격적인 알고리즘 풀이 시작

- 어학 공부 슬슬 시작하기.

- 지난번에 수업했던 git/git_hub 그리고 자바 복습