Java 프로그래밍 입문

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

# 컴파일: .java → .class (바이트코드)
javac HelloWorld.java

# 실행: JVM이 바이트코드 실행
java HelloWorld

public class BankAccount {
    // private 필드로 외부 접근 차단
    private double balance;
    private String accountNumber;

    // 생성자
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    // getter로 읽기 허용
    public double getBalance() {
        return balance;
    }

    // 검증 로직이 포함된 메서드로 데이터 변경
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public boolean withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
            return true;
        }
        return false;
    }
}

// 부모 클래스
public class Vehicle {
    protected String brand;
    protected int year;

    public Vehicle(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

    public void start() {
        System.out.println("Vehicle is starting...");
    }

    public void stop() {
        System.out.println("Vehicle is stopping...");
    }
}

// 자식 클래스
public class Car extends Vehicle {
    private int numberOfDoors;

    public Car(String brand, int year, int numberOfDoors) {
        super(brand, year);  // 부모 생성자 호출
        this.numberOfDoors = numberOfDoors;
    }

    // 메서드 오버라이딩
    @Override
    public void start() {
        System.out.println("Car engine is starting...");
    }

    // 자식 클래스만의 메서드
    public void honk() {
        System.out.println("Beep beep!");
    }
}

// 다형성 예제
public class PolymorphismExample {
    public static void main(String[] args) {
        // 부모 타입으로 자식 객체 참조 (업캐스팅)
        Vehicle myVehicle = new Car("Toyota", 2023, 4);
        myVehicle.start();  // "Car engine is starting..." 출력

        // 메서드 오버로딩 예제
        Calculator calc = new Calculator();
        System.out.println(calc.add(5, 3));       // int 버전
        System.out.println(calc.add(5.0, 3.0));   // double 버전
        System.out.println(calc.add(1, 2, 3));    // 세 개 인자 버전
    }
}

class Calculator {
    // 메서드 오버로딩: 같은 이름, 다른 매개변수
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }

    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

// 추상 클래스
public abstract class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    // 추상 메서드: 구현 없음, 자식 클래스에서 반드시 구현
    public abstract void makeSound();

    // 일반 메서드: 구현 있음
    public void sleep() {
        System.out.println(name + " is sleeping...");
    }
}

// 구현 클래스
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " says: Woof!");
    }
}

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " says: Meow!");
    }
}

// 인터페이스 정의
public interface Flyable {
    // 추상 메서드 (public abstract 생략)
    void fly();

    // Java 8+ default 메서드
    default void land() {
        System.out.println("Landing...");
    }

    // Java 8+ static 메서드
    static void checkWeather() {
        System.out.println("Checking weather conditions...");
    }
}

public interface Swimmable {
    void swim();
}

// 다중 인터페이스 구현
public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying!");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming!");
    }
}

// 제네릭 클래스
public class Box<T> {
    private T content;

    public void set(T content) {
        this.content = content;
    }

    public T get() {
        return content;
    }
}

// 제네릭 메서드
public class GenericUtils {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }

    // 제한된 타입 파라미터
    public static <T extends Number> double sum(T[] numbers) {
        double total = 0.0;
        for (T number : numbers) {
            total += number.doubleValue();
        }
        return total;
    }
}

// 사용 예제
public class GenericExample {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.set("Hello");
        String str = stringBox.get();  // 형변환 불필요

        Box<Integer> intBox = new Box<>();
        intBox.set(123);
        Integer num = intBox.get();

        Integer[] numbers = {1, 2, 3, 4, 5};
        System.out.println(GenericUtils.sum(numbers));
    }
}

// 무제한 와일드카드
public void printList(List<?> list) {
    for (Object item : list) {
        System.out.println(item);
    }
}

// 상한 제한 와일드카드 (읽기용)
public double sumOfList(List<? extends Number> list) {
    double sum = 0.0;
    for (Number num : list) {
        sum += num.doubleValue();
    }
    return sum;
}

// 하한 제한 와일드카드 (쓰기용)
public void addNumbers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
}

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        // ArrayList: 동적 배열, 랜덤 접근 빠름
        List<String> arrayList = new ArrayList<>();
        arrayList.add("Java");
        arrayList.add("Python");
        arrayList.add("JavaScript");

        // 인덱스로 접근
        System.out.println(arrayList.get(0));  // "Java"

        // 반복
        for (String lang : arrayList) {
            System.out.println(lang);
        }

        // LinkedList: 삽입/삭제 빠름
        List<Integer> linkedList = new LinkedList<>();
        linkedList.add(1);
        linkedList.add(0, 0);  // 맨 앞에 삽입
        linkedList.remove(1);
    }
}

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetExample {
    public static void main(String[] args) {
        // HashSet: 순서 보장 안됨, 빠른 검색
        Set<String> hashSet = new HashSet<>();
        hashSet.add("Apple");
        hashSet.add("Banana");
        hashSet.add("Apple");  // 중복 무시
        System.out.println(hashSet.size());  // 2

        // TreeSet: 정렬된 순서 유지
        Set<Integer> treeSet = new TreeSet<>();
        treeSet.add(3);
        treeSet.add(1);
        treeSet.add(2);
        // 출력: 1, 2, 3 (정렬됨)

        // LinkedHashSet: 삽입 순서 유지
        Set<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("First");
        linkedHashSet.add("Second");
        linkedHashSet.add("Third");
    }
}

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public class MapExample {
    public static void main(String[] args) {
        // HashMap: 빠른 검색, 순서 보장 안됨
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("Java", 1995);
        hashMap.put("Python", 1991);
        hashMap.put("JavaScript", 1995);

        // 값 조회
        Integer year = hashMap.get("Java");
        System.out.println("Java was released in: " + year);

        // 키 존재 확인
        if (hashMap.containsKey("Python")) {
            System.out.println("Python exists!");
        }

        // 반복
        for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // getOrDefault
        int cYear = hashMap.getOrDefault("C", 1972);
    }
}

import java.io.*;

public class ExceptionExample {
    public static void main(String[] args) {
        // try-catch-finally
        try {
            int result = divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println("Division error: " + e.getMessage());
        } finally {
            System.out.println("This always executes");
        }

        // try-with-resources (Java 7+)
        try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
            String line = reader.readLine();
            System.out.println(line);
        } catch (IOException e) {
            System.out.println("IO error: " + e.getMessage());
        }

        // 다중 catch
        try {
            String str = null;
            str.length();
        } catch (NullPointerException | IllegalArgumentException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }

    // throws로 예외 전파
    public static int divide(int a, int b) throws ArithmeticException {
        if (b == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
        return a / b;
    }
}