지역 클래스와 변수 캡처

앞 글의 마지막 예제에서 메서드 안에 선언한 지역 클래스(local class) LineFormatter는 메서드의 매개변수 prefix, title, viewCount를 그대로 읽었습니다. 이처럼 지역 클래스가 자신을 감싼 메서드의 변수를 가져다 쓰는 것을 캡처(capture)라고 합니다. 그 예제에서는 객체를 만들자마자 같은 메서드 안에서 썼으니 별로 이상할 것이 없었습니다.

그런데 지역 클래스의 객체를 메서드 밖으로 돌려주면 이야기가 달라집니다. JVM 메모리 구조에서 본 것처럼 매개변수와 지역 변수는 메서드가 끝나면 스택 프레임과 함께 사라지지만, 객체는 힙에 남아 계속 쓰일 수 있습니다. 그렇다면 메서드가 끝난 뒤에 그 객체는 이미 사라진 변수를 어떻게 읽을까요? 또 캡처한 변수에 나중에 다른 값을 대입하면 객체는 어느 값을 보게 될까요? 이 글에서는 두 질문의 답을 따라가며, 자바가 캡처를 '값의 복사'로 처리하고 그래서 변수의 재대입을 막는다는 것을 확인합니다.

메서드가 끝난 뒤에도 남는 캡처 값

다음 createPrinter는 지역 클래스 LocalPrinter의 객체를 만들어 돌려주는 팩터리 메서드입니다. LocalPrinter는 메서드의 매개변수 prefix, viewCount와 지역 변수 separator를 캡처합니다.

public final class CapturedPostPrinter {
    public static void main(String[] args) {
        Printer printer = createPrinter("daily", 40);
        System.out.println("factory-finished");
        printer.print("local class");
    }

    private static Printer createPrinter(String prefix, int viewCount) {
        String separator = ":";

        class LocalPrinter implements Printer {
            @Override
            public void print(String title) {
                System.out.println(prefix + separator + title + "=" + viewCount);
            }
        }

        return new LocalPrinter();
    }

    private interface Printer {
        void print(String title);
    }
}

factory-finished
daily:local class=40

LocalPrinter라는 이름은 createPrinter 안에서만 쓸 수 있습니다. 그래서 createPrinter는 객체를 인터페이스 타입 Printer로 돌려주고, main도 Printer 변수로 받습니다. 지역 클래스의 객체를 메서드 밖에서 쓰려면 이렇게 바깥에서도 보이는 인터페이스나 부모 클래스를 구현하게 해야 합니다.

출력 순서를 보세요. factory-finished가 먼저 나왔다는 것은 print를 호출하기 전에 createPrinter가 이미 끝났다는 뜻입니다. 그런데도 둘째 줄에는 createPrinter의 매개변수였던 daily와 40, 지역 변수였던 :가 모두 들어 있습니다. 호출할 때 넘긴 것은 title인 "local class"뿐인데 말입니다. print가 사라진 스택 변수를 다시 찾아간 것은 아닙니다. LocalPrinter 객체가 만들어질 때 필요한 값을 자기 안에 복사해 두었기 때문입니다.

스택에서 사라지는 변수, 힙에 남는 객체

메모리에서 무슨 일이 일어나는지 시점별로 따라가 보겠습니다. createPrinter의 매개변수와 지역 변수는 그 호출의 스택 프레임에 있고, new LocalPrinter()로 만든 객체는 힙에 있습니다.

표에서 보듯 객체가 실제로 읽는 것은 처음부터 끝까지 자기 안의 복사본입니다. 메서드가 끝나면 원래 변수는 없어지므로, 객체가 메서드보다 오래 살 수 있으려면 값을 복사해 두는 수밖에 없습니다. 지역 변수의 수명이 객체와 함께 늘어난 것처럼 보이지만, 정확히는 수명이 늘어난 것이 아니라 값이 객체로 옮겨 간 것입니다.

더 깊이: 컴파일러가 만드는 복사본 필드

이 복사는 앞 글에서 본 바깥 참조 필드처럼 javac가 숨은 필드로 구현합니다. 위 예제를 컴파일하면 지역 클래스는 CapturedPostPrinter$1LocalPrinter.class라는 파일이 되는데, javap -p로 들여다보면 소스에 없던 필드 세 개가 보입니다.

  final java.lang.String val$prefix;
  final java.lang.String val$separator;
  final int val$viewCount;

