Java 백엔드 학습 노트

package hk.edu20260803.day01; //파일의 폴더 구조(경로), 최상단에 위치

//명명법
//클래스명: 파스칼
public class HelloJava {

    // main 메서드: java코드를 실행시켜줌
    // public: 접근지정자
    // static: 내장 메모리 (static 메모리에 저장된다)
    // void: 반환값 없음
    // main: 메서드명
    // args: 매개변수
    // 메서드명: 카멜방식 (첫글자 소문자, 뒤 글자마다 대문자)
    // 변수명: 카멜방식 (첫글자 소문자, 뒤 글자마다 대문자)
    // 상수명: 스네이크 방식(모두 대문자)

    // 멤버필드: static을 붙이면 static메모리에 저장됨
    // 상수선언: 대문자
    public static final int NUMBER = 10000;
    public int number = 10;

    // 매개변수, 지역변수: main메서드 안의 괄호안에 있는 변수들은 stack메모리에 저장됨
    public static void main(String[] args) { // static으로 메모리에 이미 올라가 있음. 그래서 다른 static이 없는 메서드를
                                             // 여기에 넣어서 실행하려고 하면 안됨
        System.out.println("Hello Java");

        testMethod();
    }

    // 메서드 선언: 카멜
    public static void testMethod() {
        // 변수명: 카멜
        boolean isS = true;
        int i = 100;
        i = 200;
        final int TEST = 10; // final: 상수로 선언됨. 변경 불가능

        System.out.println("메서드 실행결과: " + i);

    }
}

package hk.edu20260803.day01;

public class VariableTest {
    public static void main(String[] args) {
        // 기본 타입의 특징
        // 1.정타입
        // : 기본형은 int
        byte b = 1;
        b = 127; // byte 표현범위는 -128 ~ 127
        b = -128;

        short sh = 128; // 2byte 크기
        int i = 100000; // 4byte 크기
        long l = 1000000000000000000L; // 리터럴 정수는 기본 int 형으로 인식함 , 8byte 크기 (long타입 정수는 L을 붙여줘야함)
        System.out.println("long타입 표현범위: " + l);

        byte bb = (byte) i; // byte -> int 다운캐스팅 , 원본값 손실됨
        int ii = 126;
        byte bbb = (byte) ii; // int -> byte 다운캐스팅, 원본값이 손실되지 않음
        System.out.println("바이트 타입 표현범위: " + bbb);
        System.out.println("======================");

        // 2.실수타입
        // 기본형은 double(8byte)
        double d = 15.7;
        float f = 15.77f; // 8byte크기라 f 붙여줌 , 기본적으로 double로 인식해서 컴파일러가 "double 값을 float 변수에 담으면 데이터가 손실될 수
                          // 있다!"라고 경고 띄움
        float ff = (float) (d + f); // 큰값을 작은 상자에 담는다 (down casting)

        // 3. 다른 타입끼리 연산
        int iii = (int) (i + d); // int+double -> double, 연산결과가 double이므로 강제형변환 필요

        // 4.정수끼리 연산
        byte b1 = 10;
        byte b2 = 20;
        // byte b3 = b1 + b2; // byte + byte 인데, 왜 오류가 나는가? = int타입으로 자동 캐스팅 하기 때문(컴퓨터가
        // 더 큰 숫자를 담기위함)
        // => 그래서 연산을 하기전 b1,b2 를 int 타입으로 변경해준 후 더해야한다.
        byte b3 = (byte) (b1 + b2); // 연산의 결과값은 int로 반환되므로, 그 값을 byte 타입의 b3에 담기 위해서는 강제형변환이 필요
        // 변수끼리 연산은 변하는 값이기 때문에 127을 벗어날 수 있다.
        byte b4 = 10 + 20; // 리터럴 정수는 기본 int 타입으로 인식하기 때문에 오류가 나지 않는다.
        System.out.println("바이트 타입 연산 결과: " + b4);

        // 5.
    }
}

package hk.edu20260804.day02;

import java.util.Scanner;

//파일명이 클래스명과 동일해야 함
public class D1_isLeapYear {

    // 윤년: 1년은 365일 --> 366일인 해, 2월달의 마지막날이 29일
    // 윤년을 판단하는 조건을 확인
    // -년도가 4의 배수이면서, 100으로 나누어떨어지지 않는 수
    // -또는 400으로 나누어 떨어지는 수
    // 2026년도가 윤년인지 아닌지 확인해서 출력해보기

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("년도를 입력해주세요 : ");
        int year = sc.nextInt();
        if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
            System.out.println(year + "는 윤년입니다");
        } else {
            System.out.println(year + "는 평년입니다");
        }

        for (int i = 2000; i < 2031; i++) {
            if ((i % 4 == 0 && i % 100 != 0) || i % 400 == 0) {
                System.out.println(i + "는 윤년입니다");
            }
        }
    }

    public static boolean isLeapYear(int year) {
        if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
            return true;
        } else {
            return false;
        }
    }
}

package hk.edu20260804.day02;

import java.util.Random;
import java.util.Scanner;

public class D2_ControlEx {
    public static void main(String[] args) {

        // System.out.print("========2단==========\n");
        // // 구구단
        // // 2단
        // for (int i = 1; i <= 9; i++) {
        // System.out.printf("\"2X%d=%d\"", i, 2 * i);
        // System.out.println();
        // }

        // System.out.print("=========2~9단==========\n");

        // // 2~9단
        // for (int i = 2; i <= 9; i++) {
        // for (int j = 1; j <= 9; j++) {
        // System.out.printf("%dx%d=%d", i, j, i * j);
        // System.out.print("\t");
        // }
        // System.out.println();
        // }

        // System.out.print("=========짝수단만==========\n");

        // // 2~9단 출력하는데 짝수단만 출력
        // for (int i = 2; i <= 9; i += 2) {
        // for (int j = 1; j <= 9; j++) {
        // System.out.printf("%dx%d=%d", i, j, i * j);
        // System.out.print("\t");
        // }
        // System.out.println();
        // }

        // System.out.print("=========홀수단만==========\n");

        // // 2~9단 출력하는데 홀수단만 출력
        // for (int i = 3; i <= 9; i += 2) {
        // for (int j = 1; j <= 9; j++) {
        // System.out.printf("%dx%d=%d", i, j, i * j);
        // System.out.print("\t");
        // }
        // System.out.println();
        // }

        // System.out.print("=========100까지 합==========\n");

        // // 1~100까지의 합 출력
        // int sum = 0;
        // for (int i = 1; i <= 100; i++) {
        // sum += i;
        // }
        // System.out.println(sum);

        // System.out.print("=========4의 배수의 총합==========\n");

        // // 1~100까지의 수 중에 4의 배수의 총합 출력
        // int sum2 = 0;
        // for (int i = 1; i <= 100; i++) {
        // if (i % 4 == 0) {
        // sum2 += i;
        // }
        // }
        // System.out.println(sum2);

        // System.out.print("=========두 주사위==========\n");
        // // 주사위 두개의 합이 5이면 실행을 멈추고
        // // 5가 아니면 계속 실행되게 코드를 작성하자
        // // 1~6까지의 숫자로 구성, 랜덤하게 숫자 생성하는 기능
        // // Math객체사용

        // boolean stop = true;
        // while (stop) {
        // int first = (int) (Math.random() * 6) + 1;
        // int second = (int) (Math.random() * 6) + 1;
        // System.out.printf("%d + %d = %d\n", first, second, first + second);
        // if (first + second == 5) {
        // stop = false;
        // System.out.println("주사위의 합 5");
        // break;
        // }
        // }

        // Random random = new Random();
        // boolean stop2 = true;
        // while (stop2) {
        // int first2 = random.nextInt(6) + 1;
        // int second2 = random.nextInt(6) + 1;
        // System.out.printf("%d + %d = %d\n", first2, second2, first2 + second2);
        // if (first2 + second2 == 5) {
        // stop2 = false;
        // System.out.println("주사위의 합 5");
        // break;
        // }

        // }

        // // Scanner 클래스: 키보드로 입력받는 기능에 활용해 볼 수 있는 객체
        // Scanner scan = new Scanner(System.in);

        // int num = 0;
        // System.out.print("숫자를 입력하세요 : ");
        // num = Integer.parseInt(scan.nextLine());
        // System.out.println("입력결과값:" + num);
        // System.out.println("또입력받기:");
        // int num2 = Integer.parseInt(scan.nextLine());
        // System.out.println("입력결과값:" + num2);

        // scan.close();

        Scanner sc = new Scanner(System.in);
        boolean start = true;
        int savemoney = 0;

        while (start) {
            System.out.println("옵션을 선택하세요");
            System.out.println("---------------------");
            System.out.println("1.예금 2.출금 3.잔고 4.종료");
            System.out.print("선택 >> ");
            int select = Integer.parseInt(sc.nextLine());
            switch (select) {
                case 1:
                    System.out.println("예금액 : ");
                    int saveTemp = Integer.parseInt(sc.nextLine());
                    savemoney += saveTemp;
                    break;
                case 2:
                    System.out.println("출금액 : ");
                    int outTemp = Integer.parseInt(sc.nextLine());
                    if (outTemp > savemoney) {
                        System.out.println("잔고가 부족합니다");
                    } else {
                        savemoney -= outTemp;
                    }
                    break;
                case 3:
                    System.out.println("잔고 : " + savemoney);
                    break;
                case 4:
                    System.out.println("종료합니다");
                    start = false;
                    break;
                default:
                    System.out.println("잘못된 입력입니다");
                    break;
            }

        }

    }
}

package hk.practice;

