자바 final : 사용 이유·변수·메서드·주의점

final int MAX_SIZE = 100;
MAX_SIZE = 200; // 컴파일 에러: cannot assign a value to final variable

final 키워드 적용 위치와 효과:

┌─────────────────────────────────────────────────────┐
│  적용 위치    │  효과              │  핵심 목적        │
├─────────────────────────────────────────────────────┤
│  변수(필드,   │  재할당 금지       │  불변 값 보장     │
│  지역변수,    │  (참조 고정,       │  상수 선언        │
│  매개변수)    │  객체 내용은 별개) │                   │
├─────────────────────────────────────────────────────┤
│  메서드       │  오버라이딩 금지   │  핵심 로직 보호   │
│               │                    │  템플릿 메서드    │
├─────────────────────────────────────────────────────┤
│  클래스       │  상속(extends) 금지│  불변 클래스 설계 │
│               │                    │  보안·무결성 보장 │
└─────────────────────────────────────────────────────┘

public class Circle {

    // final 인스턴스 필드는 세 가지 방법 중 하나로 반드시 초기화
    private final double radius;        // 방법 ①: 선언 시 초기화 (아래 참고)
    private final String color = "RED"; // 방법 ②: 선언과 동시에 초기화

    // 방법 ①: 생성자에서 초기화 (가장 권장되는 방식)
    public Circle(double radius) {
        this.radius = radius; // 생성자에서 단 한 번만 할당 가능
    }

    // 이후 어떤 메서드에서도 radius 재할당 불가
    public void resize(double newRadius) {
        // this.radius = newRadius; // ❌ 컴파일 에러
    }

    public double getArea() {
        return Math.PI * radius * radius; // 읽기는 항상 가능
    }
}

public class MathUtils {

    // static final: 클래스 로딩 시 단 한 번 초기화되는 상수
    public static final double PI        = 3.141592653589793;
    public static final int    MAX_RETRY = 3;
    public static final String APP_NAME  = "MyService";

    // 잘못된 예: 상수인데 소문자로 쓰는 것은 관례 위반
    // public static final int maxSize = 100; // ❌ 관례 위반

    // 올바른 예
    public static final int MAX_SIZE = 100; // ✅
}

// 사용: 클래스명.상수명 (new 없이 직접 접근)
double circumference = 2 * MathUtils.PI * radius;

public class FinalLocalDemo {

    // ① final 매개변수: 메서드 내에서 재할당 불가
    public double calculateArea(final double radius) {
        // radius = -1; // ❌ 컴파일 에러
        return Math.PI * radius * radius;
    }

    public void demo() {
        // ② final 지역 변수: 선언 후 한 번만 할당 가능
        final int MAX = 10;
        // MAX = 20; // ❌ 컴파일 에러

        // ③ 선언과 초기화를 분리할 수 있음 (단, 사용 전 반드시 초기화)
        final String message;
        if (MAX > 5) {
            message = "크다";
        } else {
            message = "작다";
        }
        // 이 시점부터 message 재할당 불가
        System.out.println(message); // ✅ 사용 가능
    }
}

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

public class FinalReferenceDemo {

    public static void main(String[] args) {

        final List<String> list = new ArrayList<>();

        // ✅ 리스트 내용 변경은 가능 (final은 참조만 고정)
        list.add("첫 번째");
        list.add("두 번째");
        list.remove(0);
        System.out.println(list); // [두 번째]

        // ❌ 재할당은 불가 (final이 막는 것은 참조 변경)
        // list = new ArrayList<>(); // 컴파일 에러

        // 같은 원리: final 인스턴스도 내부 상태 변경 가능
        final StringBuilder sb = new StringBuilder("Hello");
        sb.append(", World"); // ✅ 내용 변경 가능
        // sb = new StringBuilder(); // ❌ 재할당 불가
    }
}

final의 범위:

final List<String> list = new ArrayList<>();
         ↑
  이 화살표(참조)만 고정
  list가 가리키는 ArrayList 객체 자체는 자유롭게 수정 가능

진정한 불변 컬렉션을 원한다면:
  List.of(...)         // Java 9+, 불변 리스트
  Collections.unmodifiableList(list)  // 불변 래퍼
  List.copyOf(list)    // Java 10+, 불변 복사본

