Java Academy · Pelajaran

Class Lokal dan Anonim

Deklarasikan class di dalam metode dan buat implementasi anonim interface secara langsung.

Class Lokal dan Anonim adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.

Kelas Lokal dan Anonim

Kelas lokal didefinisikan di dalam metode. Kelas anonim adalah kelas lokal tanpa nama—keduanya menggabungkan deklarasi kelas dan pembuatan instans. Keduanya menangkap variabel lokal yang secara efektif final.

Deklarasi Kelas Lokal

Kelas lokal dideklarasikan di dalam isi metode. Kelas ini dapat mengakses anggota kelas yang membungkusnya dan variabel lokal yang secara efektif final.

static void greet(String language) {
    // Local class — defined inside the method
    class Greeter {
        String sayHello(String name) {
            // Can access 'language' — it is effectively final
            return switch (language) {
                case "EN" -> "Hello, " + name;
                case "ES" -> "Hola, " + name;
                case "FR" -> "Bonjour, " + name;
                default   -> "Hi, " + name;
            };
        }
    }

    Greeter g = new Greeter();
    System.out.println(g.sayHello("Alice"));
}
greet("ES"); // Hola, Alice

Variabel yang Secara Efektif Final

Kelas lokal dan anonim hanya dapat menangkap variabel lokal yang secara efektif final—variabel tersebut tidak pernah diberi nilai baru setelah inisialisasi.

void process(int threshold) {
    // threshold is effectively final (never reassigned)
    Runnable r = new Runnable() {
        public void run() {
            System.out.println("Threshold: " + threshold);
        }
    };
    r.run();

    // threshold = 10; // If you add this, the anonymous class won't compile
}

Dasar-Dasar Kelas Anonim

Kelas anonim mengimplementasikan antarmuka atau memperluas kelas secara langsung, dalam satu ekspresi.

interface Comparator<T> {
    int compare(T a, T b);
}

// Anonymous class implementing Comparator
java.util.Comparator<String> byLength = new java.util.Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return Integer.compare(a.length(), b.length());
    }
};

List<String> words = new ArrayList<>(List.of("banana", "fig", "apple", "kiwi"));
words.sort(byLength);
System.out.println(words); // [fig, kiwi, apple, banana]

Kelas Anonim vs Lambda

Untuk antarmuka metode abstrak tunggal (SAM), lambda menggantikan kelas anonim. Kelas anonim tetap diperlukan untuk antarmuka dengan beberapa metode atau saat memperluas kelas abstrak.

// Anonymous class for single-method interface
Runnable r1 = new Runnable() {
    public void run() { System.out.println("Running!"); }
};

// Lambda — cleaner for SAM interfaces
Runnable r2 = () -> System.out.println("Running!");

// Must use anonymous class for multi-method interface:
java.io.FilenameFilter filter = new java.io.FilenameFilter() {
    public boolean accept(java.io.File dir, String name) {
        return name.endsWith(".java");
    }
}; // FilenameFilter is not a SAM — no lambda shorthand

Kelas Anonim dengan Status

Kelas anonim dapat memiliki bidang, tidak seperti lambda. Ini berguna saat Anda perlu mempertahankan status di dalam implementasi anonim.

interface Counter { int increment(); int get(); }

Counter counter = new Counter() {
    private int count = 0;

    public int increment() { return ++count; }
    public int get()       { return count; }
};

System.out.println(counter.increment()); // 1
System.out.println(counter.increment()); // 2
System.out.println(counter.get());       // 2

Pola Listener Anonim

Sebelum lambda digunakan, kelas anonim merupakan pola standar untuk listener peristiwa dalam pemrograman GUI dan Android.

// Modern Android/Swing style: anonymous class listener
Button loginButton = new Button(); // hypothetical
loginButton.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick() {
        System.out.println("Login button clicked!");
    }
});

