수테크📱⌚️👀

문제 😵‍💫

https://school.programmers.co.kr/learn/courses/30/lessons/42840

내 풀🦷

import java.util.*;

class Solution {
    public int[] solution(int[] answers) {
        // 수포자들의 패턴 정의
        int[] pattern1 = {1, 2, 3, 4, 5};
        int[] pattern2 = {2, 1, 2, 3, 2, 4, 2, 5};
        int[] pattern3 = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};
        
        // 점수를 계산할 배열
        int[] scores = new int[3];
        
        // 각 문제에 대해 수포자들의 답안을 비교하여 점수 계산
        for(int i = 0; i < answers.length; i++) {
            if(answers[i] == pattern1[i % pattern1.length]) {
                scores[0]++;
            }
            if(answers[i] == pattern2[i % pattern2.length]) {
                scores[1]++;
            }
            if(answers[i] == pattern3[i % pattern3.length]) {
                scores[2]++;
            }
        }
        
        // 제일 높은 점수를 찾음
        int maxScore = Math.max(scores[0], Math.max(scores[1], scores[2]));
        
        // 가장 높은 점수를 받은 수포자를 리스트에 추가
        List<Integer> result = new ArrayList<>();
        for(int i = 0; i < scores.length; i++) {
            if(scores[i] == maxScore) {
                result.add(i+1);
            }
        }
        
        return result.stream().mapToInt(i -> i).toArray();
    }
}

가장 많은 점수를 획득한 사람을 배열로 반환하는 간단한 문제였다!!

담는것 까지는 정말 쉬운데 return 문 작성하는 과정에서 어려움이 있었다!

참고하면 좋을 개념들 ✍️

• .stream()
  • stream : 데이터 컬렉션의 추상화로, 요소들을 차례차례 꺼내 처리할 수 있는 "데이터 흐름" 
  • List<Integer> 객체에서 각 요소에 접근할 수 있는 스트림을 생성한다 
  • 스트림은 데이터 처리 작업을 쉽게 할 수 있도록 도와주는 추상화 도구이다
• .mapToInt(i -> i) 
  • 스트림의 각 요소를 정수로 변환한다
  • i -> i는 람다 표현식으로, 리스트의 각 요소를 i 그대로 변환한다는 의미이다
  • 이 과정에서 객체(Integer)를 원시 타입(int)으로 변환하게 된다
• .toArray() 
  • 스트림의 결과를 배열로 변환한다
  • 최종적으로 List<Integer> 가 int[] 배열로 변환된다

(월요일)

# 최초의 프로그래머

https://namu.wiki/w/%EC%97%90%EC%9D%B4%EB%8B%A4%20%EB%9F%AC%EB%B8%8C%EB%A0%88%EC%9D%B4%EC%8A%A4

# it 언어의 역사

C언어의 탄생

- 직관적 언어

- 변수, 조건문, 반복문, 함수

- H/W, OS 변화시, 다시 컴파일 필요

- 메모리 직접 할당/해제

- 위 2문제점들로 탄생함 => Java (JVM에서 실행됨 / OS에 맞는 JVM 환경 구성)

Java의 시작

- 참조형(데이터가 무질서하게 들어감, 데이터의 주소가 들어감) / 값형(데이터의 값이 들어감)

- Garbage Collection 

- OOP 

JRE(Java Runtime Environment)

- JDK = JRE + development tools

- JRE = JVM + libraries

# jdk 다운로드

https://www.oracle.com/java/technologies/downloads/

환경변수 구성
JAVA_HOME : C:\Program Files\Java\jdk-21
PATH : %JAVA_HOME%\bin

환경변수 구성 확인
java -version

javac -version

# 메모장으로 코딩해서 컴파일 해보기

- java는 객체지향 언어

- class 단위로 메모리에 올라간다

- main메소드만 실행한다

- 함수는 4가지로 구성 : 메서드 이름, 입력값, 처리 구문, 출력값

- 명령어 마침표 : 세미콜론(;)

- public : 접근제한자 공개!!

- static : cpu가 main메소드를 찾기 쉽게 하는것!

- void : 반환값이 없다는 의미(return이 없음)

# 메모장 개발~
class Hello {
	public static void main(String[] args) {
		// 이것은 한줄 주석입니다.
		System.out.println("Hello Seoul");
		/* 이것은
		    여러줄 주석
		    입니다.
		*/
	}
}
// 주석은 제외하고 컴파일한다(날짜, 만든 목적,설명시 주석 사용)

javac Hello.java # cmd에서 컴파일 명령어
java Hello # Hello 메서드 실행

# Java 개발 환경 구성

- Eclipse 구성

• 자바 프로그램을개발할 때 가장 많이 사용하는 통합 개발 환경(IDE)
• JDK 21을 지원하는 Eclipse IDE 2023-12이상 버전 사용 
• [ctrl] + [s] (저장) 을 누르면 바로 컴파일된다!!

https://www.eclipse.org/downloads/

# JVM 메모리 구조

Heap 영역 : 무질서한 공간 / 참조형 친구들(string) 

Method 영역 :  모든 경우에서든 접근 가능하도록..?(1층 화장실은 다 사용 가능/ 내 화장실 못쓴다) 

Stack 영역 : 값형 데이터가 쌓임(책 쌓이듯이 - 사이즈가 명확해야함) / 데이터를 뺄때는 (LIFO) 

