모던 자바 문법 총정리 — Records부터 Pattern Matching까지

// Record 선언 — 이게 끝이다
public record Point(int x, int y) {}

Point p1 = new Point(1, 2);
Point p2 = new Point(1, 2);

System.out.println(p1.x());        // 1 — getter가 아닌 컴포넌트명
System.out.println(p1.equals(p2)); // true — 값 기반 비교
System.out.println(p1);            // Point[x=1, y=2]

public record Age(int value) {
    // 컴팩트 생성자 — 파라미터 선언 없이 바로 검증
    public Age {
        if (value < 0 || value > 200) {
            throw new IllegalArgumentException("나이는 0~200 사이여야 합니다: " + value);
        }
    }
}

public record ApiResponse<T>(int code, String message, T data)
    implements Serializable {

    // static 팩토리 메서드는 가능
    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(200, "OK", data);
    }
}

// 기존 방식 — 이스케이프와 + 연결의 지옥
String json = "{\n" +
    "  \"name\": \"홍길동\",\n" +
    "  \"age\": 25\n" +
    "}";

// Text Block — 그냥 쓰면 된다
String json = """
        {
          "name": "홍길동",
          "age": 25
        }
        """;

String sql = """
        SELECT *
        FROM users
        WHERE age > 20
        """;
// 결과: 각 줄 앞의 공통 공백이 제거됨

// 마지막에 줄바꿈 없음
String noNewline = """
        hello""";

// 마지막에 줄바꿈 있음
String withNewline = """
        hello
        """;

// 기존 방식 — 검사 후 캐스팅을 별도로 해야 한다
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

// 패턴 매칭 — 검사와 캐스팅이 한 줄
if (obj instanceof String s) {
    System.out.println(s.length());
}

// 부정 조건에서도 사용 가능
if (!(obj instanceof String s)) {
    return; // 여기서는 s 사용 불가
}
// 여기서는 s 사용 가능 — obj가 String인 게 확실하니까
System.out.println(s.toUpperCase());

// 기존 방식 — fall-through 때문에 break를 빼먹으면 다음 케이스까지 실행됨
String result;
switch (day) {
    case MONDAY:
    case TUESDAY:
        result = "업무";
        break;
    case SATURDAY:
    case SUNDAY:
        result = "휴일";
        break;
    default:
        result = "기타";
        break;
}

// Arrow syntax — fall-through 없음, 값 반환 가능
String result = switch (day) {
    case MONDAY, TUESDAY -> "업무";
    case SATURDAY, SUNDAY -> "휴일";
    default -> "기타";
};

String result = switch (status) {
    case "OK" -> "성공";
    case "ERROR" -> {
        // 여러 줄 로직이 필요한 경우
        log.warn("에러 발생");
        yield "실패"; // yield로 값 반환
    }
    default -> "알 수 없음";
};

// Shape를 상속할 수 있는 클래스를 permits로 지정
public sealed class Shape
    permits Circle, Rectangle, Triangle {
}

// 하위 클래스는 final, sealed, non-sealed 중 하나를 선언해야 한다
public final class Circle extends Shape {
    private final double radius;

    public Circle(double radius) {
        this.radius = radius;
    }
}

public final class Rectangle extends Shape {
    private final double width, height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
}

// non-sealed: 다른 클래스가 자유롭게 상속 가능
public non-sealed class Triangle extends Shape {
    // ...
}

public sealed interface Shape
    permits Circle, Rectangle {}

public record Circle(double radius) implements Shape {}
public record Rectangle(double width, double height) implements Shape {}

// 모든 케이스를 다루면 default 불필요 — 컴파일러가 검증
public double area(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.width() * r.height();
        // default 없어도 컴파일 OK — 모든 하위 타입을 다뤘으니까
    };
}

// sealed + record + pattern matching의 실전 활용
public sealed interface PaymentResult
    permits Success, Failure, Pending {}

public record Success(String transactionId) implements PaymentResult {}
public record Failure(String errorCode, String message) implements PaymentResult {}
public record Pending(String redirectUrl) implements PaymentResult {}

// 처리하는 쪽 — 새 결과 타입이 추가되면 컴파일 에러로 잡아준다
public String handleResult(PaymentResult result) {
    return switch (result) {
        case Success s -> "결제 완료: " + s.transactionId();
        case Failure f -> "결제 실패: " + f.message();
        case Pending p -> "결제 진행중 — " + p.redirectUrl() + "로 이동";
    };
}

// sealed interface + record로 API 응답 모델링
public sealed interface ApiResult<T>
    permits ApiResult.Ok, ApiResult.Error {

    record Ok<T>(T data) implements ApiResult<T> {}
    record Error<T>(int code, String message) implements ApiResult<T> {}
}

// 사용하는 쪽
public String toMessage(ApiResult<?> result) {
    return switch (result) {
        case ApiResult.Ok<?> ok -> "성공: " + ok.data();
        case ApiResult.Error<?> err -> "에러 %d: %s".formatted(err.code(), err.message());
    };
}

// sealed + record로 커맨드 정의
public sealed interface Command
    permits CreateUser, DeleteUser, UpdateEmail {}

public record CreateUser(String name, String email) implements Command {}
public record DeleteUser(long userId) implements Command {}
public record UpdateEmail(long userId, String newEmail) implements Command {}

// 핸들러 — 새 커맨드 추가 시 컴파일 에러로 누락 방지
public void handle(Command cmd) {
    switch (cmd) {
        case CreateUser c -> userService.create(c.name(), c.email());
        case DeleteUser d -> userService.delete(d.userId());
        case UpdateEmail u -> userService.updateEmail(u.userId(), u.newEmail());
    }
}

var list = List.of("A", "B", "C");
list.getFirst();   // A
list.getLast();    // C
list.reversed();   // [C, B, A] — 역순 뷰 (복사 아님)

try { parseJson(input); }
catch (JsonException _) { return fallback; }  // 예외 객체 안 씀

map.forEach((_, value) -> process(value));     // 키 안 씀