public class Main {
    // 자바 프로그램의 시작점 (Entry Point)
    // 컴파일 후 JVM이 가장 먼저 찾아 실행하는 메서드입니다.
    public static void main(String[] args) {
        System.out.println("Hello, Java World!");
        
        // JRE(Java Runtime Environment) 및 OS 정보 확인
        String javaVersion = System.getProperty("java.version");
        String osName = System.getProperty("os.name");
        
        System.out.println("현재 운영체제: " + osName);
        System.out.println("현재 자바 버전: " + javaVersion);
        
        System.out.println("JVM 덕분에 동일한 코드가 " + osName + " 환경에서도 완벽히 실행됩니다!");
    }
}

public class Main {
    public static void main(String[] args) {
        // 1. 원시 타입 (Primitive Type)
        // 값 자체가 Stack 메모리에 저장됩니다.
        int age = 30;
        double height = 175.5;
        boolean isStudent = false;

        // 2. 참조 타입 (Reference Type)
        // 실제 데이터는 Heap에, 변수(name)에는 Heap의 주소가 담깁니다.
        String name = "Minstudio"; // (String Pool을 사용하지만 기본적으로 참조 타입입니다)
        
        System.out.println("age: " + age);
        System.out.println("height: " + height);
        System.out.println("name: " + name);

        // 3. 참조 타입의 주의점 (주소 비교 vs 값 비교)
        // new 키워드로 명시적으로 각각 다른 Heap 메모리 영역에 "Java" 객체를 생성합니다.
        String a = new String("Java");
        String b = new String("Java");

        System.out.println("\n--- 문자열(참조 타입) 비교 주의점 ---");
        
        // == 연산자는 Heap에 저장된 '주소(리모컨)'를 비교합니다.
        // a와 b는 서로 다른 객체를 가리키므로 주소가 다릅니다 (false).
        System.out.println("a == b (주소 비교): " + (a == b)); 

        // .equals() 메서드는 실제 상자 안의 '값'을 비교합니다.
        // 둘 다 "Java"라는 글자를 담고 있으므로 true를 반환합니다.
        System.out.println("a.equals(b) (값 비교): " + a.equals(b));
    }
}

public class Main {
    public static void main(String[] args) {
        
        System.out.println("--- 1. if-else 조건문 ---");
        int score = 85;
        
        if (score >= 90) {
            System.out.println("A 등급");
        } else if (score >= 80) {
            System.out.println("B 등급");
        } else {
            System.out.println("C 등급");
        }

        System.out.println("\n--- 2. 모던 Java (14+) Switch 표현식 ---");
        // Java 14 이상 지원: break 생략 가능, 화살표(->) 사용, 반환값 직접 할당
        String day = "MON";
        
        String status = switch (day) {
            case "MON", "TUE", "WED", "THU", "FRI" -> "평일 (출근)";
            case "SAT", "SUN" -> "주말 (휴식)";
            default -> "알 수 없는 요일";
        };
        
        System.out.println("오늘의 상태: " + status);

        System.out.println("\n--- 3. 향상된 for문 (for-each) ---");
        // 배열의 처음부터 끝까지 순회하며 값을 하나씩 fruit 변수에 꺼내줍니다.
        String[] fruits = {"Apple", "Banana", "Cherry"};
        
        for (String fruit : fruits) {
            System.out.println("과일 이름: " + fruit);
        }
    }
}

// 1. 붕어빵 틀(클래스) 정의
class FishBread {
    // 필드 (상태/속성)
    // private: 외부에서 마음대로 앙금을 바꾸지 못하게 캡슐화(보호)합니다.
    private String filling; 

    // 생성자 (인스턴스가 new를 통해 생성될 때 최초로 호출되는 메서드)
    public FishBread(String filling) {
        this.filling = filling;
    }

    // 메서드 (행동/기능)
    public void bake() {
        System.out.println(this.filling + " 붕어빵이 따끈하게 구워졌습니다!");
    }
}