// Modern equivalent with lambda (if OnClickListener is SAM):
loginButton.setOnClickListener(() -> System.out.println("Clicked!"));

Kelas Lokal untuk Logika Kompleks

Kelas lokal cocok digunakan saat Anda memerlukan kelas dengan beberapa metode hanya di satu tempat—terlalu kompleks untuk lambda, tetapi terlalu spesifik untuk kelas tingkat teratas.

static List<String> processData(List<String> data, String prefix) {
    // Local class: complex enough for a class, used only here
    class DataProcessor {
        List<String> result = new ArrayList<>();

        void process(String item) {
            // prefix is effectively final
            if (item.startsWith(prefix)) {
                result.add(item.toUpperCase());
            }
        }
    }
    DataProcessor dp = new DataProcessor();
    data.forEach(dp::process);
    return dp.result;
}
System.out.println(processData(List.of("apple","avocado","banana"), "a"));
// [APPLE, AVOCADO]

Kelas Anonim untuk Kelas Abstrak

Kelas anonim dapat memperluas kelas abstrak dan menimpa metode abstrak tanpa membuat subkelas bernama.

abstract class ReportFormatter {
    abstract String formatHeader(String title);
    abstract String formatBody(List<String> rows);

    String format(String title, List<String> rows) {
        return formatHeader(title) + "\n" + formatBody(rows);
    }
}

ReportFormatter csvFormatter = new ReportFormatter() {
    public String formatHeader(String t) { return "\"" + t + "\""; }
    public String formatBody(List<String> rows) {
        return String.join("\n", rows);
    }
};
System.out.println(csvFormatter.format("Sales", List.of("a,1","b,2")));

Antipola Inisialisasi Kurung Kurawal Ganda

Trik inisialisasi kurung kurawal ganda menggunakan kelas anonim untuk menginisialisasi koleksi. Trik ini membuat subkelas dengan penginisialisasi instans. Hindari cara ini karena tidak efisien dan rentan menimbulkan galat.

// Anti-pattern: double-brace initialization
Map<String, Integer> map = new HashMap<String, Integer>() {{
    put("a", 1);
    put("b", 2);
}};
// Creates an anonymous HashMap subclass — wasteful!

// GOOD: use Map.of() or Map.ofEntries()
Map<String, Integer> better = Map.of("a", 1, "b", 2);

// Or a mutable map:
Map<String, Integer> mutable = new HashMap<>(Map.of("a", 1, "b", 2));

Memilih: Lambda vs Anonim vs Lokal

Panduan pengambilan keputusan:

Lambda: satu metode abstrak, tanpa status tambahan, tanpa pewarisan
Kelas anonim: beberapa metode, memerlukan status, atau memperluas kelas abstrak
Kelas lokal: perlu digunakan ulang di dalam metode, memiliki beberapa metode, atau memiliki status yang kompleks

Pemeriksaan Singkat

Apa yang selalu dilakukan kelas anonim dalam satu ekspresi?

Ringkasan: Kelas Lokal dan Anonim

Inti pembelajaran:

Kelas lokal didefinisikan di dalam metode dan dapat mengakses variabel lokal yang secara efektif final
Kelas anonim menggabungkan deklarasi kelas dan pembuatan instans dalam satu ekspresi
Kelas anonim dapat memiliki bidang dan beberapa metode—tidak seperti lambda
Lambda menggantikan kelas anonim untuk antarmuka metode abstrak tunggal
Gunakan kelas lokal saat logikanya cukup kompleks untuk sebuah kelas, tetapi hanya berlaku untuk satu metode
Hindari inisialisasi kurung kurawal ganda karena membuat subkelas anonim yang tidak diperlukan

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Class Lokal dan Anonim” gratis?

Ya — teks lengkap “Class Lokal dan Anonim” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Class Lokal dan Anonim”?

Deklarasikan class di dalam metode dan buat implementasi anonim interface secara langsung. Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Java Academy?

Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Class Lokal dan Anonim” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy