수테크📱⌚️👀

이번주 자바 비전공 강의 + 프로그래머스 문제 풀면서 헷갈리고 잘 모르는것들 정리 해보았습니다😂😂

1. 문자열 정수 변환 (파이썬은 정말 간단한데요...ㅜㅜ 사실 자바도 그리 복잡하진 않음 )

• Interger.valueOf() 메서드 사용 

// 프로그래머스. 이어붙인 수
// new_정수 = Integer.valueOf(문자열) 

class Solution {
    public int solution(int[] num_list) {
        int answer = 0;
        String even = "";
        String odd = "";
        for (int i = 0; i < num_list.length; i ++){
            if (num_list[i] %2 == 1) {
                even += num_list[i];
            }else {
                odd += num_list[i];
            }
        }
        answer += Integer.valueOf(even) + Integer.valueOf(odd);
        return answer;
    }
}

• Integer.parseInt() 메서드 사용

  String str ="30";

  int i = Integer.parseInt(str);  

  System.out.println(i); // 30

둘의  차이점은...
valueOf() 메소드는 문자열의 값을 정수형으로 변환한 뒤 참조 자료형(Reference Type)인 Integer 객체로 만들어서 반환합니다.
parseInt() 메소드는 결과값을 기본 자료형(Primitive Type)인 int 로 반환합니다.

결과를 기본 자료형으로 받아오고 싶을 때는 parseInt() 를, 참조 자료형 Integer 객체로 받아오고 싶을 때는 valueOf() 를 사용하면 됩니다

아직 객체를 못 배워서 그런거라고 생각하고 정진... 하지만 그래도 아시는 자바 고수님 덜 좀 알려주세요...

2. 정수를 문자열로 변환(많음 주의...;;;;!!!)

• Integer.toString()

// 1. Integer.toString() 메서드 사용하기 
// 문자열 = Integer.toString(정수)

public class IntToString {
    public static void main(String[] args) {
        int intValue1 = 0812;
        int intValue2 = 8888;
 
        String str1 = Integer.toString(intValue1);
        String str2 = Integer.toString(intValue2);
 
        System.out.println(str1);
        System.out.println(str2);
    }
}

• String.valueOf()

// 2. String.valueOf()
// 문자열 = String.valueOf(정수)

public class IntToString {
    public static void main(String[] args) {
        int intValue1 = 0812;
        int intValue2 = 8888;
 
        String str1 = Integer.valueOf(intValue1);
        String str2 = Integer.valueOf(intValue2);
 
        System.out.println(str1);
        System.out.println(str2);
    }
}

• int + ""

// 3. int + "" (제일 간단하고 좋네요^^"")
// 문자열 : int + ""

public class IntToString {
    public static void main(String[] args) {
        int intValue1 = 0812;
        int intValue2 = 8888;
 
        String str1 = intValue1 + "";
        String str2 = intValue2 + "";
 
        System.out.println(str1);
        System.out.println(str2);
    }
}

3. for each(개선된 for 문)

: 장점 : 간편성, 가독성 좋은 코드... 배열 인덱스 문제 해결

: 단점 : 인덱스를 사용하지 못한다.. 수정 노우 ㅜ

// for each

// 동작
for(자료형 변수명 : 배열명) {
	문장
}

// 예시
int nums = [1, 2, 3, 4]
for (int num : nums) {
	System.out.println(num);
}
// 1
// 2
// 3
// 4

언젠가 for문 을 쓰는게 능숙해지면 이 방법으로도 써봐야겠다 😊

4. charAt() 메서드

: 문자열에서 문자 하나하나를 추출할 수 있는 메서드!!

// .charAt()
// .charAt(인덱스)

String str = "안녕하세우";
char ch1 = str.charAt(0);
char ch2 = str.charAt(1);
char ch3 = str.charAt(2);

System.out.println(ch1); // 안
System.out.println(ch2); // 녕
System.out.println(ch3); // 하

5. == 과 .euqlas()의 차이

•  == 연산자 : 비교하고자 하는 두개의 대상의 주소값을 비교
• equals 메소드 : 비교하고자 하는 두개의 대상의 값 자체를 비교
  
  

아직 클래스, 상속 파트를 안 배워서 정확한 차이 구별이 안된다...

프로그래머스 문제를 풀다가 ==으로 아무리 해도 문제가 안 풀리길래 구글링을 했는데 다들 equals를 사용하셨다..

equals()가 값을 비교하니까 문자열을 비교할 때 만큼은 == 연산자보다는 나을것이라 생각하기로 했다 일단은.. 

다른분 블로그에서 퍼왔다... 주소 남깁니다...

https://sudo-minz.tistory.com/93

6. 자바 문자열 한글자씩 배열에 저장하기

// Split 함수를 활용하여 단어를 배열에 저장하기

class Solution {
    public int solution(String number) {
        int answer = 0;
        int sum_number = 0;
        
        String[] nums;                // String을 담을 배열 만들어주기
        nums = number.split("");      // 배열에 한글자씩 저장하기
        for (int i = 0; i < number.length(); i++){ // for문으로 하나씩 돌리면서 값 저장하기
            sum_number += Integer.parseInt(nums[i]);
        }
        answer = sum_number % 9;
        return answer;
    }
}


// charAt 함수를 활용하여 단어를 char 배열에 한글자씩 저장하기

char[] num = new char[number.length()]; // String을 담을 배열 만들기
for (int i = 0; i < num.length; i++) {
	num[i] = numver.charAt(i);
}

7. 문자열 만들기(+연산이 많아진다면 성능적으로 좋지 않다) => StringBuilder

// 문자열 만드릭 :StringBuilder

public class Main {
	public static void main(String[] args) {
    	StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append('문자열").append("연결"); // 한번에 두개 append 가능
        // String str = stringBuilder; // String에 StringBuilder를 그대로 넣을 수는 없은  toString()을 붙여야 한다
        String str = stringBuilder.toString();
        System.out.println(stringBuilder); // 문자열연결
        System.out.println(str); // 문자열연결
    }
}

1. if 문

1) if 문과 else 문의 기본 구조

- if 문 : 주어진 조건이 참일 때 실행되는 코드

- else 문: if 문의 조건이 거짓일 때 실행되는 코드

if (조건문) {
	<수행할 문장>;
    <수행할 문장2>;
} else {
	<수행할 문장3>;
    <수행할 문장4>;
}

2) 비교 연산자

// 돈이 3000원 이상 있으면 택시, 아니면 걷기
int money = 2000;
if (money > 3000) {
    System.out.println("택시");
} else {
    System.out.println("걷기");
}
 // 걷기

3) and, or, not 연산자

// 카드가 있거나 돈이3000원 이상 있으면 택시, 아니면 걷기
int money = 2000;
boolean card = true;
if (money > 3000 || card) {
    System.out.println("택시");
} else {
    System.out.println("걷기");
}

// 택시

4)  contains

- 해당 아이템이 있는지 조사하는 메서드 / 조건문에 많이 활용된다

import java.util.ArrayList;

public class money {
	public static void main(String[] args) {
	ArrayList<String> pocket = new ArrayList<String>();
	pocket.add("paper");
	pocket.add("cellphone");
	pocket.add("money");
	
	if (pocket.contains("money")) {
		System.out.println("택시를 타고 가라");
	} else {
		System.out.println("걸어가라");
	}
	
	}
}

// 택시를 타고 가라

5) else if

- 있다와 없다중에 없을 경우 다시 경우를 나누어주는 조건문에 해당한다