public class prac01 {
    public static void main(String[] args) {
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println();

        for (int i = 1; i < 6; i++) {
            for (int j = 6; j > i; j--) {
                System.out.print("*");
            }
            System.out.println();
        }

        int line = 5;
        for (int i = 0; i < line; i++) {
            for (int j = 0; j < line - 1 - i; j++) {
                System.out.print(" ");
            }
            for (int k = 0; k < 2 * i + 1; k++) {
                System.out.print("*");
            }
            System.out.println();
        }

        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 6 - i; j++) {
                System.out.print(" ");
            }
            for (int k = 0; k < i; k++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println();

        for (int k = 0; k < 6; k++) {
            for (int i = 0; i < k; i++) {
                System.out.print(" ");
            }
            for (int i = 6; i > k; i--) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println();

        int a = 5;
        for (int i = a; i > 0; i--) {
            for (int k = 0; k < a - i; k++) {
                System.out.print(" ");
            }
            for (int j = 0; j < 2 * i - 1; j++) {
                System.out.print("*");
            }

            System.out.println();
        }

        System.out.println();

        int c = 5; // 위쪽 피라미드 높이

        // 1. 위쪽 정피라미드 (i = 0 ~ 4)
        for (int i = 0; i < c; i++) {
            for (int k = 0; k < c - 1 - i; k++) {
                System.out.print(" ");
            }
            for (int j = 0; j < 2 * i + 1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        // 2. 아래쪽 역피라미드 (i = 3 ~ 0) i = a - 2 부터 시작해서 가운데 줄 중복 방지!
        for (int i = c - 2; i >= 0; i--) {
            for (int k = 0; k < c - 1 - i; k++) {
                System.out.print(" ");
            }
            for (int j = 0; j < 2 * i + 1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

    }
}

package hk.edu20260805.day03;

public class D1_StarView {
    public static void main(String[] args) {
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println();

        for (int i = 1; i <= 6; i++) {
            for (int j = 6; j > i; j--) {
                System.out.print("*");
            }
            System.out.println(" ");
        }

        System.out.println();

        int line = 5;
        for (int i = 0; i < line; i++) {
            for (int j = 0; j < line - 1 - i; j++) {
                System.out.print(" ");
            }
            for (int k = 0; k < i * 2 + 1; k++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println();

        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 6 - i - 1; j++) {
                System.out.print(" ");
            }
            for (int k = 0; k < i; k++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println();

        for (int i = 0; i < 6; i++) {
            for (int k = 0; k < i; k++) {
                System.out.print(" ");
            }
            for (int j = 0; j < 6 - i - 1; j++) {
                System.out.print("*");
            }

            System.out.println();
        }

        // 10 8 6 4 2 -> 10 + (n-1)* -2

        int a = 5;
        for (int i = a; i > 0; i--) {
            for (int k = 0; k < 5 - i; k++) {
                System.out.print(" ");
            }
            for (int j = 0; j < i * 2 - 1; j++) {
                System.out.print("*");
            }

            System.out.println();
        }

        System.out.println();

        int c = 5;
        for (int i = 0; i < c; i++) {
            for (int j = c; j > i + 1; j--) {
                System.out.print(" ");
            }
            for (int k = 0; k < 2 * i + 1; k++) {
                System.out.print("*");
            }
            System.out.println();
        }
        for (int i = 4; i > 0; i--) {
            for (int j = 0; j < 5 - i; j++) {
                System.out.print(" ");
            }
            for (int k = 0; k < i * 2 - 1; k++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println();

        // 등차수열공식으로 하면 ++로 다 할 수 있음
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5 - (i + 1); j++) {
                System.out.print(" ");
            }
            for (int k = 0; k < (i + 1) * 2 - 1; k++) {
                System.out.print("*");
            }
            System.out.println();
        }

    }

}

package hk.edu20260805.day03;

public class D2_MethodTest {
    // main 메서드는 프로그램을 실행시키는 진입점(시작점)
    // 구현된 메서드를 실행시켜주는 메서드
    public static void main(String[] args) {
        // static 메서드 사용: 클래스명.메서드() 호출해서 사용
        D2_MethodTest.test01();

        // non-static 메서드 사용: 객체생성후 메서드 호출
        D2_MethodTest methodTest = new D2_MethodTest();
        methodTest.test02();
    }

    // 메서드의 유형
    // 1.static과 non-static 유형
    public static void test01() {
        System.out.println("static 메서드");
        // test01() 은 이미 메모리에 올라가 있음
        // test02() 는 메모리에 올라가 있지 않음
        // non-static을 사용못함->객체생성이나, static으로 만들면 사용가능
        D2_MethodTest methodTest = new D2_MethodTest();
        methodTest.test02();
    }

    // non-static 메서드 -> 객체생성해야지만 사용 가능
    public void test02() {
        System.out.println("non-static 메서드");
    }

    // 2. 매개변수와 반환유무에 따른 유형
    // 매개변수 없음, 반환값 없음
    public int test03() {
        return 0;// 반환타입을 설정했다면 반드시 해당 타입을 반환
    }

    // 반환타입X는 코드만 실행하고 끝내는 경우
    public void test04() {

    }

    // 3. 파라미터 O/X : 외부로부터 값을 받아서 뭔가 실행하려고
    public int test05(int a, int b) {
        int res = 0;
        if (a > b) {
            res = a;
        } else {
            res = b;
        }
        return res;
    }

}

package hk.edu20260806.day04;

public class D2_ClassTest {
    // 멤버필드: 클래스에서 데이터를 저장해서 사용하는 저장공간 개념
    // -> 객체가 사라지지 않는 한 항상 유지 됨
    public int number; // 인스턴스 멤버필드 (변수)
    public static int staticNumber; // 클래스 변수

    // 기본 생성자(deafult생성자) 파라미터 없음, 생략 가능,
    // //멤버필드 초기화나 초기 실행할 작업
    // 아래와 같이 파라미터가 있는 생성자를 추가하면 default생성자 생략 못함
    public D2_ClassTest() {
        // 자기 자신의 생성자 호출
        // 객체 생성할때 default 생성자를 호출하면 10으로 초기화함
        // this.number10;
        this(10);
    }

    // 생성자 오버로딩: 파라미터의 개수와 타입을 다르게 해서 생성자나 메서드 이름을 같게 사용
    public D2_ClassTest(int number) {
        // super:부모, this:자기자신 클래스
        this.number = number; // this->이 객체 자신을 의미. 멤버필드 number를 지칭
    }

    // 메서드: 인스턴스 메서드
    public void methodTest() {
        System.out.println("인스턴스에 관련된 기능을 정의한다");
    }

    // 메서드: 클래스 메서드
    public static void stmethodTest() {
        System.out.println("메서드영역 메모리에 생성되어 공통기능을 정의한다.");
    }
}

package hk.edu20260806.day04;

public class D2_ClassTestMain {
    public static void main(String[] args) {
        // 참조타입 객체명 생성자
        D2_ClassTest classTest = new D2_ClassTest(); // Heap 메모리에 생성
        classTest.methodTest(); // 객체명.메서드로 호출 -> 인스턴스 메서드
        classTest.number = 20; // 객체명.멤버필드로 호출 -> 인스턴스 변수

        D2_ClassTest.stmethodTest();// 클래스명.메서드로 호출 -> 정적 메서드

        // 객체 생성을 또 할 수 있다.
        D2_ClassTest classTest2 = new D2_ClassTest(30);
        classTest2.number = 40;

        // 인스턴스변수는 각각의 해당 객체에서 관리됨
        System.out.println("classTest.number:" + classTest.number);
        System.out.println("classTest2.number:" + classTest2.number);

        // static 변수는 클래스 전체에서 공유됨
        D2_ClassTest.staticNumber = 50;
        System.out.println("classTest.staticNumber:" + classTest.staticNumber);
        System.out.println("classTest2.staticNumber:" + classTest2.staticNumber);
    }

}

package hk.edu20260806.day04;

public class D4_Constructor {

    // 티비객체
    // private은 클래스 내부에서만 접근 가능
    private int size = 0; // 중요한 데이터 -->private 선언
    public String color = "검정석"; // 색상

    // default 생성자: 단독으로 사용한다면 생략 가능 -> 오버로딩을 하면 생략 못함
    public D4_Constructor() {
        // this.size = 24;
        // this.color = "검정색";
        // System.out.println(); //생성자는 가장 처음에 실행되어야 하므로 첫줄에 작성
        this(24, "검정색"); // 생성자 호출은 반드시 첫줄에 작성
    }

    // 생성자 오버로딩
    public D4_Constructor(int size) {
        // 멤버필드size = 파라미터 size
        this.size = size;
    }

    public D4_Constructor(int size, String color) {
        // 멤버필드size = 파라미터 size
        this.size = size;
        this.color = color;
    }

    // private으로 선언한 맴버필드는 어떻게 접근할까?->getter, setter메서드를 사용한다

    public int getSize(int pw) {
        // 조건에 따라 값을 반환한다. ex: 비밀번호를 알고 있다면 반환
        if (pw == 1234) {
            return size;
        } else {
            System.out.println("잘못된 비밀번호");
            return -1;
        }
    }

    public void setSize(int size) {
        this.size = size;
    }

}

package hk.edu20260806.day04;

public class D1_ConstructioMain {
    public static void main(String[] args) {

        D4_Constructor tv = new D4_Constructor();
        D4_Constructor tv2 = new D4_Constructor(70);
        D4_Constructor tv3 = new D4_Constructor(60, "노랑색");
        // 생성자 이용 안하고, 직접 멤버필드에 접근해서 초기화 할경우 불편하다
        D4_Constructor tv4 = new D4_Constructor();
        tv4.color = "파란색";
        tv4.setSize(24); // private이라 메서드 통해 값 추가
    }
}

package hk.edu20260806.day04;

public class D3_ObjectTest {
    public static void main(String[] args) {
        // Object 클래스: 최상위 객체
        // getClass(): 클래스의 위치를 반환한다. -> 패키지.클래스명
        String str = new String("Object");
        String str2 = "ObjectLit"; // 주로 사용되는 방식
        System.out.println(str.getClass());
        System.out.println(str2.getClass());

        D3_ObjectTest ot = new D3_ObjectTest();
        System.out.println(ot.getClass());

        // toString(): 문자열로 반환한다
        // target 객체에 "위치@hashcode(16진수)" 반환
        System.out.println(ot.toString());
        System.out.println(str.toString());

        // hashcode(): 객체의 hashcode를 반환한다. -> 10진수로 표현
        System.out.println(ot.hashCode());

        // 객체를 비교할떄 hashcode로 비교한다. --> 일반적인 객체 비교할때는 의미가 없음
        // --> equals()가 hashcode()를 이용해서 객체를 비교한다.
        System.out.println(ot.equals(str2));

        // 리터럴 방식 선언(String)
        String s = "a";
        String s2 = "a";
        System.out.println(s == s2); // 비교연산자: 객체에 주소로 비교
        System.out.println(s.equals(s2)); // hashcode로 비교

        // 객체 생성으로 선언(new String())
        String s3 = new String("a");
        System.out.println(s == s3); // false //메모리 주소가 달라서
        System.out.println(s.equals(s3)); // true --> 내용물이 같은지 봐서

    }
}

package hk.edu20260806.day04;

public class D1_divisor {

    public D1_divisor() {
        // 기본적으로 생성자 호출은 맨 윗줄에 작성
        super(); // 부모생성자를 호출 ->Object 클래스가 부모임. 매개변수가 없으면 기본적으로 Object()호출
        // this(); // 같이 작성할 수 없다
    }

    public static void main(String[] args) {
        D1_divisor d = new D1_divisor();
        d.divisor(12);
        System.out.println("최대공약수1:" + getGcd1(12, 18));
        System.out.println("최대공약수2:" + getGcd2(12, 18));
        lowestMultiple(12, 18);

        // amicable은 non-static메서드이기떄문에 객체생성해서 객체명.메서드로 호출한다.
        d.amicable(1, 1000);
        d.perfectnum(1, 1000);
    }

    // 약수를 구하는 메서드
    public void divisor(int a) {
        for (int i = 1; i < a + 1; i++) {
            if (a % i == 0) {
                System.out.print((i == a) ? i : i + ",");
            }
        }
        System.out.println();
    }

    // 최대공약수 구하는 메서드 유클리드 호제법
    public static int getGcd(int a, int b) {
        while (b != 0) {
            int r = a % b;
            a = b;
            b = r;
        }
        return a;
    }

    // 뺄셈 방식 유클리드 호제법
    public static int getGcd1(int a, int b) {
        while (a != b) {
            if (a > b) {
                a = a - b;
            } else {
                b = b - a;
            }
        }
        return a;
    }

    // 유클리드 호제법 재귀호출
    public static int getGcd2(int a, int b) {
        if (b == 0) {
            return a;
        }
        return getGcd2(b, a % b);
    }

    // 최소공배수
    public static void lowestMultiple(int a, int b) {
        int gcd = getGcd1(a, b);
        int lowestMultiple = (a * b) / gcd;
        System.out.println("최소공배수:" + lowestMultiple);
    }

    // 진약수 합
    public static int sumDivisor(int a) {
        int sum = 0;
        for (int i = 1; i < a; i++) {
            if (a % i == 0) {
                sum += i;
            }
        }
        return sum;
    }

    // 친화수
    public void amicable(int s, int e) {
        for (int i = s; i <= e; i++) {
            if (i != sumDivisor(i) && i == sumDivisor(sumDivisor(i))) {
                System.out.printf("%d와 %d는 친화수 관계입니다.\n", i, sumDivisor(i));
            }
        }
    }

    // 완전수
    public void perfectnum(int s, int e) {
        for (int i = s; i <= e; i++) {
            if (i == sumDivisor(i)) {
                System.out.println(i + "는 완전수입니다.");
            }
        }
    }
}

// 패키지 선언은 항상 파일의 맨 첫 줄에 온다 (폴더 구조와 1:1로 대응)
package com.a.b;

public class Hello {
    // main 메서드: JVM이 프로그램을 시작할 때 가장 먼저 찾아 실행하는 진입점
    public static void main(String[] args) {
        String str = "Hello!! JAVA";
        System.out.println(str);
    }
}

/* --- 콘솔에서 직접 컴파일·실행하기 ---
   javac -d . Hello.java   // -d . : 현재 폴더에 package 경로대로 폴더를 만들며 컴파일
                           //        → com/a/b/Hello.class 생성
   java com.a.b.Hello      // 실행할 때는 "패키지명.클래스명" 전체 이름을 쓴다
                           //        (Hello.class 라고 쓰면 안 된다)
*/

package hk.edu20260803.day01;

// 클래스명: 파스칼 방식 (첫 글자 대문자, 의미 단위마다 대문자)
public class HelloJava {

    // 상수 선언: static final + 전부 대문자 (스네이크 방식)
    public static final int NUMBER = 10000;
    // 인스턴스 멤버필드: 카멜 방식
    public int number = 10;

    // 메서드명도 카멜 방식
    public static void main(String[] args) {
        System.out.println("Hello Java");
        testMethod();
    }

    public static void testMethod() {
        boolean isS = true;      // 변수명: 카멜
        int i = 100;
        i = 200;                 // 일반 변수는 값을 다시 넣을 수 있다
        final int TEST = 10;     // final: 상수가 되어 변경 불가

        System.out.println("메서드 실행결과: " + i);
    }
}

public class IsPrimeTest {
    public boolean isPrimeTest(int num) {
        boolean isP = true;          // ← isP 변수 시작 (메서드 블록 전체에서 유효)

        for (int j = 2; j < num; j++) {   // ← j 변수 시작 (for 블록 안에서만 유효)
            if (num % j == 0) {      // 나누어 떨어지면 소수가 아니다
                isP = false;
                break;               // 더 볼 필요 없으니 반복 탈출
            }
        }                            // ← 여기서 j는 스택에서 사라진다

        return isP;                  // isP는 아직 살아 있으므로 반환 가능
    }                                // ← 여기서 isP도 사라진다
}

public class PrimitiveType {
    // 멤버필드는 자동 초기화된다
    static int    i;        // 0
    static double d;        // 0.0
    static boolean b;       // false
    static String s;        // null (참조형)

    public static void main(String[] args) {
        byte   by = 100;          // -128 ~ 127
        short  sh = 30000;        // 약 ±3만
        int    in = 2100000000;   // 약 ±21억 — 가장 많이 쓰는 정수 타입
        long   lo = 10000000000L; // int 범위를 넘으면 반드시 L을 붙인다

        float  fl = 3.14F;        // 실수 리터럴의 기본은 double이라 F 필수
        double db = 3.141592;     // 실수는 특별한 이유가 없으면 double

        char   ch = 'A';          // 작은따옴표 1글자 (2byte 유니코드)
        boolean isOk = true;      // true / false 만 가능 (자바는 0/1을 못 쓴다)

        System.out.println(by + " " + sh + " " + in + " " + lo);
        System.out.println(fl + " " + db + " " + ch + " " + isOk);
        System.out.println(i + " " + d + " " + b + " " + s);  // 0 0.0 false null
    }
}

public class RadixTest {
    public static void main(String[] args) {
        int n = 17;

        // 10진수 → 다른 진법 문자열 (Integer 클래스의 유틸 메서드)
        System.out.println(Integer.toBinaryString(n)); // "10001"  (2진수)
        System.out.println(Integer.toOctalString(n));  // "21"     (8진수)
        System.out.println(Integer.toHexString(n));    // "11"     (16진수)

        // 반대로 문자열(진법) → 10진수
        System.out.println(Integer.parseInt("10001", 2)); // 17
        System.out.println(Integer.parseInt("ff", 16));   // 255

        // byte의 한계 확인 — 127에 1을 더하면 -128로 되돌아간다(오버플로)
        byte max = 127;
        max++;
        System.out.println(max);  // -128
    }
}

public class CastingTest {
    public static void main(String[] args) {
        // ---- 업캐스팅(자동) / 다운캐스팅(명시) ----
        byte a = 10;
        int  c = a;              // 업캐스팅: byte → int, 자동
        int  d = 300;
        byte e = (byte)d;        // 다운캐스팅: 범위를 넘어 44가 된다(비트가 잘림)
        System.out.println(c + " " + e);

        // ---- 연산 시 자동 승격 ----
        byte b1 = 5, b2 = 10;
        // byte sum = b1 + b2;   // 에러! byte + byte 의 결과는 int
        byte sumOk = 5 + 10;     // OK: 상수끼리는 컴파일 시점에 15로 확정
        int  sum   = b1 + b2;    // 결과를 int로 받으면 문제 없다
        System.out.println(sumOk + " " + sum);

        // ---- char ↔ int ----
        System.out.println((char)65);        // A
        System.out.println((int)'A');        // 65
        System.out.println((char)('A' + 2)); // C
        System.out.println('9' - '0');       // 9  (문자 숫자 → 진짜 숫자)

        // ---- String ↔ 숫자 ----
        int    n  = Integer.parseInt("9");        // "9" → 9
        double dd = Double.parseDouble("34.5");   // "34.5" → 34.5
        String s1 = String.valueOf(9);            // 9 → "9"
        String s2 = 9 + "";                       // 같은 결과, 더 짧은 방법
        System.out.println(n + " " + dd + " " + s1 + s2);

        // ---- Boxing / UnBoxing (Java 5 이상 자동) ----
        Integer box = 4;      // Boxing   : int → Integer
        int     un  = box;    // UnBoxing : Integer → int
        Object  o   = un;     // 기본타입도 Object에 담을 수 있다(오토박싱)
        int     back = (Integer)o;   // 꺼낼 땐 캐스팅 필요
        System.out.println(box + " " + un + " " + back);
    }
}

public class OperatorTest {
    public static void main(String[] args) {
        // ---- 단축연산자 ----
        int sum = 10;
        sum += 1;                 // sum = sum + 1  → 11
        System.out.println(sum);

        // ---- 증감연산자 ----
        int x = 10;
        System.out.println(x++);  // 10 출력 후 11이 됨 (후위: 쓰고 나서 증가)
        System.out.println(x);    // 11
        System.out.println(++x);  // 12 (전위: 증가하고 나서 씀)
        System.out.println(x);    // 12

        // ---- 논리연산자 ----
        int i = 1, j = 2, k = 3;
        System.out.println(i < j && j < k);        // true  (둘 다 참)
        System.out.println(i < j || j < k);        // true  (하나만 참이어도)
        System.out.println(!(i < j) || !(j < k));  // false

        // ---- short circuit: 앞이 false면 뒤(divide)는 아예 실행되지 않는다 ----
        int zero = 0;
        if (zero != 0 && 100 / zero > 1) {   // 앞이 false → 나눗셈을 하지 않아 에러가 안 난다
            System.out.println("실행되지 않음");
        }

        // ---- 삼항연산자 ----
        int y = -5;
        int result = (y < 0) ? 10 : 20;      // y가 음수이므로 10
        System.out.println(result);
    }
}

public class SwitchCase {
    public static void main(String[] args) {
        int i = 95;

        // i / 10 을 한 번만 계산해서 그 값으로 분기한다 (95/10 = 9)
        switch (i / 10) {
            case 10: System.out.println(i + "점은 A입니다."); break;
            case 9:  System.out.println(i + "점은 A입니다."); break;  // ← 여기 실행
            case 8:  System.out.println(i + "점은 B입니다."); break;
            case 7:  System.out.println(i + "점은 C입니다."); break;
            case 6:  System.out.println(i + "점은 D입니다."); break;
            default: System.out.println(i + "점은 F입니다."); break;
        }

        // fall through 를 일부러 이용해 여러 case 를 하나로 묶기
        int month = 3;
        switch (month) {
            case 3: case 4: case 5:
                System.out.println("봄");  break;   // 3,4,5 모두 여기로
            case 6: case 7: case 8:
                System.out.println("여름"); break;
            default:
                System.out.println("그 외");
        }

        // 같은 로직을 if 로 쓰면 조건식을 매번 계산한다
        if (i >= 90)      System.out.println("A");
        else if (i >= 80) System.out.println("B");
        else              System.out.println("C 이하");
    }
}

public class LoopTest {
    public static void main(String[] args) {
        // ---- continue: 짝수는 건너뛰고 홀수만 출력 ----
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) continue;   // 짝수면 아래를 건너뛰고 i++ 로 점프
            System.out.println("[" + i + "]");
        }

        // ---- while: 조건을 먼저 검사 ----
        int r = 1;
        while (r <= 3) {
            System.out.println("반지름 " + r + " 원의 넓이: " + (Math.PI * r * r));
            r++;                        // 증감을 깜빡하면 무한 루프!
        }

        // ---- do~while: 조건이 처음부터 false여도 한 번은 실행 ----
        int i = 15;
        do {
            i++;
            System.out.println("i 값? " + i);   // 16 한 번만 출력됨
        } while (i > 20);

        // ---- 라벨 break: 중첩 반복을 한 번에 탈출 ----
        outer:
        for (int a = 0; a < 3; a++) {
            for (int b = 0; b < 3; b++) {
                if (a * b > 2) break outer;     // 안쪽에서 바깥 for까지 통째로 탈출
                System.out.println(a + "," + b);
            }
        }

        // ---- 등차수열(+3) / 등비수열(×2) ----
        int ap = 1, gp = 1;
        for (int n = 0; n < 5; n++) {
            System.out.print(ap + " ");  ap += 3;   // 1 4 7 10 13
        }
        System.out.println();
        for (int n = 0; n < 5; n++) {
            System.out.print(gp + " ");  gp *= 2;   // 1 2 4 8 16
        }
    }
}

public class PrintTest {
    public static void main(String[] args) {
        // print: 줄바꿈 없음 → 한 줄에 이어진다
        System.out.print("Hello ");
        System.out.print("Java");
        System.out.println();          // 줄바꿈만 하고 싶을 때

        // println: 출력 후 자동 줄바꿈
        System.out.println("한 줄 출력");

        // printf: 서식 문자로 값 끼워 넣기
        System.out.printf("나이:%d 이름:%s%n", 30, "한경");
        System.out.printf("원주율: %.2f%n", Math.PI);   // 소수점 2자리 → 3.14

        // + 연산의 순서 함정
        int a = 1, b = 2;
        System.out.println(a + b + "점");     // "3점"  (숫자 계산이 먼저)
        System.out.println("점수: " + a + b); // "점수: 12" (문자열이 앞이라 연결)
        System.out.println("점수: " + (a + b)); // "점수: 3" (괄호로 계산 먼저)

        // escape 문자
        System.out.println("이름\t나이");      // 탭으로 열 맞추기
        System.out.println("경로: C:\\java\\bin");  // \ 하나를 출력하려면 \\
        System.out.println("그는 \"자바\"라고 말했다.");
    }
}

import java.util.Scanner;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class InputTest {
    public static void main(String[] args) throws IOException {
        // ---- 방법 1: Scanner (가장 간단, 타입별 메서드 제공) ----
        Scanner sc = new Scanner(System.in);

        System.out.print("나이를 입력하세요: ");
        int age = sc.nextInt();      // 숫자만 읽고 엔터는 버퍼에 남는다

        sc.nextLine();               // ★ 남은 엔터를 비워 준다 (안 하면 아래가 건너뛰어짐)

        System.out.print("이름을 입력하세요: ");
        String name = sc.nextLine(); // 한 줄 전체(공백 포함)

        System.out.printf("%s님은 %d살입니다.%n", name, age);
        sc.close();

        // ---- 방법 2: InputStreamReader + BufferedReader (빠르지만 형 변환 필요) ----
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.print("숫자 하나: ");
        int n = Integer.parseInt(br.readLine());   // 항상 String으로 오므로 직접 변환
        System.out.println("입력한 수의 제곱: " + (n * n));
    }
}

public class TermMain {                 // ← 클래스 (설계도, Pascal 명명법)

    Byte b = Byte.MAX_VALUE;            // ┐
    private String str;                 // ├ 인스턴스 변수 (객체마다 따로 생김)
    static int number;                  // ┘ ← static이 붙으면 클래스 변수(모두가 공유)
                                        //    이 셋을 통틀어 "멤버필드"라고 부른다

    public TermMain() { }               // ← 생성자 (클래스명과 같고 리턴 타입이 없다)

    public void method(int param) {     // ← param : 매개변수(parameter)
        for (int i = 0; i < 5; i++) {   // ← i : 지역변수 (이 블록 안에서만 존재)
        }
    }

    public static void main(String[] args) {
        TermMain t = new TermMain();    // 인스턴스화: heap에 객체 생성 → 주소를 t에 저장
        t.method(10);                   // 10 : argument(실인수) → param 으로 전달됨
        System.out.println(TermMain.number);  // static은 객체 없이 클래스명으로 접근
    }
}

class UserDefineClass {
    String name;
    UserDefineClass(String name) { this.name = name; }

    // 오버라이드하지 않으면 "클래스명@해시코드"가 찍힌다
    @Override
    public String toString() { return "UserDefineClass(" + name + ")"; }

    // 값으로 비교하고 싶다면 equals와 hashCode를 "같이" 재정의한다
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;                    // 주소가 같으면 당연히 같다
        if (!(obj instanceof UserDefineClass)) return false;
        return this.name.equals(((UserDefineClass) obj).name);
    }
    @Override
    public int hashCode() { return name.hashCode(); }    // 값 기준 해시코드
}

public class ObjectMethod {
    public static void main(String[] args) {
        String s = new String("java");
        System.out.println(s.getClass());          // class java.lang.String

        UserDefineClass d1 = new UserDefineClass("A");
        UserDefineClass d2 = new UserDefineClass("A");

        System.out.println(d1);                    // toString() 자동 호출
        System.out.println(d1 == d2);              // false — 주소가 다르다
        System.out.println(d1.equals(d2));         // true  — 오버라이드했으므로 값 비교
        System.out.println(d1.hashCode() == d2.hashCode());  // true
    }
}

public class MethodTest {

    // 리턴 타입이 int → 반드시 int 값을 return 해야 한다
    public static int sum(int a, int b) {   // a, b : parameter(매개변수)
        int result = a + b;                 // ② 반환 타입과 같은 변수 선언
        return result;                      // ③ 그 변수를 반환
    }

    // 리턴 타입이 void → return 값이 없다 (return; 으로 중간 종료는 가능)
    public static void printLine(String msg) {
        if (msg == null) return;            // 값 없이 메서드만 빠져나가기
        System.out.println("== " + msg + " ==");
    }

    // 배열(참조타입)도 리턴할 수 있다
    public static int[] makeArray(int size) {
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) arr[i] = i * i;
        return arr;
    }

    public static void main(String[] args) {
        int m = sum(10, 20);        // 10, 20 : argument(인수) → ④ 같은 타입에 담는다
        printLine("결과");
        System.out.println(m);      // 30

        int[] squares = makeArray(5);
        for (int s : squares) System.out.print(s + " ");   // 0 1 4 9 16
    }
}

public class ClassDiagram {
    public    int publicVal;      // + : 어디서나
    protected int protectedVal;   // # : 같은 패키지 + 상속받은 자식
              int defaultVal;     //     같은 패키지만 (아무것도 안 씀)
    private   int privateVal;     // - : 이 클래스 안에서만

    public    void publicMethod()    { }
    protected void protectedMethod() { }
              void defaultMethod()   { }
    private   void privateMethod()   { }
}

// 실전 패턴: 필드는 private, 접근은 메서드로 (getter/setter)
class Student {
    private int age;                          // 외부에서 직접 못 건드린다

    public void setAge(int age) {
        if (age < 0) {                        // ← private이라서 이런 검증이 가능해진다
            System.out.println("나이는 음수일 수 없습니다.");
            return;
        }
        this.age = age;
    }
    public int getAge() { return age; }
}

public class StaticTest {

    public static final int NUMBER = 10000;  // Method Area (상수)
    static int count = 0;                    // Method Area (모든 객체가 공유)
    public int number = 10;                  // Heap (객체마다 따로)

    public StaticTest() { count++; }         // 객체가 만들어질 때마다 공유 카운트 증가

    static void staticMethod() {
        System.out.println("count = " + count);   // OK: static → static
        // System.out.println(number);            // 에러! static → non-static 불가
        StaticTest t = new StaticTest();
        System.out.println(t.number);             // 객체를 만들면 접근 가능
    }

    void instanceMethod() {
        System.out.println(count);   // OK: non-static → static 은 자유롭게 가능
        System.out.println(number);  // OK
    }

    public static void main(String[] args) {      // main도 static이다
        staticMethod();                           // 클래스명 없이 바로 호출 가능

        new StaticTest();
        new StaticTest();
        System.out.println(StaticTest.count);     // 3 (staticMethod에서 1개 + 여기서 2개)

        StaticTest obj = new StaticTest();
        obj.instanceMethod();                     // non-static은 객체를 통해서만
    }
}

public class OverloadingTest {

    // ① 매개변수 개수가 다르다
    public int a(int b, int c) { return b + c; }
    public int a(int b)        { return b; }

    // ② 개수가 같으면 타입이 달라야 한다
    public int a(byte b)       { return b; }

    // ③ 리턴 타입은 달라도 된다 (단, 리턴 타입"만" 다른 건 불가)
    public byte a(int b, int c, int d) { return 5; }

    // public double a(int b) { return 0; }  // ← 에러! 위 a(int b)와 매개변수가 같다

    public static void main(String[] args) {
        // 표준 API의 오버로딩 사례 — substring
        String subStr = "getitbeauty";
        String oneS = subStr.substring(5);      // 5번 인덱스부터 끝까지 → "beauty"
        String twoS = subStr.substring(3, 5);   // 3번부터 5번 앞까지     → "it"
        System.out.println(oneS + " : " + twoS);

        // println 도 타입별로 오버로딩되어 있다
        System.out.println(10);        // println(int)
        System.out.println(3.14);      // println(double)
        System.out.println("hello");   // println(String)
    }
}

public class Television {
    int size = 0;
    String color = "검정색";

    {   // 인스턴스 블록: 이름이 없는 { } — 생성자보다 먼저 실행된다
        System.out.println("TV 생산을 시작합니다.");
    }

    Television() {                 // ① 매개변수 없는 생성자
        this(20, "검정색");        // 다른 생성자 호출 — 반드시 첫 줄
    }

    Television(int x) {            // ② 크기만 받는 생성자
        this(x, "검정색");
    }

    Television(int x, String y) {  // ③ 크기 + 색상 (실제 초기화는 여기 한 곳에서)
        size = x;
        color = y;
        System.out.println(size + "인치 " + color + " TV 제작완료");
    }
}

public class Test {
    public static void main(String[] args) {
        Television a = new Television();              // 20인치 검정색
        Television b = new Television(30);            // 30인치 검정색
        Television c = new Television(40, "은색");    // 40인치 은색
    }
}

package hk.edu20260803.day02;      // ① 맨 첫 줄, 폴더 구조와 일치해야 한다

import java.util.Scanner;          // ② 클래스 하나만 가져오기
import java.util.ArrayList;
// import java.util.*;             //    이렇게 패키지 전체를 가져올 수도 있다
import java.io.IOException;        //    import는 여러 번 쓸 수 있다

public class PackageTest {
    public static void main(String[] args) {
        // java.lang 소속 — import 없이 바로 사용 가능
        String s = "hello";
        System.out.println(Math.max(3, 7));

        // java.util 소속 — 위에서 import 했기 때문에 짧은 이름으로 사용 가능
        Scanner sc = new Scanner(System.in);
        ArrayList<String> list = new ArrayList<>();
        list.add(s);

        // import를 안 했다면 이렇게 전체 이름을 써야 한다
        java.util.Date now = new java.util.Date();
        System.out.println(list + " " + now);
    }
}

class Student {
    int id;
    Student(int id) { this.id = id; }
    void setId(int id) { this.id = id; }
}

public class PassTest {

    // 기본타입: 값이 복사되어 넘어온다 → 원본 불변
    static void changeInt(int n) { n = 999; }

    // String: 참조타입이지만 immutable → 원본 불변
    static void changeString(String st) { st = "안녕하세요"; }

    // 참조타입: 주소가 복사되어 넘어온다 → 필드를 바꾸면 원본도 바뀐다
    static void changeStudent(Student st) { st.setId(45); }

    // 하지만 매개변수 자체에 새 객체를 대입하면 원본은 그대로다
    static void replaceStudent(Student st) { st = new Student(99); }

    public static void main(String[] args) {
        int n = 10;
        changeInt(n);
        System.out.println(n);            // 10  (그대로)

        String s = "hello";
        changeString(s);
        System.out.println(s);            // hello (그대로)

        Student stu = new Student(25);
        changeStudent(stu);
        System.out.println(stu.id);       // 45  ← 원본이 바뀌었다!

        replaceStudent(stu);
        System.out.println(stu.id);       // 45  (99가 아니다 — 새 객체를 대입했을 뿐)
    }
}

final class Star {                    // 상속 금지 — extends Star 불가
    final void shine() { }            // 오버라이딩 금지
}

public class FinalWrapperTest {

    public static final double PI = 3.141592;   // 상수: static final + 대문자

    public static void main(String[] args) {
        final int a = 5;
        // a = 7;                     // 에러! final 변수는 값 변경 불가
        System.out.println(a + " " + PI);

        // ---- Boxing / UnBoxing ----
        Integer box = 10;             // 오토박싱   : int → Integer
        int     un  = box;            // 오토언박싱 : Integer → int
        Object  o   = un;             // 기본타입도 Object에 담긴다(오토박싱)
        int     back = (Integer) o;   // 꺼낼 땐 캐스팅
        System.out.println(box + " " + un + " " + back);

        // ---- Wrapper가 제공하는 유용한 기능들 ----
        System.out.println(Integer.MAX_VALUE);        // 2147483647
        System.out.println(Integer.parseInt("123"));  // 문자열 → int
        System.out.println(Character.isDigit('9'));   // true
        System.out.println(Double.parseDouble("3.5"));

        // ---- 컬렉션에는 기본타입을 못 넣는다 → Wrapper가 필요한 이유 ----
        java.util.List<Integer> list = new java.util.ArrayList<>();
        list.add(10);                 // int 10이 오토박싱되어 Integer로 저장된다
        int first = list.get(0);      // 꺼낼 때 오토언박싱
        System.out.println(first);
    }
}

public class Singleton {

    // ② 자기 자신 타입의 static 필드 — 유일한 인스턴스의 주소를 담는다
    private static Singleton singleton;

    // ① 생성자를 private으로 막아 외부에서 new 를 못 쓰게 한다
    private Singleton() { }

    // ③ 객체 없이 부를 수 있어야 하므로 반드시 static
    public static Singleton getInstance() {
        if (singleton == null) {          // 아직 안 만들어졌을 때만 생성 (지연 초기화)
            singleton = new Singleton();
        }
        return singleton;                 // 두 번째부터는 기존 것을 그대로 반환
    }
}

public class SingletonMain {
    public static void main(String[] args) {
        // Singleton s = new Singleton();  // 에러! 생성자가 private

        Singleton obj1 = Singleton.getInstance();
        Singleton obj2 = Singleton.getInstance();

        System.out.println((obj1 == obj2)
            ? "obj1과 obj2는 같은 인스턴스를 가짐" : "다른 인스턴스");        // 주소 비교
        System.out.println((obj1.equals(obj2))
            ? "obj1과 obj2는 같은 인스턴스를 가짐" : "다른 인스턴스");        // 둘 다 true
    }
}

public class StringPool {
    public static void main(String[] args) {
        // ---- 리터럴: String pool에 저장되고 같은 값이면 같은 객체를 공유 ----
        String obj1 = "java";
        String obj2 = "java";      // 새로 만들지 않고 pool의 "java"를 가리킨다
        String obj3 = "JavaEdu";   // 값이 다르므로 pool에 새로 만들어진다

        System.out.println(obj1 == obj2);   // true  — 주소가 같다

        // ---- new: Heap에 별도 객체 생성 (값은 복사) ----
        String str = new String("java");
        System.out.println(obj1 == str);        // false — 주소가 다르다
        System.out.println(obj1.equals(str));   // true  — 값(hashCode)은 같다

        // ---- immutable 확인 ----
        String s = "ABCD";
        String s2 = s + "K";        // 새 객체가 만들어질 뿐, s는 그대로
        System.out.println(s);      // ABCD
        System.out.println(s2);     // ABCDK

        // ---- Concatenation: 왼쪽부터 계산된다 ----
        int a = 1, b = 2;
        System.out.println(a + b + "hello");   // 3hello  (숫자 계산 먼저)
        System.out.println("hello" + a + b);   // hello12 (문자열이 앞이라 계속 연결)
    }
}

import java.util.Arrays;

public class StringMethodTest {
    public static void main(String[] args) {
        // ---- 찾기 ----
        String indexStr = "Happy Birthday To 한경";
        System.out.println(indexStr.indexOf('p'));      // 2 (처음 나온 위치)
        System.out.println(indexStr.indexOf("To"));     // 문자열도 찾을 수 있다
        System.out.println(indexStr.indexOf('z'));      // -1 (없으면 -1)

        String charAtStr = "white";
        int n = charAtStr.indexOf('i');
        System.out.println(n + ":" + charAtStr.charAt(n));   // 2:i
        System.out.println(charAtStr.length());              // 5 (문자열은 length())

        // ---- 자르기·다듬기 ----
        String subStr = "getitbeauty";
        System.out.println(subStr.substring(5));     // beauty (5번부터 끝까지)
        System.out.println(subStr.substring(3, 5));  // it     (3번 ~ 5번 앞까지)

        String trimStr = "  한경닷컴  ";
        System.out.println(trimStr.length());          // 앞뒤 공백 포함 길이
        System.out.println(trimStr.trim().length());   // 앞뒤 공백만 제거된 길이

        // ---- 변환 ----
        char[] c = "star Dust".toCharArray();
        System.out.println(c.length);                  // 9 (배열은 length, 괄호 없음)
        System.out.println(Arrays.toString(c));        // [s, t, a, r,  , D, u, s, t]
        System.out.println(new String(c));             // 다시 문자열로

        System.out.println("hello".toUpperCase());     // HELLO (원본은 그대로)
        System.out.println(String.valueOf(10.13592));  // "10.13592"

        // ---- 비교 ----
        System.out.println("Eclipse".equalsIgnoreCase("eclipse"));  // true
        System.out.println("ab".compareTo("bc"));                   // -1 (사전순으로 앞)
    }
}

public class StringCompare {
    public static void main(String[] args) {
        // ① 리터럴 vs 리터럴 — pool의 같은 객체를 공유
        String str1 = "java";
        String str2 = "java";
        System.out.println(str1 == str2);        // true  (주소 01 == 01)
        System.out.println(str1.equals(str2));   // true  (해시 11 == 11)

        // ② new vs new — 주소가 각각 다르다
        String obj1 = new String("java");
        String obj2 = new String("java");
        System.out.println(obj1 == obj2);        // false (주소 02 != 03)
        System.out.println(obj1.equals(obj2));   // true  (값은 같다)

        // ③ 리터럴 vs new
        System.out.println(str1 == obj1);        // false
        System.out.println(str1.equals(obj1));   // true

        // ---- 실전 패턴: 리터럴을 앞에 두면 null 이어도 안전 ----
        String input = null;
        // System.out.println(input.equals("yes"));   // NullPointerException!
        System.out.println("yes".equals(input));      // false — 안전하다
    }
}

import java.util.StringTokenizer;

public class StringCutter {
    public static void main(String[] args) {
        // ---- String으로 반복 연결하면 매번 새 객체가 만들어진다(느림) ----
        String s = "";
        for (int i = 0; i < 5; i++) s += i;      // 새 String이 5번 생성됨
        System.out.println(s);                   // 01234

        // ---- StringBuilder: 같은 객체에 덧붙인다(빠름) ----
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 5; i++) sb.append(i);
        sb.insert(0, "[").append("]");           // 앞뒤로 삽입·추가
        System.out.println(sb.toString());       // [01234]
        System.out.println(sb.reverse());        // 뒤집기도 가능

        // ---- split: 빈 값도 배열 요소로 남는다 ----
        String[] arr = "100,200,300,,,400".split(",");
        System.out.println(arr.length);          // 6
        for (String a : arr) System.out.print("[" + a + "]");   // [100][200][300][][][400]
        System.out.println();

        // ---- StringTokenizer: 빈 값은 아예 만들지 않는다 ----
        StringTokenizer st = new StringTokenizer("100,200,300,,,400", ",");
        System.out.println(st.countTokens());    // 4
        while (st.hasMoreElements()) {
            System.out.print("[" + st.nextToken() + "]");        // [100][200][300][400]
        }
    }
}

import java.util.Arrays;

public class ArrayTest {
    public static void main(String[] args) {
        // ---- 선언 3가지 ----
        int[] a = {1, 2, 3};
        int[] b = new int[]{1, 2, 3};
        int[] c = new int[3];                 // 0, 0, 0 으로 자동 초기화
        String[] s = new String[2];           // null, null (참조타입은 null)
        System.out.println(Arrays.toString(c) + Arrays.toString(s));

        // ---- 2차원 배열 ----
        int[][] a2 = new int[2][3];
        a2[0][0] = 1;
        a2[1][2] = 6;
        int[][] a3 = {{1,2,3}, {4,5,6}};
        System.out.println(Arrays.deepToString(a3));   // [[1, 2, 3], [4, 5, 6]]

        // 가변(ragged) 배열 — 행마다 열 개수가 다를 수 있다
        int[][] a4 = new int[2][];
        a4[0] = new int[3];
        a4[1] = new int[4];
        System.out.println(a4[0].length + " " + a4[1].length);   // 3 4

        // ---- 1차원 → 2차원 변환: [i/col][i%col] ----
        int col = 4;
        int[][] magic = new int[4][4];
        for (int i = 0; i < 16; i++) {
            magic[i / col][i % col] = i + 1;   // 1~16을 순서대로 채운다
        }
        System.out.println(Arrays.deepToString(magic));

        // ---- 2차원 → 1차원 변환: i*col + j ----
        int[] flat = new int[16];
        for (int i = 0; i < 4; i++)
            for (int j = 0; j < col; j++)
                flat[i * col + j] = magic[i][j];
        System.out.println(Arrays.toString(flat));
    }
}

import java.util.Arrays;

public class CopyTest {
    public static void main(String[] args) {
        // ---- 향상된 for문 ----
        String[] str = {"여자", "남자", "사람"};
        for (int i = 0; i < str.length; i++)  System.out.print("[" + str[i] + "]");  // 일반 for
        System.out.println();
        for (String s : str)                   System.out.print("[" + s + "]");      // 향상된 for
        System.out.println();

        // ---- 얕은 복사: 주소만 복사되어 원본까지 바뀐다 ----
        int[] src  = {1, 5, 9};
        int[] dest = src;              // 같은 배열을 가리킨다
        dest[0] = 99;
        System.out.println(Arrays.toString(src));   // [99, 5, 9]  ← 원본도 바뀜!

        // ---- 깊은 복사: 새 배열에 값을 옮긴다 ----
        int[] src2  = {1, 5, 9};
        int[] deep  = new int[src2.length];
        System.arraycopy(src2, 0, deep, 0, src2.length);
        deep[0] = 99;
        System.out.println(Arrays.toString(src2));  // [1, 5, 9]   ← 원본은 그대로
        System.out.println(Arrays.toString(deep));  // [99, 5, 9]

        // 같은 효과의 간단한 방법들
        int[] copy1 = Arrays.copyOf(src2, src2.length);
        int[] copy2 = src2.clone();
        System.out.println(Arrays.toString(copy1) + Arrays.toString(copy2));
    }
}

// ---- ① 은닉화: 필드는 private, 접근은 메서드로 ----
class Account {
    private int balance;                       // 외부에서 직접 못 건드린다
    public void deposit(int money) {
        if (money <= 0) return;                // 검증할 수 있는 것이 은닉화의 이득
        balance += money;
    }
    public int getBalance() { return balance; }
}

// ---- ② 상속 ----
class Parent {
    String name = "부모";
    public void print() { System.out.println("부모에서 출력"); }
    public void onlyParent() { System.out.println("부모만 가진 기능"); }
}
class Child extends Parent {
    @Override
    public void print() { System.out.println("자식에서 override되어 실행된다"); }
    public void onlyChild() { System.out.println("자식만 가진 기능"); }
}

public class OopBasic {
    public static void main(String[] args) {
        // ---- ③ 다형성 ----
        Parent p = new Child();     // 부타자생: 부모 타입으로 자식을 생성
        p.print();                  // 부메자호(VMI): 자식의 print()가 실행된다
        p.onlyParent();             // 부모에 선언되어 있으므로 호출 가능

        // p.onlyChild();           // 에러! 설공메사 — 부모 설계도에 없는 메서드는 못 쓴다
        ((Child) p).onlyChild();    // 캐스팅하면 사용 가능

        Child c = new Child();
        Parent p2 = c;              // 부타자참: 부모 이름으로 자식을 받는다
        Child c2 = (Child) p2;      // 다시 자식으로 되돌리려면 명시적 캐스팅
        c2.onlyChild();
    }
}

class Shape {
    public void draw()  { System.out.println("도형을 그린다"); }
    public void info()  { System.out.println("이것은 도형입니다"); }
}

class Circle extends Shape {
    @Override                                   // 오타를 컴파일러가 잡아 준다
    public void draw() { System.out.println("○ 원을 그린다"); }
}

class Square extends Shape {
    @Override
    public void draw() { System.out.println("□ 사각형을 그린다"); }

    @Override
    public void info() {
        super.info();                           // 부모 기능을 먼저 실행하고
        System.out.println("그중에서도 사각형입니다");   // 내 기능을 덧붙인다(확장)
    }
}

public class OverrideTest {
    public static void main(String[] args) {
        // 부모 타입 배열에 자식 객체들을 담는다 — 다형성의 대표 활용
        Shape[] shapes = { new Circle(), new Square(), new Shape() };

        for (Shape s : shapes) {
            s.draw();      // VMI: 실행 시점에 실제 객체의 draw()가 호출된다
        }
        // ○ 원을 그린다 / □ 사각형을 그린다 / 도형을 그린다

        shapes[1].info();  // 부모 info() 실행 후 자식이 덧붙인 내용까지
    }
}

class Person {
    String name;
    int age;

    public Person(String name) {
        this(name, 19);              // ① 같은 클래스의 다른 생성자 호출 (첫 줄)
    }
    public Person(String name, int age) {
        this.name = name;            // ② this.필드 = 매개변수 (이름이 같을 때 구분)
        this.age  = age;
    }
    public String getName() { return name; }
    public int    getAge()  { return age;  }
}

class Mother {
    protected String name;
    public Mother(String name) { this.name = name; }
    public void display() { System.out.println("name : " + name); }
}

class Sun extends Mother {
    private String name;                  // 부모와 같은 이름의 필드 — 둘 다 존재한다

    public Sun(String motherName, String myName) {
        super(motherName);                // ③ 부모 생성자 호출 (반드시 첫 줄)
        this.name = myName;
    }
    @Override
    public void display() {
        System.out.println("mother name : " + super.name);  // 부모의 name
        System.out.println("my name : " + name);            // 자식의 name
    }
}

public class ThisSuperTest {
    public static void main(String[] args) {
        Person stu = new Person("홍길동");
        System.out.println(stu.getName() + " " + stu.getAge());   // 홍길동 19

        new Mother("mom").display();
        new Sun("mom", "sun").display();

        // ---- 참조타입 캐스팅: instanceof 로 확인 후 변환하는 것이 안전 ----
        Mother m = new Sun("mom", "sun");
        if (m instanceof Sun) {
            Sun s = (Sun) m;
            s.display();
        }
    }
}

abstract class Magic {
    protected int[][] board;              // 필드도 가질 수 있다
    public Magic(int n) { board = new int[n][n]; }   // 생성자도 가능

    // 구현된 메서드: 자식이 공통으로 물려받아 그대로 쓴다
    public void print() {
        for (int[] row : board) {
            for (int v : row) System.out.printf("%3d", v);
            System.out.println();
        }
    }

    // 추상 메서드: 몸체가 없다 → 자식이 반드시 구현해야 한다
    public abstract void make();
}

class OddMagic extends Magic {
    public OddMagic(int n) { super(n); }

    @Override
    public void make() {                  // 구현하지 않으면 컴파일 에러
        System.out.println("홀수 마방진 생성 알고리즘 실행");
    }
}

public class AbstractTest {
    public static void main(String[] args) {
        // Magic m0 = new Magic(3);       // 에러! 추상 클래스는 객체 생성 불가

        Magic m = new OddMagic(3);        // 추상 타입으로 참조 + 자식 구현 실행
        m.make();                         // OddMagic의 make()가 호출된다(VMI)
        m.print();                        // 부모가 구현해 둔 공통 기능을 그대로 사용
    }
}

// 추상 클래스: "is-a" — 공통 상태(필드)와 구현을 물려준다
abstract class Animal {
    String name;
    void breathe() { System.out.println("숨 쉰다"); }
    abstract void cry();
}

// 인터페이스: "can-do" — 기능 명세만 나열
interface Swimmable {
    int MAX_DEPTH = 100;          // 자동으로 public static final 상수
    void swim();                  // 자동으로 public abstract

    default void float_() {       // JDK 8+: 기본 구현 제공 (재정의 안 해도 됨)
        System.out.println("물에 뜬다");
    }
    static String info() {        // JDK 8+: static 메서드
        return "수영 가능 인터페이스";
    }
}
interface Runnable2 { void run(); }

// extends 를 먼저, implements 를 나중에. 인터페이스는 여러 개 가능
class Dog extends Animal implements Swimmable, Runnable2 {
    @Override void cry()   { System.out.println("멍멍"); }
    @Override public void swim() { System.out.println("수영한다!"); }   // 무조건 구현
    @Override public void run()  { System.out.println("달린다!"); }
}

public class InterfaceTest {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.breathe(); d.cry(); d.swim(); d.run();
        d.float_();                              // default 메서드 그대로 사용

        // 인터페이스 타입으로 참조 — 구현체가 무엇인지 몰라도 된다
        Swimmable s = d;
        s.swim();
        System.out.println(Swimmable.MAX_DEPTH + " " + Swimmable.info());
    }
}

interface Greeting { void hello(); }

public class NestedTest {
    public int a = 10;
    public static int s = 20;