public class Payment {

    private String orderId;
    private double amount;

    public Payment(String orderId, double amount) {
        this.orderId = orderId;
        this.amount  = amount;
    }

    // final 메서드: 하위 클래스에서 오버라이딩 불가
    public final double getAmount() {
        return amount;
    }

    // final 메서드: 결제 검증 로직은 절대 변경 불가
    public final boolean validate() {
        return orderId != null && !orderId.isBlank() && amount > 0;
    }

    // 일반 메서드: 하위 클래스에서 오버라이딩 가능
    public String getDescription() {
        return "주문 " + orderId + ": " + amount + "원";
    }
}

public class CardPayment extends Payment {

    public CardPayment(String orderId, double amount) {
        super(orderId, amount);
    }

    // ❌ 컴파일 에러: getAmount()는 final이므로 오버라이딩 불가
    // @Override
    // public double getAmount() { return super.getAmount() * 0.95; }

    // ✅ 일반 메서드는 오버라이딩 가능
    @Override
    public String getDescription() {
        return "[카드결제] " + super.getDescription();
    }
}

public abstract class DataExporter {

    // 전체 흐름은 final로 고정 (템플릿 메서드)
    public final void export(String destination) {
        List<Object> data = fetchData();    // 공통 단계
        validate(data);                     // 공통 단계
        String formatted = format(data);    // 하위 클래스 구현
        write(formatted, destination);      // 하위 클래스 구현
        log(destination);                   // 공통 단계
        System.out.println("내보내기 완료: " + destination);
    }

    // 공통 로직은 직접 구현 (final은 아니어도 됨)
    protected List<Object> fetchData() {
        // DB 조회 로직 (공통)
        return new ArrayList<>();
    }

    protected void validate(List<Object> data) {
        if (data == null) throw new IllegalArgumentException("데이터 없음");
    }

    protected void log(String destination) {
        System.out.println("로그: " + destination + " 내보내기");
    }

    // 하위 클래스가 반드시 구현해야 하는 단계 (추상 메서드)
    protected abstract String format(List<Object> data);
    protected abstract void   write(String content, String destination);
}

// CSV 형식으로 내보내는 구체 클래스
public class CsvExporter extends DataExporter {

    @Override
    protected String format(List<Object> data) {
        return data.stream()
                   .map(Object::toString)
                   .collect(Collectors.joining(","));
    }

    @Override
    protected void write(String content, String destination) {
        // CSV 파일로 저장 로직
        System.out.println("CSV 저장: " + destination);
    }

    // export() 메서드 자체는 final이므로 오버라이딩 불가
    // 전체 흐름(fetchData → validate → format → write → log)은 보장됨
}

public class Parent {
    // private 메서드는 암묵적으로 final
    // 하위 클래스에서 '같은 이름'의 메서드를 만들어도
    // 오버라이딩이 아닌 '새로운 메서드 정의'임
    private void helper() {
        System.out.println("부모 helper");
    }

    public void execute() {
        helper(); // 항상 이 메서드 호출
    }
}

public class Child extends Parent {
    // 이것은 오버라이딩이 아님! 새로운 메서드 정의
    private void helper() {
        System.out.println("자식 helper");
    }
}

// Child c = new Child();
// c.execute(); → "부모 helper" 출력 (자식의 helper가 아님!)

// final 클래스 선언
public final class SocialSecurityNumber {
    private final String value;

    public SocialSecurityNumber(String value) {
        validate(value);
        this.value = value;
    }

    private void validate(String value) {
        if (value == null || value.length() != 14) {
            throw new IllegalArgumentException("유효하지 않은 주민등록번호 형식");
        }
    }

    public String getMasked() {
        return value.substring(0, 6) + "-*******";
    }
}

// ❌ 컴파일 에러: SocialSecurityNumber는 final 클래스
// public class HackedSSN extends SocialSecurityNumber {
//     @Override
//     public String getMasked() {
//         return value; // 마스킹 우회 시도 → 차단됨
//     }
// }

// JDK 내부 선언 (개념적 표현)
public final class String implements Serializable, Comparable<String>, CharSequence {
    private final char[] value; // (Java 9+에서는 byte[])
    // ...
}