public class Main {
    public static void main(String[] args) {
        // 2. new 연산자를 사용하여 붕어빵 틀에서 2개의 '인스턴스(객체)'를 찍어냅니다.
        // 이 순간 힙(Heap) 메모리에 2개의 독립적인 공간이 생깁니다.
        FishBread redBeanBread = new FishBread("팥");
        FishBread creamBread = new FishBread("슈크림");

        // 3. 인스턴스의 행동 실행
        // 각각의 인스턴스는 자신만의 독립적인 상태(filling)를 가지고 행동합니다.
        redBeanBread.bake(); 
        creamBread.bake();   
    }
}

// 부모 클래스 (설계도 원본)
class Animal {
    public void makeSound() {
        System.out.println("동물이 알 수 없는 소리를 냅니다.");
    }
}

// 자식 클래스 (Dog는 Animal을 확장/상속 받음)
class Dog extends Animal {
    // 부모의 메서드를 자식의 입맛에 맞게 재정의 (Overriding)
    @Override
    public void makeSound() {
        System.out.println("멍멍!");
    }
}

// 자식 클래스 (Cat은 Animal을 확장/상속 받음)
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("야옹~");
    }
}

public class Main {
    public static void main(String[] args) {
        
        // 다형성 (Polymorphism)의 핵심:
        // '부모(Animal) 타입의 변수'에 '자식(Dog, Cat) 인스턴스'를 담을 수 있습니다. (업캐스팅)
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        // 겉보기엔 똑같이 Animal의 makeSound()를 호출하는 것 같지만,
        // 실제 메모리에 들어있는 객체(Dog, Cat)에 따라 결과가 다르게 나타납니다.
        myDog.makeSound(); // 출력: 멍멍!
        myCat.makeSound(); // 출력: 야옹~
        
        System.out.println("\n[배열을 이용한 다형성 처리]");
        // 다형성 덕분에 서로 다른 객체들을 'Animal'이라는 하나의 배열로 묶어서 관리할 수 있습니다.
        Animal[] pets = { new Dog(), new Cat() };
        
        for (Animal pet : pets) {
            pet.makeSound();
        }
    }
}

// 인터페이스 정의 (구현부가 없는 추상 메서드들의 집합, '규약')
interface UsbConnectable {
    // 인터페이스 안의 메서드는 자동으로 public abstract 처리됩니다.
    void connect(); 
}

// 클래스가 인터페이스의 규약을 따를 때는 'implements(구현)' 키워드를 사용합니다.
// 규약을 맺었으므로 반드시 내부의 connect() 메서드를 강제로 완성해야 합니다.
class Mouse implements UsbConnectable {
    @Override
    public void connect() {
        System.out.println("마우스가 USB 포트에 연결되었습니다. 띠링!");
    }
}

class Keyboard implements UsbConnectable {
    @Override
    public void connect() {
        System.out.println("키보드가 USB 포트에 연결되었습니다. 타닥타닥.");
    }
}

public class Main {
    public static void main(String[] args) {
        
        System.out.println("[USB 포트에 기기 연결 중...]");
        
        // 다형성의 극대화:
        // 컴퓨터(Main) 입장에서는 이것이 마우스인지 키보드인지 구체적으로 알 필요가 없습니다.
        // 그저 'UsbConnectable 규격을 통과한 기기'라면 무엇이든 수용합니다.
        UsbConnectable device1 = new Mouse();
        UsbConnectable device2 = new Keyboard();

        // 껍데기(인터페이스)에 대고 명령을 내리면, 연결된 실제 객체들이 알아서 동작합니다.
        device1.connect(); 
        device2.connect(); 
    }
}