    class B {                       // ① 인스턴스 내부 클래스 — 모든 멤버 접근 가능
        void print() { System.out.println(a + " " + s); }
    }

    static class C {                // ② 정적 중첩 클래스 — static 멤버만 접근 가능
        void print() { System.out.println(s); }
    }

    public void method() {
        int d = 30;                 // 재할당하지 않으므로 effectively final
        class D {                   // ③ 지역 내부 클래스 — 메서드 안에서만 존재
            void print() { System.out.println(d); }
        }
        new D().print();

        // ④ 익명 내부 클래스 — 이름 없이 즉시 구현하고 즉시 사용
        Greeting g = new Greeting() {
            @Override public void hello() { System.out.println("안녕! (익명 클래스)"); }
        };
        g.hello();

        // 같은 것을 람다식으로 (추상 메서드가 하나뿐이므로 가능)
        Greeting g2 = () -> System.out.println("안녕! (람다식)");
        g2.hello();
    }

    public static void main(String[] args) {
        NestedTest outer = new NestedTest();
        NestedTest.B b = outer.new B();   // 인스턴스 내부 클래스는 외부 객체가 필요
        b.print();

        new NestedTest.C().print();       // 정적 중첩 클래스는 독립적으로 생성 가능
        outer.method();
    }
}

import java.util.*;

// ---- 제네릭 클래스 ----
class Box<T> {
    private T item;
    public void set(T item) { this.item = item; }
    public T get() { return item; }
}

// ---- 제네릭 인터페이스 ----
interface Printer<T> { void print(T value); }
class StringPrinter implements Printer<String> {
    public void print(String value) { System.out.println("String: " + value); }
}

// ---- 제한된 타입: Number의 하위 타입만 허용 ----
class NumberBox<T extends Number> {
    private T num;
    public void set(T num) { this.num = num; }
    public void printDouble() { System.out.println(num.doubleValue()); }  // Number의 메서드 사용
}

public class GenericTest {
    // ---- 제네릭 메서드: 클래스가 제네릭이 아니어도 메서드만 제네릭으로 ----
    public static <T> void printAll(List<T> list) {
        for (T t : list) System.out.print(t + " ");
        System.out.println();
    }