Heap 영역: 동적으로 할당되는 메모리로, 무질서하게(즉, 일정한 순서 없이) 데이터가 저장되는 공간이에요. 
           주로 참조형 데이터(예: 객체)가 할당됩니다. 말 그대로 무질서한 공간이라, 
           메모리 관리를 잘 하지 않으면 메모리 누수(메모리를 차지한 채 반환되지 않는 상황)도 발생할 수 있어요.

Method 영역: 프로그램이 실행될 때 로드되는 클래스, 메서드, 정적 변수 등이 저장되는 공간입니다. 
            그래서 어디서든 접근할 수 있게 준비된 공용 공간 같은 느낌이에요. 
            이곳에는 고정된 데이터가 주로 저장되기 때문에 다른 쓰레드에서도 동시에 접근할 수 있습니다.

Stack 영역: 함수 호출 시 할당되는 메모리로, 각 호출마다 메모리가 쌓이고(LIFO - 후입선출 구조) 함수가 
            종료되면 해당 메모리가 해제됩니다. 간단한 값형 데이터(예: int, float)가 여기에 쌓이는데, 
            데이터의 크기가 명확하게 정해져 있어야 하죠.

public class Type01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		short a1 = 10;
		int a2 = 20;
		int a3 = a1;
		short a4 = (short) a2; // 큰거에서 작은걸로 넘어가려면 명시적으로 표기해줘야 error가 나지 않는다
		
		System.out.println(a1); 10
		System.out.println(a2); 20
		System.out.println(a3); 10
		System.out.println(a4); 20
	}
}

(화요일)

# 값형 vs 참조형

package thisisjava;

public class Type02 {

	public static void main(String[] args) {
		// 값형은 초기값을 설정해야 에러가 안남..
		byte a1; a1 = 10;
		short a2 = 20;
		int a3 = 30;
		long a4 = 40;
		char a5 = 'A'; char a6 = '강';  // 여기까지 값형(그릇이 만들어지고 값을 넣음)
		String a7 = "서울"; // 참조형은 데이터가 만들어지고 그릇에 담는다(주소가 스택에 들어가있음)
		
		System.out.println(a1);
		System.out.println(a2);
		System.out.println(a3);
		System.out.println(a4);
		System.out.println(a5);
		System.out.println((int)a5); // 65
		System.out.println((int)'a'); // 97
		System.out.println(a6);
		System.out.println(a7);
	}
}

# 실수형 & boolean 타입 

package thisisjava;

public class Type03 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		float a1 = 3.14f; // float 타입이라고 명시 해줘야 한다!! / 4byte
		double a2 = 3.14; // 8byte
		System.out.println(a1);
		System.out.println(a2);
		
		boolean b1 = true;
		boolean b2 = 3 > 4;
		System.out.println(b1);
		System.out.println(b2);
	}
}

# 2진수, 10진수, 16진수 비교하기

package thisisjava;

public class Type04 {
	public static void main(String[] args) {
		char a1 = 'A';
		System.out.println(a1); 
		System.out.println((int)a1); // 65
		System.out.println(Integer.toBinaryString(a1));
		System.out.println(Integer.toOctalString(a1));
		System.out.println(Integer.toHexString(a1));
		
		char a2 = 65;
		System.out.println(a2); // A
		
		char a3 = 0101;
		System.out.println(a3); // A
		
		char a4 = 0x0041;
		System.out.println(a4); // A
	}
}

# string의 주소 변환 & \ 사용법

package thisisjava;

public class Type05 {

	public static void main(String[] args) {
		String s1 = null;
		System.out.println(s1);
		s1 = "서울";
		System.out.println(s1); // garbage collector가 데이터를 치워줌..
		s1 = null;
		System.out.println(s1);
		
		String s2 = "사랑";
		System.out.println(s2); 
		s2 = "썰렁"; // 데이터의 값이 아니라 주소가 바뀜!! / 사랑에 대한 데이터는 gc가 치워줌
		System.out.println(s2);
		
		String s3 = "'사랑'합니다.";
		s3 = "\"사랑\"합니다."; // 큰따옴표 안에 큰따옴표 넣고 싶으면 \ 사용!!
		s3 = "2024년 11월 12일. \n"
				+ "날씨가 좋아요 \n그래서, "
				+ "맛있는 점심을 먹고싶어요";
		System.out.println(s3);
		
		System.out.print("안녕");  
		System.out.print("하세요");  
		
	}
}

# 값형 -> 참조형 데이터 변환

package thisisjava;

public class Type06 {

	public static void main(String[] args) {
		// 값형 안에서의 형변환은 사이즈 변환만 가능!(스택 안에서의 위아래만 변환)
		short a1 = 10;
		int a2 = a1; // 자동 형변환
		System.out.println(a2);
		
		short a3 = (short) a2; // 강제 형변환
		System.out.println(a3);
		
		// 값형에서 참조형으로 바꿔줄때는 자바 문법이 필요하다
		int a4 = 20;
		String s4 = String.valueOf(a4); // 데이터만 이전하고 주소만 a4로 넘김
		System.out.println(a4);
		
		// 참조형에서 값형으로 
		String s5 = "30";
		int a5 = Integer.parseInt(s5);
		System.out.println(a5);
	}
}

# 출력 방식에 따라 println vs printf()

• println(내용) : 괄호 안의 내용을 출력하고 행을 바꿔라
• print(내용) : 괄호 안의 내용을 출력하고 행은 바꾸지 마라
• printf("형식문자열", 값1, 값2....) : 형식에 맞춰서 출력해라(행은 바꾸지 않음)

package thisisjava;