(if, else가 여러번 사용되어 한 번에 이해하기가 쉽지 않고 산만한 느낌이드느데... 이를 보완하기 위해서... 자바는 여러 조건을 판단할 수 있게 하는 else if 문이 있다)

package test;
import java.util.ArrayList;

public class money {
	public static void main(String[] args) {
	boolean hasCard = true;
	ArrayList<String> pocket = new ArrayList<String>();
	pocket.add("paper");
	pocket.add("cellphone");
	
	if (pocket.contains("money")) {
		System.out.println("택시를 타고 가라");
	} else {
		if (hasCard) {
			System.out.println("택시를 타고 가라");
		}else {
			System.out.println("걸어가라");
		}
	}
	
	}
}

// 택시를 타고 가라

아래 else if 부분들을 수정하면 조금 간단하게 나타내면 아래로 나타내질 수 있다 / else if는 개수제한 없이 사용 가능

	if (pocket.contains("money")) {
		System.out.println("택시를 타고 가라");
	}else if (hasCard) {
		System.out.println("택시를 타고 가라");
	}else {
		System.out.println("걸어가라");
	}

2. switch / case 문

: if 문과 비슷하지만 좀 더 일정한 형식이 잇는 조건문..

=> 입력 변수의 값과 일치하는 case 입력값(입력값1, 입력값2,....) 이 있다면 해당 case 문에 속한 문장들이 실행된다...

  break 문 또한 존재(해당 case문을 실행한 뒤 swirch 문을 빠져나가기 위함), break 문이 없다면, 다음 case로 이동

package test;
import java.util.ArrayList;

public class money {
	public static void main(String[] args) {
		int month = 8;
		String monthString = " ";
		switch(month) {
		case 1: monthString = "January";
		break;
		case 2: monthString = "February";
		break;
		case 3: monthString = "March";
		break;
		case 4: monthString = "April";
		break;
		case 5: monthString = "May";
		break;
		case 6: monthString = "June";
		break;
		case 7: monthString = "July";
		break;
		case 8: monthString = "August";
		break;
		case 9: monthString = "September";
		break;
		case 10: monthString = "October";
		break;
		case 11: monthString = "November";
		break;
		case 12: monthString = "December";
		break;
		default: monthString = "Invalid month";
		break;
		}
		System.out.println(monthString);
	}
}

해당하는 숫자에 대한 case가 실행되었다!!

만약 month가 1에서 12사이의 숫자가 아닌 다른 값이 저장되어 있다면 defaul: 문장이 수행된다!

값이 정형화되어 있는 경우 if 문보다는 switch/case 문을 쓰는 것이 코드의 가독성이 좋다!!

3. while 문

: 조건문이 참인 동안 수행할 문장들을 반복해서 수행한다

package test;

public class tree {
	public static void main(String[] args) {
		int treeHit = 0;
		while (treeHit < 10) {
			treeHit++; // treeHit += 1; 로도 표현가능
			System.out.println("나무를 " + treeHit + "번 찍었습니다.");
			if (treeHit == 10) {
				System.out.println("나무 넘어갑니다.");
			}
		}

	}
}

/*
나무를 1번 찍었습니다.
나무를 2번 찍었습니다.
나무를 3번 찍었습니다.
나무를 4번 찍었습니다.
나무를 5번 찍었습니다.
나무를 6번 찍었습니다.
나무를 7번 찍었습니다.
나무를 8번 찍었습니다.
나무를 9번 찍었습니다.
나무를 10번 찍었습니다.
나무 넘어갑니다.
*/

while문의 조건문 : treeHit < 10 (10보다 작은 동안 수행) / +1 커지면서 수행하고 / 10이 되면서 종료.. while 문 빠져나옴

1) 무한 루프

: 무한하게 while 문 내의 문장들을 수행... 빠져나오지 못한다...

package test;

public class loop {
	public static void main(String[] args) {
		while (true) {
			System.out.println("Ctrl-C를 눌러야 while문을 빠져나갈 수 있습니다.");
		}
	}
}

/*
Ctrl-C를 눌러야 while문을 빠져나갈 수 있습니다.
Ctrl-C를 눌러야 while문을 빠져나갈 수 있습니다.
Ctrl-C를 눌러야 while문을 빠져나갈 수 있습니다.
...
*/

[Ctrl] + [c] : 종료

2) while 문 빠져나가기 - break

: while 문을 강제로 멈춰야 할 때 사용한다

package test;

public class loop {
	public static void main(String[] args) {
		int coffee = 10;
		int money = 300;
		
		while (money > 0) {
			System.out.println("돈을 받았으니 커피를 줍니다.");
			coffee--;
			System.out.println("남은 커피의 양은 " + coffee + "입니다.");
			if (coffee == 0) {
				System.out.println("커피가 다 떨어졌습니다. 판매를 중지합니다.");
				break;
			}
		}
	}
}

/*
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 9입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 8입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 7입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 6입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 5입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 4입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 3입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 2입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 1입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 0입니다.
커피가 다 떨어졌습니다. 판매를 중지합니다.
*/

돈이 0보다 클때동안 진행하다... 0이 되어버리면 출력후 break가 호출되어 while 문을 빠져나간다

3) while 문으로 돌아가기 - continue

: while 문 안의 문장을 수행할 때 어떤 조건을 검사해서 참이 아닌 경우 while 문을 빠져나가는 대신 while 문의 맨 처음, 즉 조건문으로 돌아가게 하고 싶은 경우 continue를 사용(빠져나가지 않고 다시 올라가서 진행)

package test;

public class loop {
	public static void main(String[] args) {
		int a = 0;
		while (a < 10) {
			a++;
			if (a % 2 == 0) {
				continue; // 짝수인 경우 조건문으로 돌아간다.
			}
			System.out.println(a); // 홀수만 출력된다
		}
	}
}

/*
1
3
5
7
9
*/

a가 짝수이면 continue문이 실행되어 while 문의 맨 처음으로 돌아가게 한다!! 

그러므로 a가 짝수이면 System.out.println(a)는 수행되지 않기 때문에 홀수만 출력될 것이다!!!!

4. for 문

: 문장을 반복해서 수행해야 할 경우에 사용

1) for 문의 기본 구조

// 기본 구조
for (초깃값; 조건문; 증갓값) {
	...
}

/////
String[] numbers = ["one", "two", "three"]
for (int i = 0; i < numbers.length; i++) :
	System.out.println(numvers[i]);
}
/*
one
two
three
*/

i의 초깃값은 0, 조건문은 i < numbers.length, 증갓값은 i++이 된다!!

=> i 값이 numbers의 개수보다 작은 동안 계속 i 값을 1씩 증가시키며 for 문의 문장들을 수행

2) for 문으로 돌아가기 - continue

: while 문과 마찬가지로 적용!

int[] marks = {90, 25, 67, 45, 80};
for (int i = 0; i < marks.length; i++) {
	if (marks[i] < 60) {
    	continue; // 조건문으로 돌아간다.
    }
    System.out.println((i+1)+"번 학생 축하합니다. 합격입니다.");
}

/*
1번 학생 축하합니다. 합격입니다.
3번 학생 축하합니다. 합격입니다.
5번 학생 축하합니다. 합격입니다.
*/

점수가 60점 미만이면 continue문이 실해되어 축하메시지를 출력하는 부분이 수행하지 않고, 

for 문의 첫부분으로 돌아갑니다!!!

=> 반복문을 수행할 때, 특정 조건에서는 수행하지 않고 건너뛰어야 할 때 사용합니다!!!!