    public static void main(String[] args) {
        // 제네릭 미적용 — Object로 처리되어 형변환이 필요하고 실수를 못 잡는다
        List raw = new ArrayList();
        raw.add("hello");
        String s0 = (String) raw.get(0);        // 강제 형변환 필요

        // 제네릭 적용 — 형변환 불필요, 잘못된 타입은 컴파일 에러
        List<String> list = new ArrayList<>();
        list.add("hello");
        // list.add(10);                        // 컴파일 에러로 미리 막아 준다
        String s1 = list.get(0);
        System.out.println(s0 + s1);

        Box<String>  strBox = new Box<>();  strBox.set("Hello");
        Box<Integer> intBox = new Box<>();  intBox.set(123);
        System.out.println(strBox.get() + " " + intBox.get());

        new StringPrinter().print("제네릭 인터페이스");

        NumberBox<Integer> nb = new NumberBox<>();
        nb.set(42);  nb.printDouble();          // 42.0

        // ---- 와일드카드 ----
        List<? extends Number> numbers = new ArrayList<Integer>();
        // numbers.add(10);                     // 에러! 읽기 전용
        List<? super Integer> ints = new ArrayList<Number>();
        ints.add(4);                            // 추가 가능
        Object o = ints.get(0);                 // 꺼내면 Object로만 받을 수 있다
        System.out.println(o);

        printAll(Arrays.asList(1, 2, 3));
    }
}

import java.util.*;

public class CollectionOverview {
    public static void main(String[] args) {
        // ---- List: 순서 O, 중복 O ----
        List<String> list = new ArrayList<>();
        list.add("A"); list.add("B"); list.add("B");   // 중복 허용
        System.out.println(list.get(0) + " " + list.size());   // A 3

        // ---- Set: 순서 X, 중복 X ----
        Set<String> set = new HashSet<>();
        set.add("가"); set.add("나"); set.add("나");   // 중복은 무시된다
        System.out.println(set.size());                // 2

        // ---- Map: key-value, key 중복 X ----
        Map<String, String> map = new HashMap<>();
        map.put("A", "값1");
        map.put("B", "값1");    // 값은 중복 가능
        map.put("B", "값3");    // 같은 키를 다시 넣으면 마지막 값으로 덮어쓴다
        System.out.println(map.get("A") + " " + map.get("B"));  // 값1 값3

        // ---- Iterator로 순회 (Set처럼 인덱스가 없을 때 유용) ----
        Iterator<String> iter = set.iterator();
        while (iter.hasNext()) System.out.print(iter.next() + " ");
        System.out.println();

        // ---- Map은 keySet()으로 키를 Set에 담아 순회한다 ----
        Set<String> keys = map.keySet();
        for (String k : keys) System.out.print(k + "=" + map.get(k) + " ");
    }
}

import java.util.*;

public class ListCompare {
    public static void main(String[] args) {
        // ---- ArrayList: 중간 삽입 시 뒤 요소들이 밀려난다 ----
        List<String> list = new ArrayList<>(Arrays.asList("A","B","C","D"));
        list.add(2, "I");             // 2번 자리에 삽입 → C, D가 뒤로 밀린다
        System.out.println(list);     // [A, B, I, C, D]

        // ---- LinkedList: 링크만 수정되므로 나머지는 영향을 받지 않는다 ----
        List<String> link = new LinkedList<>(Arrays.asList("A","B","C","D"));
        link.add(2, "I");
        System.out.println(link);     // [A, B, I, C, D]  (결과는 같지만 내부 동작이 다르다)

        // ---- 주요 메서드 ----
        System.out.println(list.get(0));          // A
        System.out.println(list.indexOf("I"));    // 2
        System.out.println(list.contains("Z"));   // false
        System.out.println(list.subList(1, 3));   // [B, I]
        list.remove("I");                         // 값으로 삭제
        list.remove(0);                           // 인덱스로 삭제
        System.out.println(list + " size=" + list.size());

        // ---- 동기화가 필요하면 Vector 대신 이 방식 ----
        List<String> safeList = Collections.synchronizedList(new ArrayList<>());
        Map<String,String> safeMap = Collections.synchronizedMap(new HashMap<>());
        safeList.add("thread-safe");
        System.out.println(safeList + " " + safeMap);
    }
}

import java.util.*;

public class SetCompare {
    public static void main(String[] args) {
        String[] data = {"다", "가", "나", "가"};

        Set<String> hash   = new HashSet<>(Arrays.asList(data));
        Set<String> linked = new LinkedHashSet<>(Arrays.asList(data));
        Set<String> tree   = new TreeSet<>(Arrays.asList(data));

        System.out.println(hash);    // [가, 나, 다] 순서 보장 없음 (중복 "가"는 제거)
        System.out.println(linked);  // [다, 가, 나] 입력 순서 유지
        System.out.println(tree);    // [가, 나, 다] 자동 정렬

        // TreeSet + Comparator: 정렬 기준 바꾸기 (내림차순)
        Set<String> desc = new TreeSet<>(Comparator.reverseOrder());
        desc.addAll(Arrays.asList(data));
        System.out.println(desc);    // [다, 나, 가]

        // ---- 실전: 로또 번호처럼 "중복 없는 6개"를 만들 때 ----
        Set<Integer> lotto = new TreeSet<>();      // TreeSet이면 정렬까지 덤으로
        while (lotto.size() < 6) {
            lotto.add((int)(Math.random() * 45) + 1);   // 중복이면 add가 무시된다
        }
        System.out.println(lotto);

        // ---- 순회: 향상된 for 또는 Iterator ----
        for (int n : lotto) System.out.print(n + " ");
        System.out.println();
        Iterator<Integer> it = lotto.iterator();
        while (it.hasNext()) System.out.print(it.next() + " ");
    }
}

import java.util.*;

public class MapCompare {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("A", "값1");
        map.put("B", "값1");       // 값은 중복 가능
        map.put("B", "값3");       // 키 중복 → 마지막 값으로 덮어쓰기
        System.out.println(map.get("A"));      // 값1
        System.out.println(map.get("Z"));      // null (없는 키는 null)
        System.out.println(map.getOrDefault("Z", "기본값"));   // 기본값