public class Type07 {

    public static void main(String[] args) {
        // 동일한 데이터 타입으로 변수를 나열할때는 쉼표로 연결할 수 있다
        String s1 = "apple", s2 = "포도"; 
        int a1 = 500, a2 = 700;

        System.out.println(s1 + " 가격은 " + a1 + "원이다.");
        System.out.printf("%s 가격은 %d원이다.\n", s1, a1); 
        
        System.out.println(s2 + " 가격은 " + a2 + "원이다.");
        System.out.printf("%s 가격은 %d원이다.\n", s2, a2);  

        String s3 = "딸기", s4 = "수박";
        float a3 = 900.99f;
        double a4 = 3333.33;

        System.out.printf("%s 가격은 %.2f원이다.\n", s3, a3);  
        System.out.printf("%s 가격은 %.2f원이다.\n", s4, a4); 
        
        System.out.printf("%s 가격은 %d원이다.\n", "과일", 45678); 
        System.out.printf("%s 가격은 %10d원이다.\n", "과일", 45678); 
        System.out.printf("%s 가격은 %-10d원이다.\n", "과일", 45678); 
 
        System.out.printf("%s 가격은 %f원이다.\n", "과일", 123.45); 
        System.out.printf("%s 가격은 %5f원이다.\n", "과일", 123.45); 
        System.out.printf("%s 가격은 %.2f원이다.\n", "과일", 123.45); 
        System.out.printf("%s 가격은 %5.2f원이다.\n", "과일", 123.45); 

        System.out.printf("%s는 과일이다.\n", "사과"); 
        System.out.printf("%5s는 과일이다.\n", "사과"); // 5칸에서 우측부터 채움
        System.out.printf("%-5s는 과일이다.\n", "사과"); // 5칸에서 좌측부터 채움
    }
}

# Scanner(키보드 입력)

package thisisjava;

import java.util.Scanner;

public class Type08 {

	public static void main(String[] args) {
		System.out.println("이름 입력=>");
		Scanner sc = new Scanner(System.in);
		// 빨간줄 Click(import ~)
		// 직접 작성(import 문장)
		// Ctrl + Shift + o(영문)
		String name = sc.next();
		System.out.print(name + "님, 안녕하세요");
		sc.close();
	}
}

# 산술 연산자

- 오버플로우 : 타입이 허용하는 최대값을 벗어나는 것(예를 들어, short의 최댓값이 127에 1을 더하면 128이 되어 오버플로우가 발생하므로 연산결과는 최소값인 -128이 된다!!)

- 언더플로우 : 타입이 허용하는 최소값을 벗어나는 것

package thisisjava;

public class Op01 {

	public static void main(String[] args) {
		
		int i1 = 20, i2 = 10;
		
		System.out.println(i1+i2); // 산술연산자
		System.out.println(i1-i2);
		System.out.println(i1*i2);
		System.out.println(i1/i2);
		System.out.println(i1%i2);
		
		String s1 = "30", s2 = "40"; 
		System.out.println(s1+s2); // 연결연산자
		
		int i3 = Integer.parseInt(s1) + Integer.parseInt(s2); // Quiz
		
		System.out.println(i3); // 70
		
		int i4 = 100;
		i4 = i4 + 2; 
		System.out.println(i4);
		
		i4 += 2; 
		System.out.println(i4);
		
		i4 *= 2; 
		System.out.println(i4);
		
		i4 /= 2; 
		System.out.println(i4);
		
		byte b1 = 127;
		//b1 = b1 + 1;
		System.out.println(b1+1); // 128
		b1 += 1;
		System.out.println(b1); // -128(오버 플로우)
		System.out.println(b1+1);
		
	}

}

< 진법의 음수 & 양수 / 제일 앞자리 : 부호 비트(0이면 양수, 1이면 음수) >

# 나눗셈연산에서 예외 방지하기

• 나눗셈(/) 또는 나머지(%)연사에서 좌측 피연산자가 정수이고 우측 피연산자가 0일 경우 ArithmeticException발생
• 좌측 피연산자가 실수이거나 으측 피연산자가 0.0또는 0.0f이면 예외가 발생하지 않는다

System.out.println(5/0.0); // Infinity
System.out.println(5%0.0); // NaN

# 증감연산자

- 전치증감연산자 : ++a

- 후치증감연산자 : a--

package thisisjava;

public class Op02 {

	public static void main(String[] args) {
		// ++ , --
		int a = 10;
		int b = --a;
		System.out.println(a); // 9
		System.out.println(b); // 9
		
		int c = a--;
		System.out.println(a); // 8
		System.out.println(c); // 9

		int d = ++a;
		System.out.println(a); // 9
		System.out.println(d); // 9
		
		int e = a++;
		System.out.println(a); // 10
		System.out.println(e); // 9
	}

}

# 논리 연산자 && 비트논리연산자

package thisisjava;

public class Op03 {

	public static void main(String[] args) {
		int i = 4, j = 3;
		System.out.println(i==j); // 비교연산자
		System.out.println(i>j);
		System.out.println(i!=j);
		
		System.out.println(true&&true);
		System.out.println(true&&false);
		System.out.println(true&true);
		System.out.println(true&false);
		
		System.out.println(false&&true);
		System.out.println(false&&false);
		System.out.println(false&true);
		System.out.println(false&false);
		
		System.out.println(true||true);
		System.out.println(true||false);
		System.out.println(false||true);
		System.out.println(false||false);
		
		System.out.println("------");
//		System.out.println(6&&4);//논리연산자 (불리언 타입으로만 와야함)
		System.out.println(6&4);//비트논리연산자 (이진수로 바꾸고 비교!)
//		System.out.println(6||3);//논리연산자
		System.out.println(6|3);//비트논리연산자	
		
		int k = 8; // 1000(2)
		System.out.println(k >> 1); // 100(2) 
		System.out.println(k << 1); // 100000(2)
	}
}