3) 이중 for 문

: for 문을 두번 사용한 것..

// 구구단 만들기
package test;

public class gugudan {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for (int i=2; i < 10; i++) {
			for (int j=1; j <10; j++) {
				System.out.print(i*j+" ");
			}
			System.out.println(""); // 줄을 바꾸어 출력하는 역할을 한다
		}
	}
}

/*
2 4 6 8 10 12 14 16 18 
3 6 9 12 15 18 21 24 27 
4 8 12 16 20 24 28 32 36 
5 10 15 20 25 30 35 40 45 
6 12 18 24 30 36 42 48 54 
7 14 21 28 35 42 49 56 63 
8 16 24 32 40 48 56 64 72 
9 18 27 36 45 54 63 72 81 
*/

단이 바뀔때 println을 사용하여 줄바꿈하여 문자를 출력하였다!!

5. for each 문

: 이전에 배웠던 for문을 활용한 예제(첨봄)

// for each 문의 구조
for (type 변수명: iterate) {
	body-of-loop
}

iterate는 루프를 돌릴 객체이고 iterate 객체에서 한 개씩 순차적으로 변수명에 대입되어 for 문이 수행된다...

iterate에 사용할 수 있는 자료형은 루프를 돌릴 수 있는 자료형(배열이나 ArrayList등)만 가능하다...

+ 변수명의 type(자료형)은 iterate 객체에 포함된 자료형과 일치해야한다!!!

String[] numbers = {"one", "two", "three"};
for(int i = 0; i < numbers.lengh; i++) {
	System.out.println(numbers[i]);
}

// for each 문을 사용한다면...
String[] numbers = {"one", "two", "three"};
for(String number: numbers) {
	System.out.println(number);
}

문제...

1. everywhere

2. i % 3 == 0

3. i >5 / int j=0; j <5; j++;

4. int i = 1; i < 101; i++;

5. int mark: marks / total / marks.length;

6) 배열

배읠의 길이 설정하기

- 배열은 바로 옆에 []기호를 붙인다

- 배열의 길이를 먼저 설정한 뒤, 배열 변수를 생성하고 그 값을 나중에 대입

String[] weeks = new String[7];
weeks[0] = "월";
weeks[1] = "화";
weeks[2] = "수";
weeks[3] = "목";
weeks[4] = "금";
weeks[5] = "토";
weeks[6] = "일";
// 초깃값 없이 배열 변수를 만들 때에는 7과 같은 숫잣값을 넣어 길이를 정해 줘야 한다...
// 그렇지 않으면 오류가 발생한다...

배열값에 접근하기

- 해당하는 값을 얻으려면 인덱스를 이용하여야 한다

String[] weeks = {"월", "화", "수", "목", "금", "토", "일"}
System.out.println(week[3]); // 목

// weeks[3] => weeks배열의 네번째 항목을 의미(0부터 숫자를 세준다)

배열의 길이 구하기

- 배열은 보통 for 문과 함께 사용

- 배열의 길이는 length를 사용

String[] weeks = {"월", "화", "수", "목", "금", "토", "일"};
// weeks.length = 7
for (int i = 0; i < weeks.length; i++) { 
	System.out.println(weeks[i])
} 
// 월
// 화
// 수
// 목
// 금
// 토
// 일

배열 오류

- ArrayIndexOutOfBoundsException : 길이와 인덱스 사이에서생기는 오류...

   (파이썬의 인덱스아웃오브레인지 같은 느낌..)

System.out.println(weeks[7]); 
// 여덟 번째 배열값이 없으므로 ArrayIndexOutOfBoundsException 오류 발생

7) 리스트

: 배열과 비슷하지만 편리한 기능이 더 많음...

배열의 크기는 정해져 있지만 리스트는 변한다 => 저장할 값의 크기가 명확하지 않은 경우 리스트를 사용해야 한다!!

ArrayList

- 리스트 자료형에서 가장 일반적으로 사용하는 것(리스트 자료형에는 ArrayList, Vector, LinkedList 등이 있다)

1. add 메서드: 요솟값 추가

// 야구공의 시속을 리스트에 추가하는 코드 작성하기
import java.util.ArrayList;

public class Sample {
	public static void main(String[] args) {
    	ArrayList pitches = new ArrayList();
        pitches.add("138");
        pitches.add("129");
        pitches.add("142");
    }
}
// import 문 : 다른 패키지나 클래스를 현재 코드에서 사용하기 위해 선언하는 문장
// ArrayList를 사용하려면 import java.util.ArrayList와 같은 import 문을 작성해야 한다
// Java.util 패키지는 자바가 기본적으로 제공하는 패키지이다


// 원하는 위치에 넣고 싶다면....
pitches.add(0, "133");  -> 첫번째 위치에 133 삽입
pitches.add(1, "133");  -> 두번째 위치에 133 삽입

2. get 메서드 : 특정 인덱스의 값을 추출

import java.util.ArrayList;

public class Sample {
	public static void main(String[] args) {
    	ArrayList pitches = new ArrayList();
        pitches.add("138");
        pitches.add("129");
        pitches.add("142");
        # 선수의 특정 투구 속도를 출력하고 싶다면!!!
        System.out.println(pitches.get(1));   // 129
    }
}

3. size 메서드 : 요소의 개수를 리턴

System.out.println(pitches.size()); // 3

4. contains 메서드 : 리스트 안에 해당 항목이 있는지 판별해 그 결과를 boolean으로 리턴한다...

System.out.println(pitches.contains("142")); // true

5. remove 메서드 : 2가지 방식이 있는데... 1. remove(객체), 2. remove(인덱스)

// remove(객체)를 사용하면 리스트에서 객체에 해당하는 항목을 삭제 , 그 결과로 true 또는 false를 반환
System.out.println(pitches.remove("129")); // true

// remove(인덱스)를 사용하면 인덱스에 해당하는 항목을 삭제한 뒤, 그 항목을 리턴
System.out.println(pitches.remove(0)); // 138

제네릭스(generics)

: 자료형을 안전하게 사용할 수 있도록 만들어 주는 기능(자료형을 강제로 바꿀 때 생길 수 있는 캐스팅 오류를 줄인다)

- 일반적인 방식 : ArrayList<String> pitches = new ArrayList<String>();

- 선호되는 방식 : ArrayList<String> pirches = new ArrayList<>();  

=>  <>에 해당하는 부분의 자료형은 명확하므로 굳이 적지 않아도 된다... (오히려 적으면 인텔리제이에서는 경고 메세지..)

- 제네릭스를 사용하지 않는다면... 값을 가져올 때 매번 Object 자료형(모든 객체가 상속하고 있는 가장 기본적인 자료형)에서 String 자료형으로 변환해야한다.... 

// 제네릭스를 사용하지 않은 예시
ArrayList pitches = new ArrayList();
pitches.add("138");
pitches.add("129");

// 형 변환이 필요함
String one = (String) pitches.get(0);
String two = (String) pirches.get(1);

// 제네릭스를 사용한 예시
ArrayList<String> pitches = new ArrayList<>();
pitches.add("138");
pitches.add("129");

// 형변환이 필요없음
String one = pitches.get(0)
String two = pitches.get(1)

다양한 방법으로 ArrayList 만들기

1. ArrayList의 add 메서드 사용 : ArrayList 객체에 요소 추가

import java.util.AttayList;

public class Sample {
	public staatic void main(String[] args) {
    	ArrayList<String> pitches = new ArrayList<>(); // 제네릭스를 사용한 표현
        pitches.add("138");
        pitches.add("129");
        pitches.add("142");
        System.out.println(pitches); // [138, 129, 142]

2. 이미 문자열 배열이 있다면...(java.util.Arrays 클래스의 asList 메서드를 사용)

import java.util.ArrayList;
import java.util.Arrays;

public class Sample {
	public static void main(String[] args) {
    	String[] data = {"138", "129", "142"}; // 이미 투구 수 데이터 배열이 있다
        ArrayList<String> pitches = new ArrayList<>(Arrays.asList(data));
        System.out.println(pitches);  // [138, 129, 142]
    }
}

3. 문자열 배열 대신 문자열 자료형을 여러개 전달하여 생성할 수도 ....

import java.util.ArrayList;
import java.util.Arrays;

public class Sample {
	public static void main(String[] args) {
        ArrayList<String> pitches = new ArrayList<>(Arrays.asList("138", "129", "142"));
        System.out.println(pitches);  // [138, 129, 142]
    }
}

String.join("구분자", 리스트 객체)

: ArrayList의 각 요소를 무언가로(콤마(,))로 구분하여 1개의 문자열로 만들기...

1) join이 없다면... 콤마를 하나하나 추가하여 마지막에 콤마는 제거한 후 출력

2) join을 사용한다면 간단하게 처리할수 있다!!

import java.util.ArrayList;
import java.util.Arrays;

public class Sample {
	public static void main(String[] args) {
    	ArrayList<String> pitches = new ArrayList<>(Arrays.asList("138", "129", "142"));
        String result = String.join(",", pirches);
        System.out.println(result); // "138, 129, 142"
    }
}

리스트 정렬하기

: 순서대로 정렬하기 위해서는 리스트의 sort 메서드 사용하기

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

public class Sample {
	public static void main(String[] args) {
    	ArrayList<String> pitches = new ArrayList<>(Arrays.asList("138", "129", "142"));
        pitches.sort(Comparator.naturalOrder()); // 오름차순 정렬
        System.out.println(pitches); // [129, 138, 142]
    }
}

- 오름차순 정렬 : Comparator.naturalOrder()

- 내림차순 정렬 : Comparator.reverseOrder()

8) 맵

- 딕셔너리와 유사하고  키와 값을 한 쌍으로 갖는 자료형

- 배열처럼 순차적으로 요솟값을 구하지 않고 키를 이용해 값을 얻는다

- HashMap, LinkedHashMap, TreeMap 등이 있다...

HashMap : 맵 자료형의 가장 기본

1. put 메서드 : key와 value를 추가

import java.util.HashMap;
public class Sample {
	public static void main(String[] args) {
    	HashMap<String, String> map = new HashMap<>();
        map.put("people", "사람");
        map.put("baseball", "야구");
    }
}
// key, value에 String 이외의 자료형은 사용할 수 없다

2. get 메서드 : key에 해당하는 value를 얻음

import java.util.HashMap;
public class Sample {
	public static void main(String[] args) {
    	HashMap<String, String> map = new HashMap<>();
        map.put("people", "사람");
        map.put("baseball", "야구");
        System.out.println(map.get("people")); // 사람
    }
}

// 맵의 key에 해당하는 value가 없을 떄 get 메서드를 사용하면 null이 리턴
System.out.println(map.get("java")); // null

// null 대신 기본값을 얻고 싶다면 getOrDefault 메서드를 사용하면 된다
System.out.println(map.getOrDefault("java", "자바")); //자바

3. containsKey 메서드 : 맵에 해당 key가 있는지를 true 또는 false로 리턴

HashMap<String, String> map = new HashMap<>();
map.put("people", "사람");
map.put("baseball", "야구");
System.out.println(map.containsKey("people")); // true

4. remove 메서드 : 맵의 항목을 삭제하는 메서드로, 해당 key의 항목을 삭제한 후 value 값을 리턴

HashMap<String, String> map = new HashMap<>();
map.put("people", "사람");
map.put("baseball", "야구");
System.out.println(map.remove("people")); // 사람

5. size 메서드 : 맵 요소의 개수를 리턴

HashMap<String, String> map = new HashMap<>();
map.put("people", "사람");
map.put("baseball", "야구");
System.out.println(map.containsKey("people")); 
System.out.println(map.size()); // 1

6. keySet 메서드 : 맵의 모든 key를 모아서 리턴

import java.util.HashMap;

public class Sample {
	public static void main(String[] args) {
    	HashMap<String, String> map = new HashMap<>();
        map.put("people", "사람");
        map.put("baseball", "야구");
        System.our.println(map.keySet()); // [baseball, people]
    }
}

++ ) 맵의 가장 큰 특징은 순서에 의존하지 않고 key로 value 값을 가져오는것이지만... 가끔 map에 입력된 순서대로 데이터를 가져오거나 입력한 key에 의해 정렬하도록 저장하고 싶을 수 있다...

- LinkedHashMap : 입력된 순서대로 데이터를 저장

- TreeMap : 입력된 key의 오름차순으로 데이터를 저장

9) 집합

: 집합과 관련된 것을 쉽게 처리하기 위해 만든것으로... HashSet, TreeSet, LinkedHashSet 등이 있다...

- 특징 2가지...

1. 중복을 허용하지 않는다

2, 순서가 없다(리스트와 배열은 순서가 있죠..., 순서가 없는 자료형이라 인덱싱을 지원하지 않는다)

교집합, 합집합, 차집합 구하기

1. 집합 자료형 2개 만들기

2. 교집합 구하기

3. 합집합 구하기

4. 차집합 구하기

import java.util.Arrays;
import java.util.HashSet;
 
 public class Sample {
 	public static void main(Stirng[] args) {
    	// 집합 자료형 두개 만들기 
    	HashSet<Integer> s1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5, 6));
        HashSet<Integer> s2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8, 9));
        
        // (교집합) = retainAll 메서드 이용
        HashSet<Integer> intersection = new HashSet<>(s1); // s1으로 intersection 이라는 HashSet 객체를 복사해 생성
        intersection.retainAll(s2); // 교집합 수행
        System.out.println(intersection); // [4, 5, 6]
        
        // (합집합) = addAll 메서드 이용
        HashSet<Integer> union = new HashSet<>(s1); // s1으로 union 생성
        union.addAll(s2); // 합집합 수행
        System.out.println(union);  // [1, 2, 3, 4, 5, 6, 7, 8, 9]
        
        // (차집합) = removeAll 메서드 이용
        HashSet<Integer> substract = new HashSet<>(s1); // s1으로 substract 생성
        substract.removeAll(s2); // 차집합 수행
        System.out.println(substract); // [1, 2, 3]
    }
}

집합 자료형과 관련된 메서드 - add, addAll, remove

1. add: 집합 자료형에 값을 추가

import java.util.HashSet;

public class Sample {
	public static void main(String[] args) {
    	HashSet<Stirng> set = new HashSet<>();
        set.add("Jump");
        set.add("To");
        set.add("Java");
        System.our.println(set); // [Java, To, Jump]
    }
}

2. addAll : 한꺼번에 여러개 값을 추가

import java.util.HashSet;

public class Sample {
	public static void main(String[] args) {
    	HashSet<Stirng> set = new HashSet<>();
        set.add("Jump");
        set.add("To");
        set.addAll(Arrays.asList("To", "Java"));
        System.our.println(set); // [Java, To, Jump]
    }
}

3. remove : 특정 값을 제거할 떄 사용

import java.util.HashSet;

public class Sample {
	public static void main(String[] args) {
    	HashSet<Stirng> set = new HashSet<>(Arrays.asList("Jump", "To", "Java"));
        set.add("To");
        System.our.println(set); // [Java, Jump]
    }
}

10) 상수 집합

 : enum 자료형은 서로 연관 있는 여러 개의 상수 집합을 정의할 때 사용

public class Sample {
	enum CoffesType {
    	AMERICANO,
        ICE_AMERICANO,
        CAFE_LATTE
    };
    
    public static void main(String[] args) {
    	System.out.println(CoffeeType.AMERICANO);  // AMERICANO
        System.out.println(CoffeeType.ICE_AMERICANO);  // ICE_AMERICANO
        System.out.println(CoffeeType.CAGE_LATTE);   // CAFE_LATTE
    }
}


// 반복문에서도 사용 가능
public class Sample {
	enum CoffesType {
    	AMERICANO,
        ICE_AMERICANO,
        CAFE_LATTE
    };
    
     public static void main(String[] args) {
     	for(CoffeeType type: CoffeeType.values()) {
        	System.out.println(type);  // 순서대로 AMERICANO, ICE_AMERICANO, CAFE_LATTE 출력
        }
    }
}

- enum 사용의 장점

1. 매직 넘버를 사용할 때보다 코드가 명확하다

2. 잘못된 값을 사용해 생길 수 있는 오류를 막을 수 있다

11) 형 변환과 final

: 형 변환이란 자료형을 다른 자료형으로 바꾸는 것 ("123"과 같은 문자열을 123과 같은 숫자형으로)

형변환 

1.  문자열을 정수로

String num = "123";
//문자열을 정수로 바꾸기 위해서는 Integer 클래스를 사용해야 한다

public class Sample {
	public static void main(String[] args) {
    	String num = "123";
        int n = Integer.parseInt(num);
        System.out.println(n); 			// 123
    }
}

2. 정수를 문자열로 : 정수 앞에 빈 문자열을 더해 주기 

public class Sample {
	public static void main(String[] args) {
    	int n = 123;
        String num = "" + n;
        System.out.println(num);  // 123
    }
}

 ++)  String.valueOf(정수), Integer.toString(정수) 모두 정수를 문자열로 바꾼다....

public class Sample {
	public static void main(String[] args) {
    	int n = 123;
        String num1 = String.valueOf(n);
        String num2 = Integer.toString(n);
        System.out.println(num1);   // 123
        System.out.println(num2);   // 123
    }
}

3. 소수점이 포함되어 있는 숫자 형태의 문자열의 변환

public class Sample {
	public static void main(String[] args) {
    	String num = "123.456";
        double d = Double.parseDouble(num);
        System.out.println(d);    // 123.456
    }
}

4. 정수와 실수 사이의 형 변환

public class Sample {
	public static void main(String[] args) {
    	int n1 = 123;
        double d1 = n1;
        System.out.println(d1);  // 123.0
        
        double d2 = 123.456;
        int n2 = (int) d2;
        System.out.println(n2);  // 123
    }
}

5. 실수 형태의 문자열을 정수로 바꿀 때

public class Sample {
	public static void main(String[] args) {
    	String num = "123.456";
        int n = Integer.parseInt(num);  // 실수 형태의 문자열을 정수로 변환할 경우 numberformatException이 발생
    }
}

// 실수 형태의 문자열을 숫자형으로 바꾸려면... Double.parseDouble()을 이용해 실수로 변환 후 사용

final

: 자료형에서 값을 단 한 번만 설정할 수 있게 강제하는 키워드 (다시 설정 안됩니다)

public class Sample {
	public static void main(String[] args) {
    	final int n = 123;   // final로 설정하면 값을 바꿀 수 없다
        n = 456;
    }
}

리스트의 경우도 final로 선언하면 재할당은 불가능...(더하거나 뺴기는 가능)

import java.util.ArrayList;
import java.util.Arrays;

public class Sample {
	public static void main(String[] args) {
    	final ArrayList<String> a = new ArrayList<>(Arrays.asList("a", "b"));
        a = new ArrayList<>(Arrays,asList("c", "d")); // 컴파일 오류 발생
    }
}

// 그러므로 final은 프로그램을 수행하면서 그 값이 바뀌면 안 될 때 사용한다

리스트의 재할당 뿐만아니라 더하거나 빼는 것도 할 수 없게 하고 싶다면... List.of를 작성하여 수정할 수 없는 리스트로 만들 수 있다!!!

import java.util.List;

public class Sample {
	public static void main(String[] args) {
    	final List<String> a = List.of("a", "b");
        a.add("c"); // UnsupportedOperationException 발생
    }
}

++) 문제 풀이

6. myList.sort(Comparator,reverseOrder());

7. String result = String.join(" ", myList);

8. int result = grade.remove("B")

9. ArrayList<Integer> result = new ArratList<>(temp);

10. 
public class Sample{
	enum CoffeeType {
    	AMERICANO,
        ICE_AMERICANO,
        CAFE_LATTE
    };
    
 ...
 
 printCoffeePrice(CoffeeType,AMERICANO);

자료형(data type)?

데이터의 종류와 크기를 결정하는 기본 구성 요소로 숫자, 문자열처럼 자료 형태로 사용하는 모든 것

1) 숫자

정수 : int, long(많이 사용함...) / byte, short(잘 사용 안함)

int age = 10;
long countingstar = 8764827384923849L; 
// int 자료형의 최댓값인 2147483647보다 크면 L;붙여줘야 한다!! => 없으면 컴파일 오류 발생

실수 : float, double

float pi = 3.14F;
double morePi = 3.14159265358979323846;
// 자바 실수 기본값은 double이므로 float 변수에 값을 대입할 때는 접미사로 F자를 꼭 붙여준다..
// 이것 또한 누락하면 컴파일 오류 발생!!

8진수와 16진수 : int 자료향을 사용

- 8진수 : 숫자 0으로 시작, 0~7까지를 사용하여 숫자를 표현한다

- 16진수 : 숫자 0과 알파벳 x로 시작..., 0~9까지의 숫자와 A부터 F까지의 알파벳을 사용하여 숫자를  표현한다

int octal = 023; // 십진수 : 19 (2 * 8의 1승 + 3* 8의 0승)
int hex = 0xC3; // 십진수 : 195 (12 * 16의 1승 + 3 * 16의 0승)

숫자 연산 : 사칙연산과 동일

// 나머지 연산자 : %
public class practice {
	public static void main(String[] args) {
		System.out.println(7%3); // 1
		System.out.println(3%7); // 3
	}
}

증감 연산 : ++, -- 기호를 이용하여 값을 증가 또는 감소 (++, -- 기호를 증감 연산자라고 한다)

int i = 0;
int j = 10;
i ++;
j --;

System.out.println(i); // 1
System.out.println(j); // 9

증감 연산자의 위치에 따른 변화..

- i++ : 값을 참조한 후에 증가

- ++i : 값을 참조하기 전에 증가 

// 후치 증감 연산자...
int i = 0;
System.out.println(i++); // 0
System.out.println(i);   // 1

// 전치 증감 연산자...
int i = 0;
System.out.println(++i); // 1
System.out.println(i); // 1

2) bool : 참 또는 거짓의 값을 갖는 자료형

불 연산 : 불 자료형에는 불 연산의 결괏값을 대입할 수 있다.

2 > 1 // 참
1 == 2 // 거짓
3 % 2 == 1 // 참
"3".equals("2") // 거짓

불 연산의 결과는 참 또는 거짓이므로 if 문과 같은 조건문에서 사용하거나 불자료형에 대입할 수 있다.

int i = 3;
boolean isOdd = i % 2 == 1;
System.out.println(isOdd); // true

3) 문자 : char 자료형을 사용한다(많이 사용하지는 않지만 문잣값을 표현하는 방식은 다양하다)

char a1 = 'a';   // 문자로 표현
char a2 = 97;	// 아스키코드로 표현
char a3 = '\u0061'; // 유니코드로 표현

System.out.println(a1); // a
System.out.println(a2); // a
System.out.println(a3); // a

4) 문자열: String을 사용한다

// 리터럴 표기 방식 : 객체를 생성하지 않고 고정된 값을 그대로 대입하는 방법
String a = "Happy Java";
String b = "a";
String c = "123";

// new 키워드 : 새로운 객체를 만들 떄 사용 
String a = new String("Happy Java")
String b = new String("a")
String c = new String("123")

원시 자료형 : int, long, double, float, boolean, char 자료형을 원시 자료형이라 한다.. 이러한 자료형들은 new 키워드로 값을 생성할 수 없다.. !!!!! String은 리터럴 표기방식을 사용할 수 있지만 원시 자료형에 포함 되지 않는다!!!! 특별 대우ㅡㅡ

boolean result = true;
char a = 'A';
int i = 100000;
// String만 둘다 가능... 특별 대우 화나요...
String a = "JAVA"
String b = new String("Python")

Wrapper 클래스 : 원시 자료형에 대응하는 Wrapper 클래스가 있는데 이는 원시 자료형을 대신하여 사용할 수 있는 자료형으로, 객체 지향 프로그래밍의 모든 기능을 활용할 수 있게 해준다.

앞으로 공부할 ArrayList, HashMap, HashSet 등은 데이터를 생성할 때 원시 자료형 대신 그에 대응하는 Wrapper 클래스를 사용해야 한다....

=> 값 대신 객체를 주고 받아 코드를 객체 중심으로 작성하는 데 유리!!

=> 멀티 스레드 환경에서 동기화를 지원하기 위해서도 Wrapper 클래스는 반드시 필요!!

문자열 내장 메서드 (내장 메서드: 문자열 객체에 속한 함수...)

- equals: 문자열 2개가 같은지를 비교하여 결괏값을 리턴

// equals
String a = "hello";
String b = "java";
String c = "hello";

System.out.println(a.equals(b)); // false
System.out.println(a.equals(c)); // true

// equals 메서드와 == 연산자 비교...
String a = "hello";
String b = new String("hello");
System.out.println(a.equals(b)); // true
System.out.println(a == b)l // false

// 값은 같지만 ==은 2개의 자료형이 같은 객체인지를 판별할 떄 사용하는 
연산자이지만 서로 다른 객체아므로 false를 리턴한다...

- IndexOf: 문자열에서 특정 문자열이 시작되는 위치(인덱스 값)를 리턴

String a = "Hello Java";
System.out.println(a.indexOf("Java"); // 6

- contains : 문자열에서 특정 문자열이 포함되어 있는지 여부를 리턴

String a = "Hello Java"
System.out.println(a.contains("Java")); // true

- charAt : 문자열에서 특정 위치의 문자를 리턴

String a = "Hello Java;
System.out.println(a.charAt(6)); // J

- replaceAll : 문자열에서 특정 문자열을 다른 문자열로 바꿀때 사용

String a = "Hello Java;
System.out.println(a.replaceAll("Java", "World")); // "Hello World"

- substring : 문자열에서 특정 문자열을 뽑아낼 떄 사용

String a = "Hello Java;
System.out.println(a.substring(0, 4)); // "Hell

- toUpperCase: 문자열을 모두 대문자로 변경할 때 사용

String a = "Hello Java;
System.out.println(a.toUpperCase()); // "HELLO JAVA"

- split : 문자열을 특정한 구분자로 나누어 문자열 배열로 리턴

String a = "a:b:c:d";
String[] result = a.split(":"); // result는 {"a", "b", "c", "d"}

문자열 포매팅 : 문자열 안에 어떤 값을 삽입하는 방법 (String.format 메서드를 사용)

- 숫자 바로 대입하기(%d)

System.out.println(String.format("I eat %d apples.", 3)); // "I eat 3 apples."
// 숫자를 넣고 싶은 자리에 %d를 입력, 삽입할 숫자를 두번째 파라미터로 전달
// %d : 문자열 포맷 코드..

- 문자열 바로 대입하기(%s)

System.out.println(String.format("I eat %s apples.", "five")); // "I eat five apples."
// %s : 문자열을 넣고 싶은 자리에 사용

- 문자열 포맷 코드의 종류

%s는 어떤 형태의 값이든 변환하여 넣을 수 있음 ;;

- %% : 특수 문자 %

System.out.println(String.format("Error if %d%%.", 98));
Error is 98%.

- 정렬과 공백 표현하기

System.out.println(String.format("%10s", "hi.")); // "           hi."
// %10s : 전체 길이가 10인 문자열 공간에서 대입되는 값(hi)을 가장 오른쪽으로 정렬하고 나머지는 공백으로 남겨두라는 의미

- 소수점 표현하기

System.out.println(String.format("%.4f", 3.42134234);; // 3.4213
// %.4f : 소수점 넷째 자리까지만 나타내고 싶어할 때 사용... 
// 길이가 10이고 소수점 넷째 자리까지 표시하고 싶다면... %10.4f

- System.out.printf

System.out.printf("I eat %d apples.", 3); // I eat 3 apples.
// System.out.printf 메서드를 사용하면 String.format 메서드가 없어도 사용 가능!!

5) StringBuffer 

: 문자열을 추가하거나 변경할 때 주로 사용하는 자료형

append : StringBuffer 객체를 생성하고 문자열을 생성

StringBuffer sb = new StringBuffer(); // StringBuffer 객체 sb 생성
sb.append("hello");
sb.append(" ");
sb.append("jump to java");
String result = sb.toString();
System.out.println(result); // "hello jump to java"

++) toString() 메서드 사용하기

String result = "";
result += "hello";
result += " ";
result += "jump to java";
System.out.println(result); // "hello jump to java"

=> 첫번째 두번쨰 결과는 같지만 내부적으로 객체를 생성하고 메모리를 사용하는 과정은 다르다..

첫번째는 StringBuffer 객체를 한번만 생성하지만... 두번째는 String 자료형에 + 연산이 있을 떄마다 새로운 String 객체를 생성하므로 총 4개의 String 자료향 객체가 만들어 진다... 

=> 무조건 StringBuffer를 사용하는 것이 좋을까? 

XX 상황에 따라 다르다... StringBuffer 자료형은 String 자료형보다 무거운 편에 속한다...

new StringBuffer()로 객체를 생성하면 String 을 사용할 때보다 메모리 사용량도 많고 속도도 느리기 때문에 문자열을 추가하거나 변경하는 작업이 많으면 StringBuffer를, 적으면 String을 사용하는 것이 유리하다

insert : 특정 위치에 원하는 문자열을 삽입

StringBuffer sb = new StringBuffer();
sb.append("jump to java");
sb.insert(0, "hello");
System.out.println(sb. toString()); // hello jump to java

- 문제 답-

1. ((a+b+c)/3), 70

2.

public class sol2 {
	public static void main(String[] args) {
		System.out.println(13 % 2);
    }
}