        // ---- keySet()으로 순회 ----
        Set<String> keys = map.keySet();
        for (String k : keys) System.out.print(k + "=" + map.get(k) + " ");
        System.out.println();

        // ---- entrySet()으로 키·값을 한 번에 ----
        for (Map.Entry<String, String> e : map.entrySet())
            System.out.print(e.getKey() + "→" + e.getValue() + " ");
        System.out.println();

        // ---- 세 구현체의 순서 차이 ----
        Map<String,Integer> hash   = new HashMap<>();
        Map<String,Integer> linked = new LinkedHashMap<>();
        Map<String,Integer> tree   = new TreeMap<>();
        for (Map<String,Integer> m : Arrays.asList(hash, linked, tree)) {
            m.put("다", 3); m.put("가", 1); m.put("나", 2);
        }
        System.out.println(hash);     // 순서 보장 없음
        System.out.println(linked);   // {다=3, 가=1, 나=2}  입력 순서
        System.out.println(tree);     // {가=1, 나=2, 다=3}  키 정렬

        // ---- 단어 개수 세기: Map의 대표 활용 ----
        String[] words = {"java", "css", "java", "html", "java"};
        Map<String,Integer> count = new HashMap<>();
        for (String w : words) count.put(w, count.getOrDefault(w, 0) + 1);
        System.out.println(count);    // {java=3, css=1, html=1}
    }
}