package thisisjava;
public class Op04 {
	public static void main(String[] args) {
		int a = 7, b = 3;
		System.out.println((a==b)&&(a>b++));//false
		System.out.println(b);//3
		
		System.out.println((a==b)&(a>b++));//false
		System.out.println(b);;//4
		
		System.out.println((a!=b)||(a>b++));//true
		System.out.println(b);;//4
		
		System.out.println((a!=b)|(a>b++));//true
		System.out.println(b);;//5

	}

}

(수요일)

# 삼항 연산자

- 총 3개의 피연산자를가짐

- ? 앞의 피연산자는 boolean 변수 또는 조건식이 참이면 : 뒤에 앞에 것을 선택하고 거짓이면 뒤에 것을 선택 

package ch03.sec11;

import java.util.Scanner;

public class ConditionalOperationExample {
	public static void main(String[] args) {
//		int score = 85;
//		char grade = (score > 90) ? 'A' : ( (score > 80) ? 'B' : 'C' );
//		System.out.println(score + "점은 " + grade + "등급입니다.");
		
		/* 90점이상이면, 우수
		 * 80점이상이면, 보통
		 * 80점미만이면, 부족
		*/
		System.out.print("자신의 점수를 입력하시오 => ");
		Scanner sc = new Scanner(System.in);
		int score = sc.nextInt();
		
		String grade = ((score >= 90) ? "우수" :
			((score >= 80) ? "보통" :
				((score >= 70) ? "부족" : "낙제")));
		System.out.printf("Score는 %d점, %s", score, grade);
		sc.close();
	}
}




package ch03.sec11;

public class ConditionalOperationExample {
	public static void main(String[] args) {
		int score = 85;
		char grade = (score > 90) ? 'A' : ( (score > 80) ? 'B' : 'C' );
		System.out.println(score + "점은 " + grade + "등급입니다.");
	}
}

# if - else (조건문)

package thisisjava;

import java.util.Scanner;

public class if01 {

	public static void main(String[] args) {
		// 조건식 ? true : false
		System.out.print("숫자를 입력하세요 => ");
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		String ans = null;
		
		if((n % 2) == 0) {
			ans = "짝수"; 
		} else {			
			ans = "홀수"; 
		}
		
		System.out.println(ans);
		sc.close();
	}
}


package thisisjava;

import java.util.Scanner;

public class if02 {

	public static void main(String[] args) {
		System.out.print("점수를 입력하세요 => ");
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		String score = null;
		
		if(n >= 90) { score = "우수"; }
		else if(n >= 80) { score = "보통"; }
		else if(n >= 70) { score = "부족"; }
		else { score = "낙제"; }
		
		System.out.printf("제점수는 %d이고, %s입니다", n, score);
		sc.close();

	}
}

# switch - case 문

package thisisjava;

import java.util.Scanner;

public class switch01 {

	private static final int case1 = 0;

	public static void main(String[] args) {
		// 조건식 ? true : false
		System.out.print("숫자를 입력하세요 => ");
		Scanner sc = new Scanner(System.in);
		int n = (sc.nextInt() % 2);
		sc.close();
		
		String ans = null;
		
		switch (n) {
			case 0: ans = "짝수";
				break; // 빠져 나가주지 않으면 다 기타로 빠짐....
			case 1: ans = "홀수";
				break;
			default: ans = "기타";
		}
		
		System.out.println(ans);
	}

}

#  ==과 .equals()의 차이

package thisisjava;

import java.util.Scanner;

public class str01 {

	public static void main(String[] args) {
		int i1 = 20, i2 = 10, i3 = 20;
		System.out.println(i1 == i2);
		System.out.println(i1 == i3);
		
		// s1 : KR을 먼저 만들고 주소 할당하고 / s2 : 이미 KR이 있으므로 같은 주소가 들어감
		String s1 = "KR", s2 = "KR";
//		String s3 = new String("KR");
		System.out.println(s1 == s2);
//		System.out.println(s1 == s3);
		System.out.println(s1.equals(s2));
		
		// 외부에서 입력받았을 경우..
		// 어떤 데이터가 올지 몰라서 일단 주소를 넣고 KR이 들어감!! 그래서 키보드로 입력받은것은 
		// 이미 heap에 저장되어 있는 값이더라도 주소가 다를 수 밖에 없다 
		System.out.println("KR 입력 =>");
		Scanner sc = new Scanner(System.in);
		String s3 = sc.next();
		sc.close();
		
		System.out.println(s1 == s3);
		System.out.println(s1.equals(s3));
	}
}

# 화살표 처리 (jdk12버전 부터 있었당)

package thisisjava;

import java.util.Scanner;

public class switch03 {

	public static void main(String[] args) {
		System.out.println("영어를 알려줘 👇👇👇👇");
		Scanner sc = new Scanner(System.in);
		String direction = sc.next();
		String eng;
		sc.close();
		
		switch(direction) {
			case "동" -> eng = "East";
			case "서" -> eng = "West"; 
			case "남" -> eng = "South"; 
			case "북" -> eng = "North"; 
			default -> eng = "기타"; 
		}
		
		System.out.printf("%s에 대한 영어 단어는 %s입니다 :)", direction, eng);
	}
}


package thisisjava;

import java.util.Scanner;

public class switch04 {

	public static void main(String[] args) {
		System.out.println("영어를 알려줘 👇👇👇👇");
		Scanner sc = new Scanner(System.in);
		String direction = sc.next();
		sc.close();
		
		String eng = switch(direction) {
			case "동", "동쪽", "동녁" -> "East";
			case "서" -> "West"; 
			case "남" -> {
				String result = "South" + "방향";
				yield result;  // switch 표현식의 반환 값을 지정할 때 사용
			}
			case "북" -> "North"; 
			default -> "기타"; 
		};
		
		System.out.printf("%s에 대한 영어 단어는 %s입니다 :)", direction, eng);
	}
}

(목요일)

# 가위바위보 게임!!

package thisisjava;

import java.util.Scanner;

public class if07 {

	public static void main(String[] args) {

		int num = (int)(Math.random()*3); // 상대 랜덤

		String sRan; // 상대꺼 저장
		if(num== 0) { sRan= "가위"; }
		else if (num == 1) { sRan= "바위"; }
		else { sRan= "보"; }		
		
		System.out.println("가위/바위/보 입력 => ");
		Scanner sc = new Scanner(System.in);  // 내꺼 입력
		String sMe= sc.next(); // 내꺼 저장
		
		// 비기는 경우 (가위-가위, 바위-바위, 보-보)
		if(sMe.equals("가위") || sMe.equals("바위") || sMe.equals("보")) {
//			while(sMe.equals("가위") || sMe.equals("바위") || sMe.equals("보")) {
			System.out.printf("나 : %s, 상대 : %s \n",sMe,sRan);
			if(sMe.equals(sRan)) { System.out.println("비김");}
			// 이기는 경우 (가위-보 || 바위-가위 || 보-바위)
			else if(    (sMe.equals("가위") && sRan.equals("보"))
					|| (sMe.equals("바위") && sRan.equals("가위"))
					|| (sMe.equals("보") && sRan.equals("바위"))
					){
				System.out.println("이김");
			}
			// 지는 경우
			else { System.out.println("졌음"); }			
		}
		else {
			System.out.println("잘못입력하였습니다 (TㅡT)");
		}
	}
}

# 강사님 문제

package thisisjava;

import java.util.Scanner;

public class if08 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("국어 점수 입력 => ");
		int iKr = sc.nextInt();
		System.out.println("영어 점수 입력 => ");
		int iEn = sc.nextInt();
		sc.close();
		
		int iTotal = iKr + iEn;
		double dAvg = iTotal / 2.0; // int로 계산한뒤 저장하기 때문에 2를 double인 2.0으로 바꿔줌
		System.out.printf("총점 : %d, 평균 : %.2f \n", iTotal, dAvg);
		
		if(iKr < 60 || iEn < 60) {
			System.out.println("과목낙제 입니다 FFF");
		}
		else {
			if(dAvg >= 90) {
				System.out.println("우수");
			} else if(dAvg >= 80) {
				System.out.println("보통");
			} else if(dAvg >= 70) {
				System.out.println("부족");
			} else {
				System.out.println("평균낙제");
			}
		}
	}

}

https://www.w3schools.com/

공부하기 좋은 url

# 반복문 3가지!! (for / while / do-while)

package thisisjava;

public class for01 {

	public static void main(String[] args) {
		// 1 ~ 5 까지 가로방향 출력
		// 시작점 : int i = 1 / 끝점 : i <= 5 / 스텝 : 1씩 증가 : i++ / 처리 : 가로 방향 출력 (syout) 
		
		/*
		 for문의 구조
		 for(시작점; 끝점; 스텝;) {
		 	처리;
		 }
		 */
		
		for(int i = 5; i >= 1; i--) {
			System.out.print(i + " ");
		}
		
		
		/*
		 while문의 구조
		 시작점;
		 while(끝점) {
		 	처리;
		 	스텝;
		 }
		 */
		int z = 5;
		while(z >= 1) {
			System.out.print(z + " ");
			z--;
		}
		
		
		/*
		 do - while문의 구조
		 시작점;
		 do {
		 	처리;
		 	스탭;
		 }while (끝점);
		 */
		
		int y = 5;
		do {
			System.out.print(y + " ");
			y--;
		}
		while(y >= 1);
		
	}
}

# 예외처리

package thisisjava;

import java.util.InputMismatchException;
import java.util.Scanner;

public class try01 {

	public static void main(String[] args) {
		System.out.print("숫자 하나 입력 => ");
		Scanner sc = new Scanner(System.in);
		
		try {
			int i1 = sc.nextInt();
			int i2 = 100/i1;
			System.out.println(i2);			
		} catch(ArithmeticException e) {
			System.out.println("0은 안되요");
			System.out.println(e);
		} catch(InputMismatchException e) {
			System.out.println("문자는 안되요");
			System.out.println(e);
		}
		sc.close();
	}
}

(금요일)

# array 기초

package thisisjava;

public class arr01 {

	public static void main(String[] args) {
		int i1 = 10;
		int i2 = 20;
		int i3 = 30;
		int i4 = 40;
	
		int[] iArr1 = {10, 20, 30, 40};
		
		
		for(int i = 0; i < iArr1.length; i++) {
			System.out.println(iArr1[i]);
		}
		System.out.println();
		
		// sArr1 세로방향 출력
		String[] sArr1 = {"사과", "배", "바나나"};
		for(int i = 0; i < sArr1.length; i++) {
			System.out.println(sArr1[i]);
		}
	}
}