javac는 캡처한 변수마다 final 필드를 하나씩 만들고, new LocalPrinter()를 호출할 때 세 값을 생성자로 넘겨 이 필드에 저장합니다. print 안의 prefix는 실제로는 val$prefix 필드를 읽는 코드로 컴파일됩니다. 다만 필드 이름과 배치는 컴파일러가 정하는 구현 방식일 뿐이니 코드가 여기에 기대서는 안 됩니다. 언어가 정한 것은 '지역 클래스는 캡처한 변수의 값을 쓴다'는 규칙까지입니다.

캡처한 변수는 다시 대입할 수 없다

값을 복사해 둔다면 곤란한 경우가 하나 생깁니다. 객체를 만든 뒤에 원래 변수에 다른 값을 대입하면 원래 변수와 복사본이 서로 달라집니다. 다음 코드는 Printer가 prefix를 캡처한 뒤 prefix를 바꾸려고 합니다.

public final class CapturedLocalMutationFailure {
    public static void main(String[] args) {
        String prefix = "board";

        class Printer {
            void print() {
                System.out.println(prefix);
            }
        }

        prefix = "changed";
        new Printer().print();
    }
}

lab/CapturedLocalMutationFailure.java:7: error: local variables referenced from an inner class must be final or effectively final
                System.out.println(prefix);
                                   ^
1 error

오류는 대입한 줄이 아니라 지역 클래스가 prefix를 읽는 7번 줄에 표시됩니다. 만약 이 코드가 컴파일된다면 print()는 무엇을 출력해야 할까요? 이 코드에서는 Printer 객체가 prefix = "changed"; 다음에 만들어지므로 changed를 복사하겠지만, 대입이 객체를 만든 뒤에 있었다면 객체는 board를, 변수는 changed를 들고 있게 됩니다. 같은 이름 prefix가 코드의 위치에 따라 다른 값을 뜻하게 되는 것입니다. 자바는 이런 혼란을 아예 만들지 않는 쪽을 택했습니다. 캡처하는 변수는 값이 한 번 정해진 뒤 바뀌지 않아야 한다고 정해 두면, 원래 변수와 복사본은 언제나 같은 값이므로 어느 쪽을 읽든 결과가 같습니다.

오류 메시지는 캡처하는 변수가 final이거나 사실상 final(effectively final)이어야 한다고 말합니다. 사실상 final이란 final을 붙이지는 않았지만 초기화한 뒤 한 번도 다시 대입하지 않은 변수를 말합니다. 앞 글의 LineFormatter가 final을 쓰지 않은 매개변수를 캡처할 수 있었던 것도 그래서입니다. 메시지가 지역 클래스를 'inner class'라고 부르는 것은 중첩 클래스의 종류와 정적 중첩 클래스에서 본 것처럼 언어 명세가 static이 아닌 중첩 클래스를 모두 내부 클래스라고 부르기 때문입니다.

이 규칙은 대입이 어디에 있든 똑같이 적용됩니다. 위 코드에서 prefix = "changed";를 지역 클래스 선언 앞으로 옮겨도, new Printer().print(); 뒤로 옮겨도 같은 오류가 납니다. 컴파일러는 대입이 캡처보다 먼저인지 나중인지 따지지 않고, 그 변수가 사실상 final인지만 봅니다. count++처럼 값을 하나 늘리는 것도 다시 대입하는 것이라서 캡처한 count에는 쓸 수 없습니다. 반대로 String label;처럼 선언만 해 두고 if와 else에서 각각 한 번씩만 대입한 변수는 사실상 final로 인정되어 캡처할 수 있습니다.

Java 7까지는 지역 클래스나 익명 클래스가 캡처할 변수에 반드시 final을 직접 붙여야 했습니다. Java 8부터는 다시 대입하지 않는 변수라면 final을 붙이지 않아도 캡처할 수 있게 되었고, 같은 규칙이 Java 8에 새로 들어온 람다식에도 적용됩니다. 람다식이 캡처한 변수를 다시 대입하면 메시지만 referenced from a lambda expression으로 바뀐 같은 오류가 납니다. 람다의 캡처는 18장의 Runnable을 만드는 세 가지 방법과 람다 캡처와 30장에서 다시 만납니다.