3. pin.substring(0, 6);

4. pin.charAt(7)); 

5. a.replaceAll(":", "#")

1. main 메서드 이해하기

•  클래스를 실행하려면 main 메서드를 작성해야한다
• 시작과 끝을 관리하는 것 = main 메서드(메서드는 함수와 동일한 개념)
• 자바는 모든것이 클래스 기반이므로 자바에서 사용하는 함수는 모드 메서드이다

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

• public : 메서드의 접근 제어자로, 누구나 이 메서드에 접근할 수 있다는 의미
• static : 메서드에 static이 지정되어 있으면 이 메서드는 인스턴스를 생성하지 않아도 실행할 수 있다는 것을 의미
• void : 메서드의 리턴값이 없음을 의미(void = '텅빈')
• String[] : 문자열을 나타내는 자바의 자료형([]은 값이 여러 개로 이루어진 배열이라는 것을 의미)
• args: String[] 자료형의 변수명
• System.out.println : 표준 출력으로 데이터를 보내는 자바의 내장 메서드로 문자열을 화면에 출력

2. 자바 코드의 구조 살펴보기

/* 클래스 블록 */
public class 클래스명 {

    /* 메서드 블록 */
    [public|private|protected] [static] (리턴자료형|void) 메서드명1(입력자료형 매개변수, ...) {
        명령문(statement);
        ...
    }

    /* 메서드 블록 */
    [public|private|protected] [static] (리턴자료형|void) 메서드명2(입력자료형 매개변수, ...) {
        명령문(statement);
        ...
    }

    ...
}

• 클래스 블록 : 자바 코드의 가장 바깥쪽 영역 / 클래스명은 사용자 마음대로 지을 수 o / 여러 메서드 블록을 포함

public class Sample {
    (... 생략 ...)
}
# 클래스 명 : Sample
# 클래스 블록은 중괄호({})로 둘러싸야 한다
# public은 자바의 접근 제어자로, 어디서든 이 클래스에 접근할 수 있음을 의미
# class는 클래스 블록을 만드는 키워드

• 메서드 블록 : [public | private | protected] : 메서드의 접근 제어자 / [static] : static 키워드가 붙으면 클래스 메서드가 되어 객체를 만들지 않아도 '클래스명.메서드명' 형태로 호출할 수 있다 / [void (리턴자료형)] : 리턴값이 없음을 의미

public class Sample {
    public static void main(String[] args) {
        (... 생략 ...)
    }
}
# 메서드 블록은 클래스 블록 안에 있으며 역시 중괄호({})로 영역을 구분한다
# 이 메서드의 이름은 main이다

• 명령문 : 메서드 블록 안에는 명령문이 있음... 컴퓨터에 무언가 일을 시키는 문장

public class Sample {
    public static void main(String[] args) {
        System.out.println("Hello java");
    }
}
# 명령문은 반드시 세미콜론(;)을 붙여 문장이 끝났다는 것을 표시해야한다
# 메서드 블록 안에는 명령문이 여러 개 있을 수 있다.

3. 변수와 자료형

• 변수(variable) : 값을 넣을 수 있는 빈 상자와 같다고 생각!

int a;
String b;
int one;
String two;
# 변수 이름을 지을 때의 3가지 규칙
1. 변수명은 숫자로 시작할 수 없다 ex) int 1st;
2. _와 &이외의 특수 문자는 사용할 수 없다 ex) int a#;
3. int, class, return등의 자바의 키워드는 변수명으로 사용할 수 없다 ex) int class;

• 자료형(type) : 값에는 어떤 형태가 정해져야 하는데... 이것의 형태를 말함

int a; // 변수 a의 자료형은 int(정수)이다 => 1, 10, 25 
String b; // 변수 b의 자료형은 String(문자열)이다 => 'a', 'hello'

• 변수에 값 대입하기 : 변수 선언 후, 변수에 값을 =(대입 연산자) 사용하여 대입

int a;
String b;

a = 1; // int 자료형 변수에 a에 1이라는 값을 대입
b = 'hello java'; // String 자료형 변수 b에 "hello java" 라는 값을 대입

int a = 1;
String b = "hello java";

• 사용자 정의 자료형 : 사용자가 자료형을 직접 만들 수 있다!!

class Animal {
}

Animal cat;  // cat 변수의 자료형은 Animal이며, cat 변수엔 Animal 자료형에 해당하는 값만 대입 가능

4. 이름 짓는 규칙

• 클래스 이름 짓기

# 클래스명은 명사로 한다.
# 클래스명은 대문자로 시작한다.
# 여러 개의 단어를 조합하여 만들 경우 각 단어의 첫 번째 글자는 대문자여야 한다
class Cookie {}
class ChocoCookie {}

• 메서드 이름 짓기

# 메서드명은 동사로 한다.
# 메서드명은 소문자로 시작한다.
# 여러 개의 단어를 조합하여 만들 경우 맨 첫 글자를 제외한 나머지 단어의 첫 글자는 대문자를 써서 구분
run();
runFast();
getBackground();

• 변수 이름 짓기

# 변수 이름은 짧지만 의미가 있어야 함 = 변수명을 보면 사용한 이유를 알 수 있어야 함
# 순서를 의미하고 임시로 쓰이는 정수의 변수명은 i, j, k, m, n을 사용
# 변수명에 _, $를 쓸 수 있지만, 시작 문자로 사용하는 것은 지양
String useName;
float lineWidth;
int i; // 주로 반복문에서 사용
char c; // 주로 반복문에서 사용

5. 주석

• 프로그래머의 의견이나 코드의 설명을 적을 수 있다
• 주석은 프로그램 코드에 삽입하더라도 프로그램을 수행하는 데 전혀 영향을 끼치지 않는다
• 블록 주석과 라인 주석의 두가지 형태가 있다

# 블록 주석 : /*로 시작하고 */으로 끝난다.. / 코드에서 블록 단위(클래스, 메서드 등)로 설명할 떄 주로 사용
/*
나는 집에 가고 싶습니다
왜냐면 월요병에 걸렸기 때문입니다
집은 멉니다... 힘듭니다
*/
public class Saffy {

# 라인 주석 : // 기호를 사용, //가 시작된 곳부터 그 라인의 끝까지 주석, 주석이 한줄일 경우 주로 사용
int age; 	// 동물의 나이

• 주석 올바르게 사용하기 : 알만한 내용을 주석 사용하여 지저분하게 만들지 않기, 코드에 엉뚱한 주석문 달려 혼돈을 주지 않게 하기

1) 패키지와 API 문서

1-1) 자바 라이브러리 

• 개발자가 편리하게 사용할 수 있도록 패키지 혹은 모듈을 압축한 파일

1-2) 패키지와 모듈

• 패키지 : 상호 관련 있는 클래스와 인터페이스를 한 곳에 묶어 놓은 것
• 모듈 : 밀접한 관계가 있는 패키지와 리소스를 묶어 놓은 것, JDK를 설치하면 jmods 폴더에 jmod 파일을 제공하는데 jmod 파일이 모듈 파일

1-3) 자바의 주요 패키지 및 모듈

1-4) API 문서

• 자바는 이런 패키지를 개발자가 사용할 수 있도록 API 형태로 제공하다
• 사용자는 API로부터 필요한 패키지를 임포트하면 모니터와 키보드를 쉽게 조작하는 프로그램을 작성할 수 있다
• JDK에 포함된 라이브러리는 매우 방대하기 때문에 개발자가 모두 기억할 수 없으므로 패키지를 올바르게 사용하려면 개발자는 API 문서를 자주 참조해야한다