public class ExceptionTest {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};

        try {
            System.out.println(arr[5]);        // ArrayIndexOutOfBoundsException 발생
            System.out.println(10 / 0);        // 여기는 실행되지 않는다

        } catch (ArrayIndexOutOfBoundsException e) {    // 하위(구체적) 예외를 먼저
            System.out.println("배열 범위를 벗어났습니다: " + e.getMessage());

        } catch (ArithmeticException e) {
            System.out.println("0으로 나눌 수 없습니다.");

        } catch (Exception e) {                          // 상위(포괄적) 예외는 마지막
            System.out.println("그 밖의 예외: " + e);

        } finally {
            System.out.println("성공하든 실패하든 항상 실행됩니다.");
        }

        // Java 7+ : 여러 예외를 한 줄로 묶기
        try {
            String s = null;
            s.length();
        } catch (NullPointerException | ArithmeticException e) {
            System.out.println("묶어서 처리: " + e.getClass().getSimpleName());
        }

        System.out.println("예외를 처리했으므로 프로그램은 계속 실행됩니다.");
    }
}

// ---- 사용자 정의 예외: Exception을 상속 ----
class TestException extends Exception {
    public TestException(String message) {
        super(message);                    // 부모(Exception)에 메시지 전달
    }
    public TestException() {
        this("0으로 나누지 마세요");        // 기본 메시지를 가진 생성자
    }
}

public class UsingEx {

    // throws : "이 메서드는 TestException을 던질 수 있다"는 예고
    public static int sub(int a, int b) throws TestException {
        if (b == 0) {
            throw new TestException("0으로 나누지 마세요");   // throw : 실제로 던진다
        }
        return a / b;
    }

    public static void main(String[] args) {
        try {
            System.out.println(sub(10, 2));    // 5
            System.out.println(sub(10, 0));    // 여기서 예외 발생
        } catch (TestException e) {
            System.out.println("사용자 예외 처리: " + e.getMessage());
        }

        // ---- Checked vs Runtime 차이 ----
        // Checked: 처리하지 않으면 컴파일 자체가 안 된다
        try {
            new java.io.FileReader("없는파일.txt");    // IOException(Checked)
        } catch (java.io.IOException e) {
            System.out.println("파일 예외: " + e.getMessage());
        }

        // Runtime: 처리하지 않아도 컴파일은 된다 (실행 중에 터질 뿐)
        String s = null;
        try {
            s.length();                                 // NullPointerException
        } catch (RuntimeException e) {
            System.out.println("런타임 예외: " + e.getClass().getSimpleName());
        }
    }
}

import java.util.*;

@FunctionalInterface                 // 추상 메서드가 하나뿐임을 컴파일러가 검사
interface MyLambda { void show(); }

@FunctionalInterface
interface Calc { int apply(int x, int y); }

public class LambdaTest {
    public static void main(String[] args) {
        // ---- 익명 클래스 방식 (JDK 7 이하) ----
        MyLambda obj1 = new MyLambda() {
            @Override
            public void show() { System.out.println("Hello, Java! (익명 클래스)"); }
        };
        obj1.show();

        // ---- 람다식 방식 (JDK 8+) — 같은 일을 한 줄로 ----
        MyLambda obj2 = () -> System.out.println("Hello, Java! (람다식)");
        obj2.show();

        // ---- 매개변수·반환값이 있는 경우 ----
        Calc add = (x, y) -> x + y;              // 한 줄이면 중괄호와 return 생략
        Calc mul = (x, y) -> {                   // 여러 줄이면 둘 다 필요
            int r = x * y;
            return r;
        };
        System.out.println(add.apply(3, 4) + " " + mul.apply(3, 4));   // 7 12

        // ---- 표준 함수형 인터페이스 활용 ----
        List<String> names = new ArrayList<>(Arrays.asList("John", "Anna", "Bob"));

        names.forEach(n -> System.out.print(n + " "));       // Consumer
        System.out.println();

        names.sort((a, b) -> a.length() - b.length());       // Comparator (길이순 정렬)
        System.out.println(names);

        names.removeIf(n -> n.startsWith("A"));              // Predicate
        System.out.println(names);

        new Thread(() -> System.out.println("스레드도 람다로")).start();   // Runnable
    }
}

import java.util.*;
import java.util.stream.*;

public class StreamExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Anna", "Bob", "Alice", "Anna");

        // ---- 기본 파이프라인: 생성 → 중간 연산 → 최종 연산 ----
        names.stream()                              // 1. 스트림 생성
             .filter(n -> n.startsWith("A"))        // 2. 중간 연산 (필터링)
             .forEach(System.out::println);         // 3. 최종 연산 (출력)

        // ---- 중간 연산 조합 ----
        List<String> result = names.stream()
             .distinct()                            // 중복 제거 (Anna 하나만)
             .filter(n -> n.length() > 3)           // 길이 4 이상
             .map(String::toUpperCase)              // 대문자로 변환
             .sorted()                              // 정렬
             .collect(Collectors.toList());         // 리스트로 수집
        System.out.println(result);                 // [ALICE, ANNA, JOHN]

        // ---- 숫자 처리 ----
        List<Integer> nums = Arrays.asList(5, 3, 9, 1, 7, 9);
        System.out.println(nums.stream().count());                       // 6
        System.out.println(nums.stream().filter(n -> n > 5).count());    // 3
        System.out.println(nums.stream().reduce((a, b) -> a + b).get()); // 34 (합계)
        System.out.println(nums.stream().allMatch(n -> n > 0));          // true
        System.out.println(nums.stream().sorted().findFirst().get());    // 1 (최솟값)

        // IntStream: 숫자 전용 스트림은 sum()·average()를 바로 제공
        System.out.println(IntStream.rangeClosed(1, 10).sum());          // 55

        // ---- 원본은 바뀌지 않는다 ----
        System.out.println(names);   // [John, Anna, Bob, Alice, Anna] 그대로

        // ---- 최종 연산 후 재사용은 불가 ----
        Stream<String> s = names.stream();
        s.count();
        // s.count();   // IllegalStateException: stream has already been operated upon
    }
}

import java.io.*;

public class IoOverview {
    public static void main(String[] args) throws IOException {

        // ---- 노드 스트림: 파일에 직접 연결 (1byte 단위) ----
        FileOutputStream fos = new FileOutputStream("test.txt");
        fos.write("Hello".getBytes());
        fos.close();

        // ---- 필터 스트림: 노드 스트림을 감싸서 기능 추가 ----
        //      FileReader(노드) → BufferedReader(필터) 로 감싸면 readLine() 사용 가능
        FileReader     fr = new FileReader("test.txt");      // 2byte(char) 단위 노드
        BufferedReader br = new BufferedReader(fr);          // 버퍼 + readLine() 추가
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
        br.close();      // 감싼 쪽(마지막에 만든 것)부터 닫는다

        // ---- 키보드 입력도 같은 구조 ----
        //      System.in(노드, byte) → InputStreamReader(byte→char 변환) → BufferedReader(필터)
        BufferedReader keyboard =
            new BufferedReader(new InputStreamReader(System.in));
        System.out.print("입력하세요: ");
        System.out.println("입력값: " + keyboard.readLine());
    }
}

import java.io.*;

public class FileIoTest {
    public static void main(String[] args) {

        // ---- 쓰기: Writer 계열은 write(String)이 있다 ----
        Writer writer = null;
        try {
            writer = new FileWriter("file.txt");
            writer.write("문자열을 출력합니다.\n두 번째 줄입니다.");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // close는 반드시 finally에서 — 위에서 예외가 나도 실행되어야 한다
            if (writer != null) {
                try { writer.close(); } catch (IOException e) { }
            }
        }

        // ---- 읽기: Reader에는 문자열 읽기가 없으므로 BufferedReader로 감싼다 ----
        try (Reader read = new FileReader("file.txt");                  // try-with-resources
             BufferedReader br = new BufferedReader(read)) {            // 자동으로 close된다
            String line;
            while ((line = br.readLine()) != null) {                    // null이면 끝
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // ---- 1byte 단위 읽기: 반환값이 음수(-1)면 더 읽을 데이터가 없다는 뜻 ----
        try (InputStream in = new FileInputStream("file.txt")) {
            int c;
            while ((c = in.read()) != -1) {      // -1 = EOF
                System.out.print((char) c);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// ---- 방법 ①: Runnable 구현 (다른 클래스를 상속 중이어도 가능) ----
class MyRun implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) System.out.println("Runnable " + i);
    }
}

// ---- 방법 ②: Thread 상속 ----
class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) System.out.println("Thread " + i);
    }
}

// ---- 공유 객체 + 동기화 ----
class Calculator {
    private int cal;