package thisisjava;

import java.util.Arrays;

public class arr02 {

	public static void main(String[] args) {
		int i1 = 100, i2 = 200;
		
		int[] iArr1 = {10, 20, 30, 40};
		// 다른 메모리를 쓰는 이유 : 구조를 만들고 데이터를 넣는 것이므로 같은 값이더라도 주소값이 다르다
        /*
        새로운 메모리 공간에 구조(배열 객체)를 할당하고 그 안에 데이터를 넣는 방식으로 동작하므로, 
         같은 데이터가 들어가더라도 객체마다 별개의 메모리 주소를 가지게 됩니다. 
         */
		int iArr2[] = {10, 20, 30, 40}; 
		if(Arrays.equals(iArr1, iArr2)) {
			System.out.println("g");
		}
		
		// new를 보면 heap 공간에 데이터를 넣기 위해 확보한다는 의미
		int[] iArr3 = new int[4]; 
		
		iArr3[0] = 11; iArr3[1] = 22; 
		iArr3[2] = 33; iArr3[3] = 44; 
		
		for(int i = 0; i < iArr3.length; i++) {
			System.out.println(iArr3[i]);
		}
	}
}

# 향상된 for 문

package thisisjava;

public class arr04 {

	public static void main(String[] args) {
		int[] iArr1 = {10, 20, 30, 40, 50};
		
		// 방번호 붙여서 가지고 올래
		for(int i = 0; i < iArr1.length; i++) {
			 System.out.print(iArr1[i] + " ");
		}
		
		System.out.println();
		
		// 방값 복사해서 가지고 올래..
		for(int iA : iArr1) {
			System.out.print(iA + " ");
		}
	}
}

# String과 String[]의 메모리 구조 이해!!!

#  null & nullPointerException

package thisisjava;

public class arr06 {

	public static void main(String[] args) {
		// 사과, 배, 바나나가 들어가는 빈 STring 배열 3칸 구성
		String[] fruits =  new String[3];
		
		for(int i = 0; i < fruits.length; i++) {
			System.out.print(fruits[i] + " "); // null : 연결할 주소 없음
		}
		
		fruits[0] = "사과";
		fruits[1] = "배";
		fruits[2] = "바나나";
		
	}
}


package thisisjava;

public class NullPointerExceptionExample {
	public static void main(String[] args) {
		int[] intArray = null;
//		intArray[0] = 10;	 //NullPointerException

		// eclipse도 실행을 해봐야 에러가 나온다! 문법적인 에러가 따로 없어서 실행은 되는데 막상 실행해보면 안됨;;
		String str = null;
		System.out.println("총 문자수: " + str.length() );	  //NullPointerException
	}
}

(화요일)

- github 이슈 생성해서 jira랑 연동 실습하기(?)

- README.md 파일에서 md란...? markdown 파일이라는 뜻 (웹 페이지 글올릴 때 쓰임) 

Todo : 이슈 진행 전 상태

In Progress : 담당자가 이슈를 확인하고 진행중인 상태

In Review : 검토를 요청/진행 중인 상태(중간에 검토 단계를 넣는게 요즘 근황)  

Done : 완료 및 종료된 상태

프로젝트 목표 : 정해진 비용과 기간내에서 어떻게 하면 품질을 높이면서 마무리할 수 있을건지...

- R&R : Role & Responsibility (pm이라면 프로젝트 관리를 위한 책임)

- wbs 실습은 내일!!

- 위험과 이슈의 차이 : 위험(potential problem)은 아직 잠재적 문제로 아직 일어나지 않은 것이고 이슈는 일어난 문제로 실제로 일어날 이슈를 방지하기 위해 위험을 방지해야한다!

- 위험과 관련된용어 : 발생 가능성과 발생했을때의 심각도(위험도)를 곱한것이 위험도.. 높은것이 우선순위로 정해지고 이를 대비하기 위해 철저하게 계획을 세워야한다

(수요일)

- wbs 만들기 

베이스 라인 : 특정 시점에서 필요한 파일들을정확히 사용할 수 있게 해주는 작업..

 - 어떤 요구사항 명세서를 반영하는 소스코드인건지를 알기 애매하므로 어떤 산출물을 기준으로 개발한건지를 알기 위해 적어 놓은것이 baseline..

- 어떤 요구사항 명세서와 설계서를 기준으로 개발할건지를 확인하고 개발해야한다!

- 소프트웨어 형상 통제 : 형상통제위원회에서 변경 요청을 수용할 것인지 평가하고 협의하는 과정(CCB한테 통과 받아야 업데이트 가능)

요구사항 명세서(SW Requirement Specification) : 무엇을 개발할건지에 초점을 맞춘다! (어떤 기능을 제공할것인지, 어떤 품질로 / 어떻게는 설계서에 들어갑니다..)

- 시스템(SYSRS)

- 소프트웨어(SWRS)

- 하드웨어(HWRS)

기능 vs 비기능 

- 기능 :  찐 기능

- 비기능 : 품질, 성능, 제약사항

비기능 요구사항 예시

기능 요구사항 어떻게 분석하고 작성하는지... (도출, 분석, 명세, 확인...)

- 좋은 요구사항 명세서라면 요구사항 명세서를 가지고 테스트를 만들어서 다 잘 돌아가는지...(테스트가 가능하다면 요구사항이 굉장히 디테일 하다는것!! / 아니라면 요구사항 명세서 더 자세하게 해달라고 부탁하기!!)