- 교수님이 계속 모르는거 있으면 java.api 보라고 강조를 하신다. 대부분 영어라 해석하기 힘들어서 구글링이나 chat gpt를 많이 찾아보는데 언젠가 영어 실력과 코딩 실력을 키워서 api만들 이용하여 만들어도 보고 싶다!!

2) java.lang 패키지

2-1) 필수 패키지

• java.lang 패키지는 자바 프로그램에서 가장 기본이 되는 클래스와 인터페이스를 보관
• import 문 없이 사용

2-2) Object 클래스

• 모든 클래스의 조상
• Object 클래스가 제공하는 주요 메서드

2-3) Class 클래스

• 실행 중인 자바 프로그램 내부에 포함된 클래스와 인터페이스 정보를 제공하려고 getName(), getSimpleName() 등 다양한 메서드를 제공
• Class 클래스는 생성자가 없고 어떤 객체라도 생성하면  JVM이 대응하는 Class 객체를 자동으로 생성
• 실행 도중 객체 정보를 얻으려면  getClass()의 결과인 Class 객체를 사용
• ex) 주어진 obj객체에서 Class 객체를 얻으려면 

2-4) Math 클래스

• 모든 메서드가 static이기 때문에 객체를 생성하지 않고 메서드 호출
• Math 클래스가 제공하는 주요 double 타입의 메서드

답은

2-5) System 클래스

• 표준 입출력을 비롯한 실행 시스템과 관련된 필드와 메서드를 static으로 제공
• System.out.println()도 System 클래스가 제공하는 메서드
• System 클래스의 세가지 필드

• 자바에서 운영체제로부터 할당받은 메모리를 JVM이 관리
• JVM은 메모리가 부족하거나 주기적으로 가비지 컬렉터를 사용해 가비지를 수거
• 가비지를 수거하는 순서는 객체의 생성 순서와는 무관
• 프로그램에서 가비지 컬렉터를 직접 호출 불가, 대신에 System.gc()로 JVM에 가능하면 빨리 가비지 컬렉터를 실행하도록 요청 가능

답은

가비지의 생성 순서와 수거 순서는 무관하다!!

2-6) 포장 클래스

• 대부분의 기본 패키지가 제공하는 클래스의 메서드는 참조 타입을 매개변수로 사용하기 때문에 기초 타입을 사용하면 객체 지향 언어의 특징을 이용 불가
• 자바는 기초 타입을 포장해 클래스화 한 포장 클래스(wrapper class)를 제공해서 기초 타입 데이터도 기본 패키지를 활용하도록 함
• 모든 기초 타입에 대응하는 포장 클래스가 있으며, int와 char 타입에 대응하는 포장 클래스는 각각 Integer와 Character이며, 나머지 포장 클래스의 이름은 기초 타입의 첫 영문자를 대문자로 바꾼 것이다
• Integer 클래스가 제공하는 주요 메서드

• 기초 타입 데이터를 포장해 객체화하는 것을 박싱(boxing), 반대 과정을 언박싱(unboxing)

• 박싱을 수행하려면 포장 클래스의 생성자나 valueOf()메서드를 사용한다

답은

1) 패키지

1-1) 패키지의 의미

• 클래스 파일을 묶어서 관리하기 위한 수단으로 파일 시스템의 폴더를 이용
• 패키지마다 별도의 이름 공간이 생기기 때문에 클래스 이름을 사용하더라도 다른 패키지에 작성한 후 통합한다면 클래스 파일이 중복되지 않는다
• 클래스를 패키지 단위로도 제어할 수 있기 때문에 좀 더 세밀하게 접근을 제어할 수 있다

** 대표적인 패키지

• java.lang 패키지는 import 문을 선언하지 않아도 자동으로 임포트되는 자바의 기본 클래스를 모아둔 것
• java.awt 패키지는 그래픽 프로그래밍에 관련된 클래스를 모아둔 것
• java.io 패키지는 입출력과 관련된 클래스를 모아 둔 것

1-2) 패키지 선언

• 주석문을 제외하고는 반드시 첫 행에 선언
• 패키지 이름은 모두 소문자로 명명하는 것이 관례이고 일반적으로 패키지 이름이 중복되지 않도록 회사의 도메인 이름을 역순으로 사용한다

1-3) 패키지의 사용

• 다른 패키지에 있는 공개된 클래스를 사용하려면 패키지 경로를 컴파일러에게 알려 주어야 한다.
• 패키지 이름을 접두어로 사용해 다른 패키지에 있는 클래스를 이용한다. ex) new com.usa.people.Lincoln();
• 자바는 사용하려는 패키지 경로를 미리 컴파일러에 알려 줄 수 있도록 다음과 같이 import 문을 사용한다
• import 문은 소스 파일에서 package 문과 첫 번째 클래스 선언부 사이에 위치한다

• 컴파일러에 Lincoln 클래스의 경로를 알려준다
• import 문으로 경로를 알려 주었으므로 com.usa.people이라는 경로 정보는 필요 없다

2) 자식 클래스와 부모 생성자

• 생성자는 클래스 멤버가 아니므로 자식 클래스에 상속되지는 않는다
• 하지만 부모에게서 물려받은 멤버가 있다면 자식 클래스는 이를 초기화하기 위해 부모 클래스의 생성자가 필요하다

• 자식 생성자의 첫 행에 부모 생성자를 호출하는 코드가 있다

3) 상속과 접근제어

3-1) 접근 지정자의 접근 범위

• 자바는 클래스와 클래스 멤버를 다른 객체에 공개하는 범위를 명시하려고 private, protected, public이라는 접근 지정자(access modifier)를 제공한다

• 다른 클래스에 공개하려면 public, 자식 클래스에만 공개하려면 protected, 공개하지 않으면 private으로 지정한다.    접근 지정자로 지정하지 않을 때는 해당 패키지에서만 공개되는데, 이를 디폴트 접근 지정이라고 한다
• private 멤버는 자식 클래스에 상속되지 않는다
• 클래스 멤버는 어떤 접근 지정자로도 지정할 수 있지만, 클래스는 protected와 private으로 지정할 수 없다
• 메서드를 오버라이딩할 때 부모 클래스의 메서드보다 더 좋은 접근 지정을 할 수 없다.

4) final 클래스와 메서드

4-1) final 클래스

• 더 이상 상속할 수 없는 종단 클래스를 의미
• final 클래스의 목적은 자식 클래스를 정의해 비공개 정보에 접근하거나 시스템을 파괴하는 경우를 방지하는 것이다
• 자바 표준 API가 제공하는 String 클래스는 대표적인 final 클래스로 다음과 같이 자식 클래스를 선언한다면 오류가 발생한다

ex) class ChildString extends String {..}  =>  String은 final 클래스이므로 부모 클래스가 될 수 없다

4-2) final 메서드

• final 메서드는 더 이상 오버라이딩할 수 없는 종단 메서드이다
• 따라서 부모 클래스에서 정의한 final 메서드를 자식 클래스는 수정 없이 그대로 사용해야 한다
• 특정 메서드만 오버라이딩하지 않도록 하려면 final 메서드로 선언한다

=> 체스 게임은 흰색 선수가 먼저 시작하는 것이 관례이므로 시작 순서를 바꾸지 않아야 하므로 체스의 시작 선수를 정하는 메서드를 final로 지정ㅎ해서 게임의 순서를 고정한 예제이다