    // synchronized: 한 스레드가 끝날 때까지 다른 스레드는 들어올 수 없다
    public synchronized void setAndPrint(int value) {
        this.cal = value;
        try { Thread.sleep(100); } catch (InterruptedException e) { }
        System.out.println(Thread.currentThread().getName() + " → " + cal);
    }
}

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        new Thread(new MyRun()).start();     // ① Runnable
        new MyThread().start();              // ② Thread 상속
        new Thread(() -> System.out.println("람다로도 가능")).start();   // ③ 람다

        // ---- 동기화 확인: 없으면 둘 다 같은 값을 출력하는 버그가 생긴다 ----
        Calculator c = new Calculator();
        Thread t1 = new Thread(() -> c.setAndPrint(5),  "스레드1");
        Thread t2 = new Thread(() -> c.setAndPrint(10), "스레드2");
        t1.start(); t2.start();

        t1.join(); t2.join();                // 두 스레드가 끝날 때까지 기다린다
        System.out.println("메인 스레드 종료");
    }
}

import java.net.InetAddress;
import java.net.UnknownHostException;

public class IpTest {
    public static void main(String[] args) throws UnknownHostException {
        // 내 컴퓨터의 IP (보통 사설 IP가 나온다)
        InetAddress local = InetAddress.getLocalHost();
        System.out.println("호스트명 : " + local.getHostName());
        System.out.println("IP 주소  : " + local.getHostAddress());

        // 도메인 이름으로 공인 IP 조회 (DNS 조회)
        InetAddress remote = InetAddress.getByName("www.google.com");
        System.out.println("google IP: " + remote.getHostAddress());

        // 한 도메인에 여러 IP가 매핑된 경우 전부 조회
        for (InetAddress a : InetAddress.getAllByName("www.google.com")) {
            System.out.println(" - " + a.getHostAddress());
        }
    }
}

import java.io.*;
import java.net.*;