public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3}; // 인덱스는 0, 1, 2만 존재합니다.

        try {
            // 예외가 발생할 가능성이 있는 위험한 무대
            System.out.println("배열의 5번째 요소 접근 시도...");
            
            // 배열 크기는 3인데 5번째(인덱스 4)에 접근하므로 여기서 오류 폭발!
            // 오류가 터진 즉시 실행이 중단되고 곧바로 catch 블록으로 던져집니다.
            System.out.println(numbers[4]); 
            
            System.out.println("에러 아래쪽의 이 코드는 영원히 실행되지 않습니다.");

        } catch (ArrayIndexOutOfBoundsException e) {
            // 특정 예외가 터졌을 때 안전하게 낚아채서 수습하는 그물망
            System.out.println("경고: 배열의 범위를 벗어났습니다!");
            System.out.println("에러 메시지: " + e.getMessage());

        } catch (Exception e) {
            // 그 외의 예상치 못한 모든 예외를 잡는 최상위 안전망 (항상 맨 아래에 배치)
            System.out.println("알 수 없는 오류 발생: " + e.getMessage());

        } finally {
            // 예외 발생 여부와 상관없이 100% 무조건 실행되는 뒷정리 블록
            System.out.println("finally: 예외 검사가 모두 종료되었습니다.");
        }
        
        // try-catch 덕분에 프로그램이 크래시(강제종료)되지 않고 살아서 진행됩니다.
        System.out.println("프로그램이 강제 종료되지 않고 여기까지 정상적으로 도달했습니다.");
    }
}

// 데이터 타입을 <T>라는 임시 변수(타입 파라미터)로 구멍을 뚫어놓은 제네릭 클래스 설계
class Box<T> {
    private T item; // T는 컴파일(객체 생성) 시점에 String, Integer 등으로 완벽히 치환됩니다.

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

public class Main {
    public static void main(String[] args) {
        // 1. 객체를 생성할 때 <T> 자리에 들어갈 구체적인 진짜 타입을 명시합니다.
        // (Java 7 이상부터는 뒤쪽 다이아몬드 연산자 <> 안의 타입을 생략할 수 있습니다)
        Box<String> stringBox = new Box<>(); 
        
        stringBox.setItem("소중한 반지");
        
        // stringBox.setItem(100); 
        // ☝️ 만약 위 주석을 해제하면 에러 발생! String만 넣을 수 있도록 컴파일러가 완벽 차단합니다.

        // 캐스팅(형변환) 코드 없이 바로 String 타입으로 안전하게 꺼내 쓸 수 있습니다.
        String myItem = stringBox.getItem();
        System.out.println("상자 안의 물건: " + myItem);


        // 2. 완전히 똑같은 Box 클래스 설계도 하나로, 이번엔 '숫자 전용' 상자를 만들었습니다.
        // (제네릭에는 int 같은 원시타입은 들어갈 수 없어 Wrapper 클래스인 Integer를 사용합니다)
        Box<Integer> numberBox = new Box<>(); 
        numberBox.setItem(999);
        
        System.out.println("상자 안의 숫자: " + numberBox.getItem());
    }
}

// 컬렉션 프레임워크를 사용하기 위해서는 java.util 패키지를 import 해야 합니다.
import java.util.ArrayList;
import java.util.List;
import java.util.HashSet;
import java.util.Set;
import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        
        // 1. List (대기표: 순서 보장, 중복 허용)
        // 다형성을 위해 왼쪽은 인터페이스(List), 오른쪽은 구현체(ArrayList)를 쓰는 것이 정석입니다.
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("Java"); // 중복 데이터를 넣어도 0번째, 2번째로 위치(인덱스)가 다르므로 괜찮습니다.
        System.out.println("List (대기표): " + list); 
        // 출력: [Java, Python, Java]


        // 2. Set (장바구니: 순서 섞임, 중복 무시)
        Set<String> set = new HashSet<>();
        set.add("Java");
        set.add("Python");
        set.add("Java"); // 이미 "Java"가 있으므로, 이 줄은 조용히 무시됩니다.
        System.out.println("Set (장바구니): " + set); 
        // 출력: [Java, Python] (순서는 내부 알고리즘에 의해 랜덤으로 나옵니다)