지역 클래스 안에서 바뀌는 값이 필요하다면 지역 변수 대신 지역 클래스 자신의 필드를 쓰면 됩니다. 필드는 객체 안에 하나만 있으니 복사본과 어긋날 일이 없습니다. 실무 코드에서는 int[] count = {0};처럼 길이가 1인 배열을 캡처해 두고 count[0]++로 값을 바꾸는 우회로도 가끔 보입니다. 바뀌는 것은 변수 count가 아니라 그 변수가 가리키는 배열의 칸이라서 컴파일되는데, 그 이유는 뒤에서 참조를 캡처하는 경우를 다룰 때 드러납니다. 다만 바뀌는 상태를 배열 뒤에 숨기는 방식이라 의도가 잘 보이지 않으므로, 가능하면 필드를 쓰는 편이 낫습니다.

더 깊이: 다른 언어는 변수 자체를 캡처한다

JavaScript나 C# 같은 언어의 클로저(closure)는 값이 아니라 변수 자체를 캡처합니다. 그래서 캡처한 뒤에도 변수를 자유롭게 바꿀 수 있고, 바뀐 값이 클로저 안에서도 보입니다. 이를 위해 C# 컴파일러는 캡처한 지역 변수를 힙에 있는 숨은 객체로 옮겨, 메서드와 클로저가 같은 저장 공간을 함께 쓰게 만듭니다.

자바는 이 방식을 택하지 않았습니다. 자바의 지역 변수는 그 메서드를 실행하는 스레드 하나만 쓰므로 여러 스레드가 동시에 건드릴 걱정이 없는데, 변수 자체를 공유하면 이 성질이 깨집니다. 캡처한 객체를 다른 스레드에 넘기는 순간 하나의 지역 변수를 여러 스레드가 읽고 쓰게 되기 때문입니다. JLS의 람다 본문 규칙도 사실상 final 제한이 계속 바뀌는 지역 변수에 접근하는 것을 막고, 그런 캡처가 일으킬 수 있는 동시성 문제를 피하려는 것이라고 이유를 밝힙니다. 바뀌는 상태를 공유해야 한다면 객체의 필드에 담아 공유하라는 것이 자바의 답이고, 그렇게 하면 공유한다는 사실이 코드에 드러납니다.

반복문 안에서 객체마다 다른 값 캡처하기

반복문 안에서 지역 클래스의 객체를 여러 개 만들 때 이 규칙을 자주 만납니다. 다음 코드는 반복마다 번호가 다른 라벨러를 만들어 목록에 넣고, 반복이 모두 끝난 뒤에 차례로 호출합니다.

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

public final class CaptureSnapshotFactory {
    public static void main(String[] args) {
        List<Labeler> labelers = new ArrayList<>();
        for (int index = 0; index < 3; index++) {
            int capturedIndex = index;
            class IndexedLabeler implements Labeler {
                public String label(String title) {
                    return capturedIndex + "=" + title;
                }
            }
            labelers.add(new IndexedLabeler());
        }

        for (Labeler labeler : labelers) {
            System.out.println(labeler.label("capture"));
        }
    }

    private interface Labeler {
        String label(String title);
    }
}

0=capture
1=capture
2=capture

label 안에서 capturedIndex 대신 index를 바로 쓰면 앞에서 본 것과 같은 must be final or effectively final 오류가 납니다. index는 index++로 매 반복 다시 대입되므로 사실상 final이 아니기 때문입니다. 그래서 반복문 본문 안에 capturedIndex를 따로 선언하고 그 반복의 index 값을 담았습니다. 본문 안에서 선언한 변수는 반복할 때마다 새로 만들어지는 별개의 변수이고, 어느 반복에서도 다시 대입되지 않으므로 사실상 final입니다.

출력을 보면 세 객체가 각자 0, 1, 2를 기억하고 있습니다. 각 IndexedLabeler는 만들어질 때 그 반복의 capturedIndex 값을 복사해 두었으므로, 반복문이 끝난 뒤에 호출해도 서로 다른 번호를 냅니다. 참고로 for (String title : titles) 같은 향상된 for문의 반복 변수는 반복마다 새로 선언되는 것으로 취급되어, 본문에서 다시 대입하지만 않으면 따로 복사하지 않고 바로 캡처할 수 있습니다.

바깥 객체의 필드는 복사하지 않고 읽는다