- 추적성 : 우리의 소스코드가 어떤 설계서, 아키텍처 설계서, 요구사항 명세서를 만족시키기 위해 나왔는지 추적이 가능한지... / 우리의 요구사항은 언제든지 변경될 수 있기 때문에 어떤걸 수정해야할지 찾는데 시간이 오래걸림, 누락 가능하다

- 변경 용이성 : 다른것과 최대한 독립성을 띄우는것이 좋다(의존적이면 변경하기 힘듦) 

-  uml 그리기 실습은 내일..

<목요일)

- UML : 시스템 설계를 표현하는데 사용하는 통합된 모델링언어

MBD : MODEL BASED DEVELOPMENT / 모델링만 하면 자동으로 개발해줌... / 개발자는 없어져도... 설계자는 안 없어진다

USECASE DIAGRAM 구성요소

- user actor :  시스템의 외부에 있으면서 시스템과 상호작용하는 것들... 일반적으로 사용자 혹은 외부 시스템

- system actor : 해당 프로젝트의 개발 범위에는 속하지 않지만 데이터를주고받는 등 서로 연동되는 다른 시스템 
                          ex) 우리 시스템에 데이터를 주는 기상청 시스템   

- usecase : 시스템이 액터에게 제공해야 하는 기능의 집합 / 동사+명사 형식으로 작성(성적등록, 성적조회)

- relationship : 액터와 유스케이스 / 유스케이스와 유스케이스 사이의 연관 관계!!! (관계 종류.....)

# USECASE DIAGRAM 그리기

https://app.diagrams.net/

# 설계

- 관점 : HOW(어떻게)

- 특징 : 사용 환경을 반영해 구체적

- 상위 설계서, 상세 설계서 두가지로 나뉨

(금요일)

https://velog.io/@hongjunland/Clean-Architecture

클린 아키텍처 필독서...

# 설계!!!

## 추상화 : 상위 레벨에서 제품의 구현을 생각해봄!!

https://wealthymindset.tistory.com/entry/%EC%82%AC%EC%97%85%EC%B6%94%EC%A7%84-%ED%98%95%ED%83%9C%EC%9D%98-%EB%91%90%EA%B0%80%EC%A7%80-%EB%B0%A9%EB%B2%95-%ED%83%91%EB%8B%A4%EC%9A%B4Top-down%ED%95%98%ED%96%A5%EC%8B%9D-%EB%B0%94%ED%85%80%EC%97%85Bottom-up%EC%83%81%ED%96%A5%EC%8B%9D-%EB%B0%A9%EC%8B%9D

Top-down(하향식)과 Bottom-up(상향식)의 차이..

comfile 과정 : .java 파일을 컴퓨터가 해석할 수 있도록 컴파일러를 거쳐서 .class 파일로 바꿔주는 과정

## 분할과 정복(Divide Conquer)

- Component : 소프트웨어를 구성하는 요소들의 집합 / 클 수도 작을 수도 어떻게 쪼개지는지는 때마다 다르다  

- Unit : 더이상 나눌 수 없는 atomic한 요소

분할과 정복의 의미...

- 하나로 하지 말고 여러 개로 쪼개고 하나하나 작은 단위부터 개발하고 합쳐서 상향식으로 개발해 나가라는 의미

- 모듈화랑 같은 의미(= unit과도 같음)

- 한 화면에 보기 좋은 50-80줄 사이로 함수를 작성하는 것이 좋음

## 모듈화(Modularity)

- 의미 : 소프트웨어 구조를 이루는 기본 단위

- 특징

• 독립적인 기능을 수행하는 단위
• 유일한 이름을 가짐
• 모듈에서 또 다른 모듈을 호출(call)할 수 있음 -> interaction의 한 종류 / interface : interaction을 하는데 손쉽게 하는 수단(화면) / 호출을 하는경우... 데이터를 요청하고 응답 받을  
• 다른 프로그램에서도 모듈을 호출할 수 있음

- 모듈의 크기 : 시스템의 규모, 유형, 특성에 따라 작음 / 작은 시스템이라면 모듈의 크기는 함수 / 큰 시스템이라면...

- 응집도는 강하게(모듈 구성 요소간에는 강하게) / 결합도는 약하게(의존성이 약해야한다)

- 결합도를 느슨하게 하라는 말이... 모든 관계가 안좋다는 말이 아니라 A,B가 서로 호출하여 에러의 무한루프를 돌지 말라는 소리  

- 결합도가 높을수록 복잡해짐 / 낮을수록 단순해지도 유지보수, 재사용성이 좋다

C언어 절차지향형 언어...

- 다른 언어들도 다 순서대로 코드가 실행되는데 왜 절차지향이라고 하는지 ???? 특히나 순서에 집중해서?? 함수를 어디서나 쓰려고 하면 전역변수로 선언해야 한다 / 유지보수 어려움

JAVA 객체지향 언어...

- 사람이 이해한것처럼 코드를 짜보자 해서 나온 언어

- interaction이 이루어지기 때문에 loose coupling, strong cohension을 꼭 하자

# 객체지향방법론의 특징

- 캡슐화 : 정보은닉의 개념이 포함된 개념 / 나의 정보를 감싸서 다른 사람들에게 정보를 숨기는 효과 

- 상속 : 다른클래스의 속성을 물러받아 내 것처럼 쓰는 것 

