// 계약만 정의
interface Drivable {
    void drive();
}

// 공통 기능 포함
abstract class Vehicle {
    String model;

    public Vehicle(String model) {
        this.model = model;
    }

    // 공통 기능
    public void printModel() {
        System.out.println("Model: " + model);
    }

    // 추상 메서드 (계약)
    public abstract void startEngine();
}

// Car는 Vehicle을 상속해야 하고 Drivable도 구현해야 함
class Car extends Vehicle implements Drivable {

    public Car(String model) {
        super(model);
    }

    @Override
    public void startEngine() {
        System.out.println("Car engine started!");
    }

    @Override
    public void drive() {
        System.out.println("Car is driving!");
    }
}

// 만약 다른 클래스도 상속해야 하면 abstract class 상속은 하나만 가능
class SportsCar extends Car /*extends SomeOtherClass*/ { 
    // 자바는 다중 상속을 막아서, Vehicle + SomeOtherClass 동시에 상속 불가
}

java.lang.Throwable
├── java.lang.Error                // 주로 JVM 레벨 문제
│   ├── VirtualMachineError
│   │   ├── OutOfMemoryError
│   │   └── StackOverflowError
│   ├── AssertionError
│   └── LinkageError
└── java.lang.Exception      // 프로그램에서 처리 가능한 예외
    ├── java.lang.RuntimeException // Unchecked Exception
    │   ├── NullPointerException
    │   ├── IndexOutOfBoundsException
    │   │   ├── ArrayIndexOutOfBoundsException
    │   │   └── StringIndexOutOfBoundsException
    │   ├── ArithmeticException
    │   ├── ClassCastException
    │   ├── IllegalArgumentException
    │   │   └── NumberFormatException
    │   ├── IllegalStateException
    │   ├── UnsupportedOperationException
    │   └── ConcurrentModificationException
    ├── java.io.IOException          // Checked Exception (입출력 관련)
    │   ├── FileNotFoundException
    │   ├── EOFException
    │   ├── InterruptedIOException
    │   └── ObjectStreamException
    │       ├── InvalidClassException
    │       ├── NotSerializableException
    │       └── OptionalDataException
    ├── java.sql.SQLException
    ├── ClassNotFoundException
    ├── NoSuchMethodException
    ├── NoSuchFieldException
    ├── InstantiationException
    └── ReflectiveOperationException
        ├── IllegalAccessException
        └── InvocationTargetException

import java.io.*;

public class ExceptionExample {
    public static void main(String[] args) {
        // Checked Exception 예시: 파일 읽기
        try {
            FileReader reader = new FileReader("nonexistent.txt");
            reader.read();
            reader.close();
        } catch (FileNotFoundException e) {
            System.out.println("파일이 존재하지 않습니다: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("파일 입출력 오류 발생: " + e.getMessage());
        }

        // Unchecked Exception 예시: 0으로 나누기
        try {
            int a = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("산술 오류 발생: " + e.getMessage());
        }
    }
}

public abstract class Game {
    // 템플릿 메소드
    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }

    // 추상 메소드들 (하위 클래스에서 구현)
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();
}

public class Singleton {
    // 클래스 내부에서 단 하나의 인스턴스를 생성
    private static final Singleton instance = new Singleton();

    // private 생성자 → 외부에서 new Singleton() 불가능
    private Singleton() {
        System.out.println("Singleton 생성자 호출");
    }
}

// 1. 추상 팩토리 인터페이스
interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

// 2. 구체 팩토리 (Windows)
class WindowsFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new WindowsCheckbox();
    }
}

// 3. 구체 팩토리 (Mac)
class MacFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
}

// Product 클래스
class Computer {
    private String cpu;
    private String gpu;
    private int ram;
    private int storage;

    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.gpu = builder.gpu;
        this.ram = builder.ram;
        this.storage = builder.storage;
    }

    @Override
    public String toString() {
        return "Computer [CPU=" + cpu + ", GPU=" + gpu + ", RAM=" + ram + "GB, Storage=" + storage + "GB]";
    }

    // Builder 클래스
    public static class Builder {
        private String cpu;
        private String gpu;
        private int ram;
        private int storage;

        public Builder setCpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

        public Builder setGpu(String gpu) {
            this.gpu = gpu;
            return this;
        }

        public Builder setRam(int ram) {
            this.ram = ram;
            return this;
        }

        public Builder setStorage(int storage) {
            this.storage = storage;
            return this;
        }

        public Computer build() {
            return new Computer(this);
        }
    }
}