지역 변수와 달리 필드는 사실상 final이 아니어도 지역 클래스 안에서 쓸 수 있습니다. 인스턴스 메서드 안에서 선언한 지역 클래스는 앞 글의 내부 클래스처럼 바깥 객체에 연결되기 때문입니다. 다음 예제에서 ProgressReporter는 매개변수 targetCount와 바깥 객체의 필드 publishedCount를 함께 출력합니다.

public final class OuterFieldAndLocalCapture {
    private int publishedCount = 10;

    public static void main(String[] args) {
        OuterFieldAndLocalCapture tracker = new OuterFieldAndLocalCapture();
        Reporter reporter = tracker.createReporter(100);

        tracker.publishedCount = 40;
        reporter.print();
    }

    private Reporter createReporter(int targetCount) {
        class ProgressReporter implements Reporter {
            public void print() {
                System.out.println("progress=" + publishedCount + "/" + targetCount);
            }
        }
        return new ProgressReporter();
    }

    private interface Reporter {
        void print();
    }
}

progress=40/100

reporter를 만들 때 publishedCount는 10이었지만, 출력에는 그 뒤에 바꾼 40이 나왔습니다. 반면 100은 createReporter(100)을 호출할 때 캡처한 값 그대로입니다. 두 값은 읽는 방식이 다릅니다. targetCount는 지역 변수이므로 객체가 만들어질 때 값이 복사되었고, publishedCount는 복사된 것이 아니라 객체가 기억하는 바깥 객체 tracker를 통해 print()를 호출하는 순간에 읽습니다. 힙에 있는 tracker의 필드는 하나뿐이므로 지금 값인 40이 보입니다.

필드에 사실상 final 규칙이 적용되지 않는 이유도 여기서 나옵니다. 필드는 복사본이 따로 생기지 않으니, 원래 값과 복사본이 어긋나는 문제가 처음부터 없습니다. 지역 클래스가 static 메서드 안에 있다면 연결된 바깥 객체가 없으므로 바깥 클래스의 인스턴스 필드는 쓸 수 없습니다.

0=capture
1=capture
2=capture

0=capture
1=capture
2=capture

그런데 출력 한 줄 안에 '객체를 만든 시점의 목표'와 '출력하는 시점의 게시 수'가 섞여 있다는 점은 짚어 볼 만합니다. 목표가 나중에 바뀌는 프로그램이라면 이 출력은 어느 시점의 진행률도 정확히 나타내지 못합니다. 모든 값이 같은 시점의 것이어야 한다면, 출력에 쓸 값을 한 시점에 모두 읽어 바꿀 수 없는 값 객체로 만든 뒤 넘기는 편이 안전합니다.

참조를 캡처하면 객체는 함께 쓴다

캡처한 지역 변수가 객체를 가리키는 참조 변수라면, 복사되는 것은 참조값입니다. 객체 자체가 복사되는 것은 아닙니다. 다음 코드는 태그 목록을 캡처한 뒤 원래 목록에 태그를 하나 더 넣습니다.

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

public final class CapturedListShared {
    public static void main(String[] args) {
        List<String> tags = new ArrayList<>();
        tags.add("java");

        class SizeReader implements Reader {
            public int size() {
                return tags.size();
            }
        }
        Reader reader = new SizeReader();

        tags.add("nested");
        System.out.println("size=" + reader.size());
    }

    private interface Reader {
        int size();
    }
}

size=2

tags에는 다른 목록을 대입하지 않으므로 사실상 final이고, 컴파일도 됩니다. 하지만 SizeReader가 복사해 둔 것은 목록을 가리키는 참조값이어서, SizeReader와 main은 같은 목록 하나를 함께 씁니다. 그래서 객체를 만든 뒤에 넣은 nested도 보이고 크기는 2가 됩니다. final 참조와 객체 변경에서 본 것처럼, 변수를 다시 대입하지 않는 것과 그 변수가 가리키는 객체가 바뀌지 않는 것은 별개의 이야기입니다.