- 다형성 : 하나 이상의 형태를 갖는 것

• 오버로딩 : 같은 함수 이름이어도 매개변수의 개수나 타입이 다르면 중복 정의하여 사용 가능
• 오버라이딩 : 상속 관계에서 부모의 가져온 메소드를 자식 클래스가 재정의 하여 사용 가능
  • 오버라이딩은 부모 클래스의 메소드를 자식 클래스에서 동일한 이름과 매개변수로 재정의하여, 자식 클래스에서 메소드를 호출할 때 부모 클래스의 메소드가 아닌 자식 클래스의 메소드가 실행되도록 하는 것입니다. 오버라이딩은 메소드에서만 이루어집니다.
  • 쉐도잉은 자식 클래스에서 부모 클래스와 동일한 이름의 변수를 선언하여 부모 클래스의 변수를 덮어쓰는 것입니다. 이 경우 자식 클래스의 인스턴스는 부모 클래스의 변수 대신 자식 클래스의 변수를 참조하게 됩니다. 하지만 부모 클래스의 변수 자체가 변경되는 것은 아닙니다

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; 	// 동물의 나이

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

import java.util.Scanner;

public class bj2753 {
	public static void main (String[] args) {
		Scanner sc = new Scanner(System.in);
			int a;
			a = sc.nextInt();
			
			if (a%4==0 && a%400==0) {
				System.out.println(1);
			}
			else if(a%4==0 && a%100!=0) {
				System.out.println(1);
			}
			else {
				System.out.println(0);
			}
	}
}

import java.util.Scanner;

public class Solution2884 {
	public static void main (String[] args) {
		Scanner sc = new Scanner (System.in);
		int H,M;
		H = sc.nextInt();
		M = sc.nextInt();
		if (H>=0 && H<=23) {
			if (M>=0 && M <=60) {
				if(M>=45) {
					System.out.println(H);
					System.out.println(M-45);
				}
				else if(M<45) {
					System.out.println(23);
					System.out.println(M+15);
				}
				else {
					System.out.println(H-1);
					System.out.println(M+15);
				}
	
			}
		}
	}
}

조금 복잡한거 같긴 한데 예제도 제대로 나오고 그래도 틀린건 없다고 생각했는데 이리저리 바꿔봤는데도 10번 넘게 틀려서 ;;;;;;; 다른 분 블로그를 슬쩍 빌려왔습니다^__________________^

scanner.close();을 왜 하는지는 모르겠지만 나머지는 깔끔하니 이해되네용 ㅎㅎㅎ

--를 사용해서 줄여들이는거랑 " "(큰 따옴표) 사용해서 한번에 출력하는 부분 좋네요~~

다음 백준 문제에 풀때 참고해서 풀어보겠습니다 👌👌

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로 지정ㅎ해서 게임의 순서를 고정한 예제이다

1) 문자열

1-1) 문자열의 선언과 생성

• 문자열은 String 타입을 사용하므로  String 타입의 변수를 먼저 선언해야 한다
• String 타입의 변수는 다음과 같이 큰따음표(" ")로 감싸서 나타낸 문자열 리터럴을 사용하여 초기화할 수 있다

• 문자열 리터럴은 내부적으로 new String()을 호출해 생성한 객체이다
• 따라서 s1은 new String("안녕, 자바!")를 호출해서 생성한 객체를 가리킨다
• 그러나 내용이 같은 문자열 리터럴(프로그램에서 직접 표현한 값)이라면 더 이상 새로운 String 객체를 생성하지 않은 채 기존 리터럴을 공유, 따라서 s1과 s2는 동일한 String객체를 가진다

1-2) 문자열의 비교

• ==나 != 연산자는 두 문자열의 내용을 비교하는 것이 아니라 동일한 객체인지를 검사한다

답은

• s1, s2 변수는 내용이 같은 리터럴이므로 동일한 객체이다
• s3, s4 변수는 내용은 같지만, 생성자로 생성한 객체이기 때문에 다른 객체이다

1-3) 문자열의 다양한 연산

답은

나머지는 위에 표를 보고 그대로 출력하면 되는데 마지막 출력문에서

trim().indexOf()가 연달아 나와서 순서를 바꿔서 하면 값이 달라지므로 중요하다~~ 

항상 출력은 앞에서 부터 하므로 trim부터해서 공백을 없애고 indexOf로 v의 위치를 찾으므로 답은 222222

1-4) String 클래스에서 제공하는 유용한 정적 메서드

답은

2) 배열 기초

2-1) 배열의 개념

• 배열(array) : 타입이 동일한 여러 데이터의 연속된 기억 공간으로, 모든 데이터가 같은 배열 이름을 사용

2-2) 배열의 선언과 생성

• 배열의 크기는 배열이 생성될 때 정해지며, length 필드에 저장한다
• scores는 배열을 참조할 변수에 불과하므로 배열 객체를 생성해야한다
• 배열 객체는 문자열처럼 new 연산자로 생성한다

2-3) 다차원 배열

• 배열의 배열
• ex) 학생 3명의 5과목 성적을 처리하는 정수 타입 2차원 배열(3행 * 5열)인 scorses를 선언하고 생성한다면..

2-4) 동적 배열

• 처리할 데이터의 개수가 고정된 경우가 아니라면 정적 배열은 자원을 낭비하거나 프로그램을 다시 컴파일
• 자바는 크기가 유동적인 배열을 지원하기 위하여 ArrayList 클래스를 제공
• ArrayList 객체 생성