public class TCPServer {
    public static void main(String[] args) {
        // try-with-resources: 블록이 끝나면 자동으로 close()된다
        try (ServerSocket serverSocket = new ServerSocket(5000)) {
            System.out.println("Server is listening on port 5000");

            while (true) {
                Socket socket = serverSocket.accept();   // 연결이 올 때까지 여기서 멈춘다
                System.out.println("New client connected");
                new ServerThread(socket).start();        // 클라이언트마다 스레드 하나씩
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

class ServerThread extends Thread {
    private Socket socket;
    public ServerThread(Socket socket) { this.socket = socket; }

    public void run() {
        try (InputStream input = socket.getInputStream();
             BufferedReader reader = new BufferedReader(new InputStreamReader(input));
             OutputStream output = socket.getOutputStream();
             PrintWriter writer = new PrintWriter(output, true)) {   // true = autoFlush

            String text;
            while ((text = reader.readLine()) != null) {   // 끊길 때까지 계속 읽는다
                System.out.println("Received: " + text);
                writer.println("Echo: " + text);           // 받은 걸 그대로 되돌려 준다
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

import java.io.*;
import java.net.*;

public class TCPClient {
    public static void main(String[] args) {
        String hostname = "localhost";      // 같은 PC에서 테스트할 때 쓰는 루프백 주소
        int port = 5000;

        try (Socket socket = new Socket(hostname, port)) {     // 서버에 접속
            OutputStream output = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(output, true);

            // 키보드 입력을 읽기 위한 스트림 (소켓과는 별개)
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            // 서버 응답을 읽기 위한 스트림
            BufferedReader responseReader =
                new BufferedReader(new InputStreamReader(socket.getInputStream()));

            String text;
            while (true) {
                System.out.print("Enter text: ");
                text = reader.readLine();       // 키보드 입력
                writer.println(text);           // 서버로 전송
                System.out.println(responseReader.readLine());   // 서버 응답 출력
            }
        } catch (UnknownHostException ex) {
            System.out.println("Server not found: " + ex.getMessage());
        } catch (IOException ex) {
            System.out.println("I/O error: " + ex.getMessage());
        }
    }
}

import java.io.*;
import java.net.*;

public class UDPServer {
    public static void main(String[] args) {
        try (DatagramSocket socket = new DatagramSocket(5000)) {
            byte[] buffer = new byte[512];                     // 받을 데이터를 담을 버퍼
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            System.out.println("Server is listening on port 5000");

            while (true) {
                socket.receive(packet);                        // 데이터가 올 때까지 블록

                // 실제 받은 길이만큼만 문자열로 변환해야 한다
                String received = new String(packet.getData(), 0, packet.getLength());
                System.out.println("Received: " + received);

                // 보낸 사람의 주소·포트를 패킷에서 꺼내 그대로 되돌려 보낸다
                InetAddress address = packet.getAddress();
                int port = packet.getPort();
                packet = new DatagramPacket(buffer, buffer.length, address, port);
                socket.send(packet);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

import java.io.*;
import java.net.*;

public class UDPClient {
    public static void main(String[] args) {
        String hostname = "localhost";
        int port = 5000;

        try (DatagramSocket socket = new DatagramSocket()) {   // 포트 자동 할당
            InetAddress address = InetAddress.getByName(hostname);
            byte[] buffer = new byte[512];
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

            String text;
            while (true) {
                System.out.print("Enter text: ");
                text = reader.readLine();
                buffer = text.getBytes();                      // 문자열 → byte 배열

                // 전송용 패킷: 데이터 + 길이 + 목적지 주소 + 포트
                DatagramPacket packet =
                    new DatagramPacket(buffer, buffer.length, address, port);
                socket.send(packet);

                // 수신용 패킷: 데이터 + 길이만 (주소 불필요)
                packet = new DatagramPacket(buffer, buffer.length);
                socket.receive(packet);
                String received = new String(packet.getData(), 0, packet.getLength());
                System.out.println("Received: " + received);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

import java.io.*;
import java.net.*;
import java.util.*;

public class ChatServer {
    // 접속한 모든 클라이언트의 출력 스트림 — 여러 스레드가 공유하므로 동기화 필요
    static List<PrintWriter> clients =
        Collections.synchronizedList(new ArrayList<>());

    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(5000)) {
            System.out.println("채팅 서버 시작 (포트 5000)");

            while (true) {
                Socket socket = serverSocket.accept();   // 메인 스레드는 연결만 받는다
                new ClientHandler(socket).start();       // 처리는 작업 스레드에 위임
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 접속한 전체에게 메시지를 뿌린다
    static void broadcast(String msg) {
        synchronized (clients) {                 // 순회 중 목록이 바뀌지 않도록 잠근다
            for (PrintWriter w : clients) w.println(msg);
        }
    }
}

class ClientHandler extends Thread {
    private Socket socket;
    public ClientHandler(Socket socket) { this.socket = socket; }

    public void run() {
        PrintWriter writer = null;
        try (BufferedReader reader = new BufferedReader(
                 new InputStreamReader(socket.getInputStream()))) {

            writer = new PrintWriter(socket.getOutputStream(), true);
            ChatServer.clients.add(writer);                 // 목록에 등록
            ChatServer.broadcast("[알림] 새 사용자 입장 (현재 "
                                 + ChatServer.clients.size() + "명)");

            String text;
            while ((text = reader.readLine()) != null) {    // 끊길 때까지 수신
                ChatServer.broadcast("> " + text);          // 받은 메시지를 전체에게
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (writer != null) ChatServer.clients.remove(writer);   // 나가면 목록에서 제거
            ChatServer.broadcast("[알림] 사용자 퇴장");
            try { socket.close(); } catch (IOException e) { }
        }
    }
}

public class Divisor {

    // 약수를 화면에 출력한다
    public static void printDivisors(int num) {
        System.out.print(num + "의 약수: ");
        for (int i = 1; i <= num; i++) {
            if (num % i == 0) {              // 나머지가 0 = 나누어 떨어진다
                System.out.print(i + " ");
            }
        }
        System.out.println();
    }

    // 자기 자신을 제외한 약수(진약수)의 합 — 4번·5번 문제에서 재사용한다
    public static int getProperDivisorSum(int num) {
        int sum = 0;
        for (int i = 1; i < num; i++) {      // i < num : 자기 자신은 제외
            if (num % i == 0) sum += i;
        }
        return sum;
    }

    public static void main(String[] args) {
        printDivisors(12);                       // 1 2 3 4 6 12
        System.out.println(getProperDivisorSum(220));   // 284
    }
}

public class Gcd {

    // 방법 2: 두 수가 같아질 때까지 큰 수에서 작은 수를 뺀다 (과제 제시 방법)
    public static int gcdBySub(int a, int b) {
        while (a != b) {
            if (a > b) a -= b;
            else       b -= a;
        }
        return a;                    // 같아진 값이 최대공약수
    }

    // 방법 3: 유클리드 호제법 — 나머지가 0이 될 때까지 반복 (훨씬 빠르다)
    public static int gcd(int a, int b) {
        while (b != 0) {
            int temp = a % b;
            a = b;
            b = temp;
        }
        return a;
    }

    // 재귀로 쓰면 한 줄 (같은 알고리즘)
    public static int gcdRecursive(int a, int b) {
        return (b == 0) ? a : gcdRecursive(b, a % b);
    }

    public static void main(String[] args) {
        System.out.println(gcdBySub(10, 20));      // 10
        System.out.println(gcd(10, 20));           // 10
        System.out.println(gcdRecursive(48, 18));  // 6
    }
}

public class Lcm {

    public static int gcd(int a, int b) {          // 2번 문제에서 만든 것을 재사용
        while (b != 0) { int t = a % b; a = b; b = t; }
        return a;
    }

    public static int lcm(int a, int b) {
        return a / gcd(a, b) * b;                  // 나눗셈을 먼저 해서 오버플로 방지
    }

    // 참고: 공식을 모른다면 배수를 하나씩 늘려가며 찾을 수도 있다
    public static int lcmByLoop(int a, int b) {
        int big = Math.max(a, b);
        int n = big;
        while (n % a != 0 || n % b != 0) {         // 둘 다 나누어 떨어질 때까지
            n += big;
        }
        return n;
    }

    public static void main(String[] args) {
        System.out.println(lcm(2, 4));        // 4
        System.out.println(lcm(10, 20));      // 20
        System.out.println(lcmByLoop(6, 8));  // 24
    }
}

public class AmicableNumber {

    // 자기 자신을 제외한 약수(진약수)의 합
    public static int sumOfProperDivisors(int num) {
        int sum = 0;
        for (int i = 1; i < num; i++) {        // i < num 이 핵심! (자기 자신 제외)
            if (num % i == 0) sum += i;
        }
        return sum;
    }

    // 두 수가 친화수인지 판별
    public static boolean isAmicable(int a) {
        int b = sumOfProperDivisors(a);        // a의 진약수 합
        if (a == b) return false;              // 완전수는 친화수가 아니다
        return sumOfProperDivisors(b) == a;    // 다시 a로 돌아오면 친화수
    }

    public static void main(String[] args) {
        System.out.println(sumOfProperDivisors(220));   // 284
        System.out.println(sumOfProperDivisors(284));   // 220
        System.out.println(isAmicable(220));            // true

        // 1 ~ 1300 범위에서 친화수 쌍 찾기
        for (int a = 2; a <= 1300; a++) {
            int b = sumOfProperDivisors(a);
            if (a < b && sumOfProperDivisors(b) == a) {   // a < b : 중복 출력 방지
                System.out.println(a + " 와 " + b + " 는 친화수입니다.");
            }
        }
        // 220 와 284 / 1184 와 1210
    }
}

public class PerfectNumber {

    // 자기 자신을 제외한 약수의 합 (4번 문제와 동일한 메서드)
    public static int sumOfProperDivisors(int num) {
        int sum = 0;
        for (int i = 1; i < num; i++) {
            if (num % i == 0) sum += i;
        }
        return sum;
    }

    // 완전수 판별: 진약수의 합이 자기 자신과 같은가?
    public static boolean isPerfect(int num) {
        return num > 1 && sumOfProperDivisors(num) == num;
    }

    public static void main(String[] args) {
        System.out.println(isPerfect(6));    // true  (1+2+3 = 6)
        System.out.println(isPerfect(28));   // true  (1+2+4+7+14 = 28)
        System.out.println(isPerfect(12));   // false (1+2+3+4+6 = 16)

        System.out.println("1 ~ 10000 사이의 완전수:");
        for (int i = 2; i <= 10000; i++) {
            if (isPerfect(i)) {
                System.out.print(i + " ");   // 6 28 496 8128
            }
        }
    }
}

import java.time.LocalDate;

public class LeapYear {

    // 윤년 판별 — 11번 달력 문제에서도 그대로 쓰인다
    public static boolean isLeapYear(int year) {
        return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
    }

    public static void main(String[] args) {
        System.out.println(isLeapYear(2024));   // true  (4의 배수)
        System.out.println(isLeapYear(1900));   // false (100의 배수라 평년)
        System.out.println(isLeapYear(2000));   // true  (400의 배수라 윤년)

        // 문제 7: 2000년 ~ 현재까지의 윤년만 출력
        int now = LocalDate.now().getYear();
        for (int y = 2000; y <= now; y++) {
            if (isLeapYear(y)) {
                System.out.println(y + "년: 윤년입니다.");
            }
        }
    }
}

public class AntSequence {

    // 한 항을 읽어 다음 항을 만든다
    public static String next(String s) {
        StringBuilder sb = new StringBuilder();
        char[] c = s.toCharArray();

        char prev = c[0];      // 비교 기준이 되는 앞 글자
        int count = 1;         // 같은 숫자가 몇 번 연속되는지

        for (int i = 1; i < c.length; i++) {
            if (c[i] == prev) {
                count++;                       // 같으면 개수만 늘린다
            } else {
                sb.append(prev).append(count); // 다르면 "숫자 + 개수"를 기록하고
                prev = c[i];                   // 기준을 바꾸고
                count = 1;                     // 개수를 초기화
            }
        }
        sb.append(prev).append(count);         // ★ 마지막 묶음 처리 (빠뜨리기 쉬움)
        return sb.toString();
    }

    public static void main(String[] args) {
        String s = "1";
        for (int i = 1; i <= 6; i++) {
            System.out.println(i + "번째: " + s);
            s = next(s);
        }
        // 1번째: 1
        // 2번째: 11
        // 3번째: 12
        // 4번째: 1121
        // 5번째: 122111
        // 6번째: 112213
    }
}

import java.util.Arrays;

// ---- 문제 1: 로또 한 장 ----
class Lotto {
    private int[] numbers = new int[6];

    public Lotto() {
        int count = 0;
        while (count < 6) {
            int n = (int)(Math.random() * 45) + 1;   // 1 ~ 45
            if (!contains(n, count)) {               // 중복이 아니면 저장
                numbers[count] = n;
                count++;
            }
        }
        Arrays.sort(numbers);                        // 보기 좋게 정렬
    }

    // 이미 뽑은 번호인지 확인 (count 개까지만 검사)
    private boolean contains(int n, int count) {
        for (int i = 0; i < count; i++) {
            if (numbers[i] == n) return true;
        }
        return false;
    }

    public int[] getNumbers() { return numbers; }
    public void print() { System.out.println(Arrays.toString(numbers)); }

    // 추첨번호와 비교해 일치 개수를 센다
    public int matchCount(Lotto win) {
        int match = 0;
        for (int my : numbers) {
            for (int w : win.getNumbers()) {
                if (my == w) { match++; break; }
            }
        }
        return match;
    }
}

// ---- 문제 2: 로또 판매점 (여러 장 보관) ----
class LottoStore {
    private Lotto[] lottos;

    public LottoStore(int count) {
        lottos = new Lotto[count];                   // 객체 배열 — 아직 전부 null
        for (int i = 0; i < count; i++) {
            lottos[i] = new Lotto();                 // 하나씩 실제 객체로 채운다
        }
    }
    public Lotto[] getLottos() { return lottos; }
    public void printAll() { for (Lotto l : lottos) l.print(); }
}

// ---- 문제 3: 당첨 확인 ----
public class LottoMain {
    public static String rank(int match) {
        switch (match) {
            case 6:  return "1등";
            case 5:  return "2등";
            case 4:  return "3등";
            case 3:  return "4등";
            case 2:  return "5등";
            default: return "낙첨";
        }
    }

    public static void main(String[] args) {
        LottoStore store = new LottoStore(5);        // 5장 구매
        Lotto win = new Lotto();                     // 추첨번호

        System.out.print("당첨번호: ");
        win.print();
        System.out.println("--- 구매한 로또 ---");

        for (Lotto l : store.getLottos()) {
            int match = l.matchCount(win);
            System.out.print(Arrays.toString(l.getNumbers()));
            System.out.println(" → 맞은 개수 " + match + "개, " + rank(match));
        }
    }
}

import java.util.Arrays;

public class MagicSquare {

    // ---- ① 홀수 마방진 ----
    public static int[][] odd(int n) {
        int[][] m = new int[n][n];
        int r = 0, c = n / 2;          // 시작 위치: 0행, 가운데 열
        m[r][c] = 1;

        for (int i = 2; i <= n * n; i++) {
            int nr = (r - 1 + n) % n;  // 왼쪽 위 대각선 (음수면 반대편 끝으로)
            int nc = (c - 1 + n) % n;
            if (m[nr][nc] != 0) {      // 이미 값이 있으면 이동 전 위치에서 한 칸 아래로
                nr = (r + 1) % n;
                nc = c;
            }
            m[nr][nc] = i;
            r = nr; c = nc;
        }
        return m;
    }

    // ---- ② 4의 배수 마방진 ----
    public static int[][] doublyEven(int n) {
        int[][] m = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                m[i][j] = i * n + j + 1;                   // 1~n²를 순서대로 채우고
                if ((i % 4 == j % 4) || ((i % 4 + j % 4) == 3)) {
                    m[i][j] = n * n + 1 - m[i][j];         // 대각선 패턴 위치만 역순 값으로
                }
            }
        }
        return m;
    }

    // ---- ③ 6마방진 (4의 배수가 아닌 짝수) ----
    public static int[][] singlyEven(int n) {
        int half = n / 2;
        int[][] sub = odd(half);           // n/2 크기의 홀수 마방진을 먼저 만든다
        int[][] m = new int[n][n];
        int sq = half * half;

        for (int i = 0; i < half; i++) {
            for (int j = 0; j < half; j++) {
                m[i][j]               = sub[i][j];             // A 영역 (+0)
                m[i + half][j + half] = sub[i][j] + sq;        // B 영역 (+1배)
                m[i][j + half]        = sub[i][j] + 2 * sq;    // C 영역 (+2배)
                m[i + half][j]        = sub[i][j] + 3 * sq;    // D 영역 (+3배)
            }
        }

        int k = (n - 2) / 4;
        for (int i = 0; i < half; i++) {
            for (int j = 0; j < k; j++) {                      // 왼쪽 k개 열: A ↔ D 교환
                int jj = (i == half / 2) ? j + 1 : j;          // 가운데 행만 한 칸 오른쪽
                int t = m[i][jj]; m[i][jj] = m[i + half][jj]; m[i + half][jj] = t;
            }
            for (int j = 0; j < k - 1; j++) {                  // 오른쪽 k-1개 열: C ↔ B 교환
                int jj = n - 1 - j;
                int t = m[i][jj]; m[i][jj] = m[i + half][jj]; m[i + half][jj] = t;
            }
        }
        return m;
    }

    // ---- 크기에 맞는 알고리즘 선택 (팩토리 역할) ----
    public static int[][] create(int n) {
        if (n % 2 == 1)      return odd(n);
        else if (n % 4 == 0) return doublyEven(n);
        else                 return singlyEven(n);
    }

    // ---- ④ 검증: 행·열·대각선의 합이 모두 같은가? ----
    public static boolean isMagic(int[][] m) {
        int n = m.length;
        int target = 0, d1 = 0, d2 = 0;
        for (int j = 0; j < n; j++) target += m[0][j];   // 첫 행의 합을 기준으로

        for (int i = 0; i < n; i++) {
            int row = 0, col = 0;
            for (int j = 0; j < n; j++) { row += m[i][j]; col += m[j][i]; }
            if (row != target || col != target) return false;
            d1 += m[i][i];              // 왼쪽 위 → 오른쪽 아래 대각선
            d2 += m[i][n - 1 - i];      // 오른쪽 위 → 왼쪽 아래 대각선
        }
        return d1 == target && d2 == target;
    }

    public static void print(int[][] m) {
        for (int[] row : m) {
            for (int v : row) System.out.printf("%4d", v);
            System.out.println();
        }
    }

    public static void main(String[] args) {
        for (int n : new int[]{3, 4, 6, 10}) {
            int[][] m = create(n);
            System.out.println("=== " + n + " 마방진 (마방진 확인: " + isMagic(m) + ") ===");
            print(m);
        }
    }
}

import java.util.Scanner;

public class BaseballGame {

    // 1~9 중 중복 없는 숫자 3개 생성 (로또 문제의 중복 확인 로직과 동일)
    public static int[] makeNumbers() {
        int[] arr = new int[3];
        int count = 0;
        while (count < 3) {
            int n = (int)(Math.random() * 9) + 1;
            boolean dup = false;
            for (int i = 0; i < count; i++) if (arr[i] == n) dup = true;
            if (!dup) arr[count++] = n;
        }
        return arr;
    }

    public static void main(String[] args) {
        int[] pitcher = makeNumbers();
        Scanner sc = new Scanner(System.in);
        int tryCount = 0;

        System.out.println("서로 다른 숫자 3개를 입력하세요 (예: 123)");

        while (true) {
            System.out.print("타자: ");
            String input = sc.next();
            if (input.length() != 3) {              // 간단한 입력 검증
                System.out.println("3자리로 입력하세요.");
                continue;
            }
            tryCount++;

            int[] batter = new int[3];
            for (int i = 0; i < 3; i++) {
                batter[i] = input.charAt(i) - '0';  // 문자 '3' → 숫자 3
            }

            int strike = 0, ball = 0;
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    if (batter[i] == pitcher[j]) {
                        if (i == j) strike++;       // 숫자도 위치도 일치
                        else        ball++;         // 숫자만 일치
                    }
                }
            }

            if (strike == 3) {
                System.out.println("3S 모두 일치!! 타자 승리!! (" + tryCount + "번 만에 성공)");
                break;
            } else if (strike == 0 && ball == 0) {
                System.out.println("out");
            } else {
                System.out.println(strike + "S " + ball + "B");
            }
        }
        sc.close();
    }
}

import java.time.LocalDate;

public class Calendar2023 {

    static final int[] NORMAL = {31,28,31,30,31,30,31,31,30,31,30,31};
    static final int[] LEAP   = {31,29,31,30,31,30,31,31,30,31,30,31};

    // 6번 문제의 윤년 판별을 그대로 재사용
    public static boolean isLeapYear(int y) {
        return (y % 4 == 0 && y % 100 != 0) || (y % 400 == 0);
    }

    public static int lastDay(int year, int month) {
        return isLeapYear(year) ? LEAP[month - 1] : NORMAL[month - 1];
    }

    // 1년 1월 1일부터 (year, month, day)까지의 총 경과일
    public static int totalDays(int year, int month, int day) {
        int total = 0;
        for (int y = 1; y < year; y++) {                 // ① 지난 연도들
            total += isLeapYear(y) ? 366 : 365;
        }
        for (int m = 1; m < month; m++) {                // ② 올해 지난 달들
            total += lastDay(year, m);
        }
        return total + day;                              // ③ 이번 달의 날짜
    }

    public static void printMonth(int year, int month) {
        System.out.printf("%n      < %d년 %d월 >%n", year, month);
        System.out.println(" 일  월  화  수  목  금  토");

        int start = totalDays(year, month, 1) % 7;       // 0이면 일요일
        for (int i = 0; i < start; i++) System.out.print("    ");   // 앞 공백

        int last = lastDay(year, month);
        for (int d = 1; d <= last; d++) {
            System.out.printf("%3d ", d);
            if ((start + d) % 7 == 0) System.out.println();          // 토요일마다 줄바꿈
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // 문제 1: 2023년 1월 ~ 12월 달력 출력
        for (int m = 1; m <= 12; m++) printMonth(2023, m);

        // 문제 2: 살아온 일수 (생일을 입력하면 오늘까지의 일수를 계산)
        int by = 2000, bm = 5, bd = 15;                  // 예시 생일
        LocalDate today = LocalDate.now();
        int days = totalDays(today.getYear(), today.getMonthValue(), today.getDayOfMonth())
                 - totalDays(by, bm, bd);
        System.out.println("살아온 일수: " + days + "일");
    }
}

import java.util.*;

// ---- 문제 1: 카드 한 장 ----
class Card {
    // 모든 카드가 공유하는 값이므로 static final (상수)
    public static final String[] SHAPES  = {"♥", "♣", "♠", "◆"};
    public static final String[] NUMBERS =
        {"2","3","4","5","6","7","8","9","10","T","J","Q","K"};

    private String shape;
    private String number;

    // 랜덤 카드 한 장
    public Card() {
        this(SHAPES[(int)(Math.random() * SHAPES.length)],
             NUMBERS[(int)(Math.random() * NUMBERS.length)]);
    }
    // 지정 카드 (덱을 순서대로 만들 때 사용)
    public Card(String shape, String number) {
        this.shape = shape;
        this.number = number;
    }

    @Override
    public String toString() { return shape + number; }

    // 중복 확인(contains)을 쓰려면 equals·hashCode가 필요하다
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Card)) return false;
        Card c = (Card) o;
        return shape.equals(c.shape) && number.equals(c.number);
    }
    @Override
    public int hashCode() { return Objects.hash(shape, number); }
}

// ---- 문제 2: 카드 52장이 들어있는 덱 ----
class CardDeck {
    private List<Card> cards = new ArrayList<>();

    // 방법 ②: 4 × 13 으로 전부 만들고 섞는다 (중복이 원천적으로 없다)
    public CardDeck() {
        for (String s : Card.SHAPES) {
            for (String n : Card.NUMBERS) {
                cards.add(new Card(s, n));
            }
        }
        Collections.shuffle(cards);
    }

    // 방법 ①: 랜덤으로 뽑되 중복이면 다시 (equals 오버라이드가 필요하다)
    public static CardDeck byRandom() {
        CardDeck deck = new CardDeck();
        deck.cards.clear();
        while (deck.cards.size() < 52) {
            Card c = new Card();
            if (!deck.cards.contains(c)) deck.cards.add(c);   // contains → equals 사용
        }
        return deck;
    }

    public int size() { return cards.size(); }
    public Card draw() {                       // 맨 위 카드 한 장 뽑기
        return cards.isEmpty() ? null : cards.remove(0);
    }
    public void printAll() { System.out.println(cards); }
}

public class CardMain {
    public static void main(String[] args) {
        CardDeck deck = new CardDeck();
        System.out.println("덱 크기: " + deck.size());   // 52
        deck.printAll();

        System.out.println("--- 5장 뽑기 ---");
        for (int i = 0; i < 5; i++) System.out.print(deck.draw() + " ");
        System.out.println("\n남은 카드: " + deck.size());   // 47
    }
}