// 마찬가지로 래퍼 클래스들도 final
public final class Integer extends Number implements Comparable<Integer> { }
public final class Long    extends Number implements Comparable<Long>    { }
public final class Double  extends Number implements Comparable<Double>  { }

// 완전한 불변 클래스 설계 예시
public final class Money {                          // ① 클래스에 final

    private final long amount;                      // ② 모든 필드에 final
    private final String currency;                  // ② 모든 필드에 final

    // ③ setter 없음, 상태 변경 메서드 없음
    private Money(long amount, String currency) {   // ④ 생성자는 private
        if (amount < 0) {
            throw new IllegalArgumentException("금액은 0 이상: " + amount);
        }
        this.amount   = amount;
        this.currency = currency;
    }

    // ④ static 팩토리 메서드로 생성 (생성자 대신)
    public static Money of(long amount, String currency) {
        return new Money(amount, currency);
    }

    public static Money zero(String currency) {
        return new Money(0, currency);
    }

    // 상태를 바꾸는 대신 새 객체를 반환 (함수형 방식)
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("통화 불일치");
        }
        return new Money(this.amount + other.amount, this.currency); // 새 객체 반환
    }

    public Money multiply(int factor) {
        return new Money(this.amount * factor, this.currency); // 새 객체 반환
    }

    // getter만 제공 (setter 없음)
    public long   getAmount()   { return amount; }
    public String getCurrency() { return currency; }

    // ⑤ 가변 객체를 필드로 가질 경우 방어적 복사 필수
    //    (여기서는 long, String 모두 불변이므로 불필요)

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Money)) return false;
        Money money = (Money) o;
        return amount == money.amount && currency.equals(money.currency);
    }

    @Override
    public int hashCode() {
        return Objects.hash(amount, currency);
    }

    @Override
    public String toString() {
        return amount + " " + currency;
    }
}

불변 클래스 설계 5원칙 요약:

① final 클래스 선언 (상속 차단)
② 모든 필드를 private final로 선언
③ setter 및 상태 변경 메서드 제거
④ 생성자를 private으로 + static 팩토리 메서드 사용
⑤ 가변 객체 필드가 있다면 방어적 복사 적용

public class EffectivelyFinalDemo {

    public static void main(String[] args) {

        // ① 명시적 final: final 키워드 선언
        final String greeting = "안녕하세요";

        // ② effectively final: final 없지만 값이 변경되지 않음
        String name = "홍길동"; // 이후 name이 변경되지 않으면 effectively final

        // 람다는 외부 변수를 캡처(capture)할 때 반드시 final 또는 effectively final이어야 함
        Runnable r = () -> {
            System.out.println(greeting + ", " + name); // ✅ 모두 사용 가능
        };

        r.run(); // 안녕하세요, 홍길동

        // ③ effectively final 조건 위반 예시
        String city = "서울";
        city = "부산"; // 값 변경 → effectively final 아님

        Runnable r2 = () -> {
            // System.out.println(city); // ❌ 컴파일 에러
            // Variable used in lambda expression should be final or effectively final
        };
    }
}

람다가 외부 변수를 캡처하는 방식:

  외부 메서드의 Stack 영역
  ┌──────────────┐
  │  String name │ ← 지역 변수는 Stack에 존재
  │  = "홍길동"  │   메서드 종료 시 사라짐
  └──────────────┘
          │
          │ 람다가 캡처 (복사)
          ↓
  람다 객체 (Heap 영역)
  ┌──────────────────┐
  │  captured: "홍길동" │ ← 람다 객체 안에 값 복사본 저장
  └──────────────────┘

  메서드가 종료되어 Stack이 사라져도
  람다 객체는 Heap에 남아 캡처된 값을 사용

  만약 name이 변경 가능하다면:
  Stack의 name과 람다가 캡처한 복사본이
  서로 다른 값을 갖게 되는 불일치 발생
  → 이를 방지하기 위해 final/effectively final만 허용

// 실전에서 자주 보이는 effectively final 패턴
public List<String> filterByPrefix(List<String> items, String prefix) {
    // prefix는 이 메서드 내에서 변경되지 않음 → effectively final
    return items.stream()
                .filter(item -> item.startsWith(prefix)) // prefix 캡처 가능
                .collect(Collectors.toList());
}