        // 3. Map (전화번호부: Key-Value 쌍, Key 중복 불가)
        Map<String, Integer> scores = new HashMap<>();
        scores.put("Alice", 90);
        scores.put("Bob", 85);
        
        // Key인 "Alice"가 중복되었습니다. 에러가 나지는 않지만 덮어쓰기(수정)가 일어납니다.
        scores.put("Alice", 95); 

        System.out.println("Map (전화번호부): " + scores); 
        // 출력: {Bob=85, Alice=95}
        
        // Key를 던져주면 그에 맞는 Value를 꺼내옵니다.
        System.out.println("Alice의 점수: " + scores.get("Alice")); 
        // 출력: 95
    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        // 불변 리스트 초기화
        List<String> names = Arrays.asList("Apple", "Banana", "Cherry", "Avocado", "Blueberry");

        // 목표: 'A'로 시작하는 과일만 대문자로 바꿔서 새 리스트에 담기

        // 1. [과거 방식 - Java 7 이전]
        // 코드가 길어지고, 뎁스(if문)가 깊어져 가독성이 떨어집니다.
        List<String> oldResult = new ArrayList<>();
        for (String name : names) {
            if (name.startsWith("A")) {
                oldResult.add(name.toUpperCase());
            }
        }
        System.out.println("[과거 방식] 결과: " + oldResult);

        // 2. [모던 자바 스트림 방식 - Java 8 이후]
        // 선언적 코드(무엇을 할 것인가)에 집중하여 컨베이어 벨트처럼 직관적입니다.
        List<String> streamResult = names.stream()                 // 1. 물줄기(스트림) 생성
                .filter(name -> name.startsWith("A"))              // 2. 중간 연산: 'A'로 시작하는 과일만 통과 (람다식)
                .map(name -> name.toUpperCase())                   // 3. 중간 연산: 모두 대문자로 가공 (람다식)
                .collect(Collectors.toList());                     // 4. 최종 연산: 결과를 다시 List로 묶어라

        System.out.println("[모던 자바 스트림 방식] 결과: " + streamResult); 
    }
}

public class Main {
    public static void main(String[] args) {
        
        // 1. 객체 생성: Heap 메모리에 "홍길동" 객체 공간이 할당됩니다.
        // Stack 메모리에 있는 'user' 변수가 그 주소를 잡고 있습니다. (연결 상태)
        String user = new String("홍길동"); 

        System.out.println("현재 유저 객체: " + user);

        // 2. 연결 끊기 (풍선 줄 놓기)
        // 변수에 null을 대입하여 Heap 객체와의 '연결 고리'를 의도적으로 끊습니다.
        user = null; 
        System.out.println("유저 객체와의 연결을 끊었습니다. (null 대입)");

        // 이제 "홍길동" 객체는 메모리에 존재하지만, 그 누구도 접근할 수 없는 '외딴섬(Unreachable)'이 됩니다.
        // 백그라운드에서 조용히 돌고 있는 가비지 컬렉터(GC)가 주기적으로 하늘을 순찰하다가
        // 이런 쓰레기(고아 객체)들을 찾아내어 메모리에서 영구히 삭제(청소)합니다.

        // 3. GC 강제 호출 (실무에서는 절대 금지!)
        // 개발자가 System.gc()를 호출해서 "웬만하면 지금 청소 좀 해줘" 라고 요청할 순 있지만,
        // 실제 청소를 언제 할지는 100% JVM 맘대로입니다. (무시할 수도 있습니다)
        // 강제로 호출하면 전체 시스템이 일시정지(Stop-the-world) 되므로 실무에선 절대 직접 쓰지 않습니다.
        System.gc();
        System.out.println("[시스템] 개발자가 명시적으로 GC 실행을 요청했습니다. (비권장)");
        
        System.out.println("안심하세요! JVM이 알아서 메모리를 관리해줍니다.");
    }
}