객체를 만든 시점의 목록 내용을 고정하고 싶다면 List.copyOf(tags)로 복사본을 만들어 그 복사본을 캡처합니다. List.copyOf는 원래 목록과 같은 원소를 담은, 수정할 수 없는 목록을 돌려주며 원래 목록이 나중에 바뀌어도 그 변경을 반영하지 않습니다. 단, 이 복사는 목록의 칸만 복사합니다. 원소가 바꿀 수 있는 객체라면 두 목록이 같은 원소 객체를 가리키므로, 원소의 내용이 바뀌면 복사본에서도 바뀐 내용이 보입니다. List.copyOf의 공식 문서도 수정할 수 없는 목록이 원소의 추가, 삭제, 교체만 막을 뿐 원소 자체를 불변으로 만들지는 않는다고 설명합니다. 원래 목록에 null 원소가 있으면 NullPointerException이 난다는 점도 알아 두세요.

다음 예제는 이 두 가지를 함께 보여 줍니다. StringBuilder는 문자열 서식과 StringBuilder에서 본 것처럼 내용을 바꿀 수 있는 문자열 객체입니다.

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

public final class MutableTagCaptureBoundary {
    public static void main(String[] args) {
        StringBuilder tag = new StringBuilder("java");
        List<StringBuilder> source = new ArrayList<>(List.of(tag));
        Formatter formatter = createFormatter(source);
        tag.append("-changed");
        source.add(new StringBuilder("nested"));
        System.out.println(formatter.format());
        System.out.println("source-size=" + source.size());
    }

    private static Formatter createFormatter(List<StringBuilder> tags) {
        List<StringBuilder> snapshot = List.copyOf(tags);
        String fixedText = snapshot.get(0).toString();
        class TagFormatter implements Formatter {
            public String format() {
                return "members=" + snapshot.size()
                        + ", live=" + snapshot.get(0)
                        + ", fixed=" + fixedText;
            }
        }
        return new TagFormatter();
    }

    private interface Formatter {
        String format();
    }
}

members=1, live=java-changed, fixed=java
source-size=2

List.of(tag)는 tag 하나를 담은 목록을 만들고, new ArrayList<>(...)는 그 원소를 담되 원소를 더 넣을 수 있는 목록을 새로 만듭니다. createFormatter는 이 목록의 복사본 snapshot과, 첫 원소를 그 시점에 문자열로 바꾼 fixedText를 캡처합니다. 그 뒤 main은 tag의 내용에 -changed를 덧붙이고 source에 원소를 하나 더 넣습니다.

출력을 세 부분으로 나눠 읽어 보겠습니다. members=1은 source에 나중에 넣은 nested가 snapshot에 들어오지 않았다는 뜻입니다. 목록의 칸은 복사되었기 때문입니다. live=java-changed는 snapshot의 첫 칸이 source의 첫 칸과 같은 StringBuilder 객체를 가리키고 있어서, 그 객체에 덧붙인 내용이 그대로 보인 것입니다. fixed=java는 fixedText가 toString()을 호출한 시점에 만들어진 별도의 String이기 때문에 나중 변경과 상관없이 java로 남은 것입니다. String은 한 번 만들면 내용을 바꿀 수 없으므로, 이렇게 바꿀 수 없는 값으로 만들어 캡처하면 그 시점의 내용을 확실하게 고정할 수 있습니다.

지역 클래스를 쓸지 판단하기

지역 클래스를 쓸 때는 다음을 먼저 정해 두면 앞에서 본 문제를 피할 수 있습니다.

• 캡처하는 것이 만든 시점에 고정된 값인가, 아니면 다른 코드와 함께 쓰는 바뀌는 객체인가?
• 객체가 메서드 밖으로 반환되어 메서드보다 오래 사는가?
• 큰 객체를 캡처해서 그 객체가 필요 이상으로 오래 메모리에 남지 않는가? 인스턴스 메서드 안의 지역 클래스는 바깥 객체까지 붙잡을 수 있다는 점도 기억하세요.
• 같은 구현을 다른 메서드에서도 쓰게 되지 않는가? 그렇다면 정적 중첩 클래스나 최상위 클래스로 옮길 때입니다.
• 메서드 하나짜리 인터페이스를 구현할 뿐이라면 람다식이 더 간단하지 않은가?

정리하면 이름 있는 지역 클래스는 한 메서드 안에서만 필요한 작은 구현이 메서드를 여러 개 가지거나 자기 상태를 가질 때 잘 맞습니다. 지역 클래스에는 private이나 public 같은 접근 제어자를 붙일 수 없는데, 어차피 그 메서드 밖에서는 이름조차 보이지 않기 때문입니다.

더 깊이: 지역 레코드는 캡처하지 않는다

Java 16부터는 메서드 안에 레코드, enum, 인터페이스도 선언할 수 있습니다. 이들은 지역 클래스와 달리 언제나 암묵적으로 static입니다. 그래서 바깥 객체에 연결되지 않고 메서드의 지역 변수도 캡처할 수 없습니다. 메서드 안의 레코드 본문에서 그 메서드의 지역 변수 prefix를 읽으려 하면 javac는 non-static variable prefix cannot be referenced from a static context라는 오류를 냅니다. 레코드의 상태는 선언에 적은 구성 요소로만 정해져야 하는데, 몰래 캡처한 값이 생기면 그 원칙이 깨지기 때문입니다. 지역 레코드에 필요한 값은 구성 요소로 받아야 합니다.

정리

• 지역 클래스는 자신을 감싼 메서드의 매개변수와 지역 변수를 캡처할 수 있습니다. 캡처한 값은 객체가 만들어질 때 객체 안으로 복사되므로, 메서드가 끝난 뒤에도 쓸 수 있습니다.
• 캡처하는 변수는 final이거나 사실상 final이어야 합니다. 다시 대입할 수 있다면 원래 변수와 복사본이 어긋나기 때문입니다. 대입이 캡처의 앞에 있든 뒤에 있든 똑같이 거부됩니다.
• 반복 변수처럼 바뀌는 값은 반복문 본문 안의 새 변수에 담아서 캡처합니다.
• 바깥 객체의 필드는 복사되지 않고 바깥 객체를 통해 호출 시점에 읽히므로, 사실상 final이 아니어도 되고 최신 값이 보입니다.
• 참조를 캡처하면 객체는 함께 씁니다. 목록의 내용을 고정하려면 List.copyOf 같은 복사본을 캡처하되, 원소가 가변 객체라면 원소의 변경은 막지 못한다는 점에 주의합니다.

연습 문제

1. 가변 태그 목록을 받는 팩터리 메서드 createFormatter를 만드세요. 이 메서드는 받은 목록의 수정할 수 없는 복사본을 만들고, 지역 클래스 TagFormatter가 그 복사본으로 문장을 만들게 합니다. format("capture")는 capture=java,nested처럼 제목 뒤에 태그를 쉼표로 이어 붙인 문자열을 돌려줍니다. 원래 목록은 ["java", "nested"]로 시작하고, 포매터를 만든 뒤 원래 목록에 "changed"를 추가해도 포매터의 결과가 바뀌지 않아야 합니다.
2. 다음 프로그램이 무엇을 출력할지 실행하기 전에 예상하세요. 그다음 views = 5; 바로 아래에 limit = 20;을 추가하면 어떻게 되는지 설명하세요.

public final class CaptureQuiz {
    private int views = 1;

    public static void main(String[] args) {
        CaptureQuiz quiz = new CaptureQuiz();
        Reporter reporter = quiz.create(10);
        quiz.views = 7;
        System.out.println(reporter.report());
    }

    private Reporter create(int limit) {
        String label = "views";
        class ViewReporter implements Reporter {
            public String report() {
                return label + "=" + views + "/" + limit;
            }
        }
        Reporter reporter = new ViewReporter();
        views = 5;
        return reporter;
    }

    private interface Reporter {
        String report();
    }
}

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

public final class LocalTagSnapshotExercise {
    public static void main(String[] args) {
        List<String> source = new ArrayList<>(List.of("java", "nested"));
        Formatter formatter = createFormatter(source);
        source.add("changed");

        System.out.println(formatter.format("capture"));
        System.out.println("source=" + source);
    }

    private static Formatter createFormatter(List<String> tags) {
        List<String> snapshot = List.copyOf(tags);
        class TagFormatter implements Formatter {
            public String format(String title) {
                return title + "=" + String.join(",", snapshot);
            }
        }
        return new TagFormatter();
    }

    private interface Formatter {
        String format(String title);
    }
}

capture=java,nested
source=[java, nested, changed]

source=[java, nested, changed]

capture=java,nested

source=[java, nested, changed]

capture=java,nested

views=7/10

다음 글

익명 클래스로 동작 전달하기에서는 이름 없이 선언과 생성을 한 번에 하는 익명 클래스를 다룹니다. 익명 클래스도 지역 클래스와 같은 방식으로 변수를 캡처하므로, 이 글에서 본 사실상 final 규칙과 바깥 객체 연결이 그대로 적용됩니다.