// effectively final 위반으로 인한 우회 패턴 (안티패턴)
public void badExample() {
    int[] counter = {0}; // int 대신 배열로 우회 (권장하지 않음)
    List.of("a", "b", "c").forEach(item -> {
        counter[0]++; // 배열 참조는 final, 내용 변경은 가능
    });
    // 하지만 이 패턴은 AtomicInteger를 사용하는 것이 올바른 대안
}

// 올바른 대안: AtomicInteger
public void goodExample() {
    AtomicInteger counter = new AtomicInteger(0); // effectively final (참조 고정)
    List.of("a", "b", "c").forEach(item -> {
        counter.incrementAndGet(); // ✅ 원자적 연산으로 값 변경
    });
    System.out.println(counter.get()); // 3
}

// Java 7 방식: 명시적 final 필요
public void java7Style(final String message) {
    Runnable r = new Runnable() {
        @Override
        public void run() {
            System.out.println(message); // final 명시 필요
        }
    };
    r.run();
}

// Java 8+ 방식: effectively final로 충분
public void java8Style(String message) { // final 생략 가능
    Runnable r = () -> System.out.println(message); // effectively final
    r.run();
}

@Service
public class OrderService {

    // ① 생성자 주입 + final 조합: 스프링 공식 권장 방식
    private final OrderRepository orderRepository;
    private final PaymentService  paymentService;
    private final EventPublisher  eventPublisher;

    // ② Lombok @RequiredArgsConstructor로 자동 생성 가능
    public OrderService(
            OrderRepository orderRepository,
            PaymentService paymentService,
            EventPublisher eventPublisher) {
        this.orderRepository = orderRepository;
        this.paymentService  = paymentService;
        this.eventPublisher  = eventPublisher;
    }

    public OrderResult placeOrder(OrderRequest request) {
        // orderRepository, paymentService, eventPublisher는
        // 이 서비스의 생애 전체에서 절대 바뀌지 않음이 보장됨
        Order order = orderRepository.save(new Order(request));
        paymentService.charge(order);
        eventPublisher.publish(new OrderPlacedEvent(order));
        return OrderResult.success(order);
    }
}

public final class BadExample {
    public int count = 0;  // ← final 클래스지만 필드는 변경 가능
    // 이 객체는 불변이 아님! 상속만 불가능한 것
}

// 문제: final 클래스는 기본 Mockito로 Mock 불가
public final class ExternalApiClient { ... }

// 해결책 1: final 제거 + 인터페이스 추출
public interface ApiClient { ... }
public class ExternalApiClient implements ApiClient { ... }

// 해결책 2: Mockito 2.x+ inline mock 설정
// src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
// mock-maker-inline

public final class Config implements Serializable {
    private final String value;

    public Config(String value) {
        this.value = value;
    }
    // 역직렬화 시 readObject()를 통해 final 필드에 값이 할당됨
    // 이 과정에서 리플렉션이 사용되며, 악의적 역직렬화 공격 가능성 있음
    // → 직렬화가 필요한 불변 클래스는 readResolve() 구현을 고려
}

final 변수: 거의 항상 붙이는 것이 좋음
  ✅ 필드: 생성자에서 초기화 후 변경 없으면 반드시 final
  ✅ 상수: static final 조합 항상 사용
  ✅ 의도 표현: 변경 없는 지역 변수에 붙여 가독성 향상
  ⚠️ 컬렉션: final만으로는 내용 불변이 안 됨 → 불변 래퍼 병행

final 메서드: 신중하게 사용
  ✅ 보안·무결성 핵심 로직
  ✅ 템플릿 메서드 패턴의 골격 메서드
  ❌ 단순히 "변경하지 말라"는 의도만이면 문서화가 더 나음

final 클래스: 명확한 목적이 있을 때만
  ✅ 불변 값 객체 (Money, PhoneNumber 등)
  ✅ 보안·무결성이 핵심인 클래스
  ❌ 확장 가능성이 필요한 유틸리티·서비스 클래스
  ❌ 테스트에서 Mock이 필요한 클래스