Java Academy · Pelajaran

Class Dalam dan Akses ke Class Luar

Gunakan class dalam nonstatis yang menyimpan referensi ke instans class luar.

Class Dalam dan Akses ke Class Luar adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 2 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 Inner

Kelas inner nonstatis menyimpan referensi implisit ke instance kelas luar yang membungkusnya. Kelas ini dapat mengakses semua anggota kelas luar, termasuk anggota privat.

Mendeklarasikan dan Menggunakan Kelas Inner

Buat instance kelas inner hanya melalui instance kelas luar menggunakan outer.new InnerClass().

class BankAccount {
    private double balance;
    private String owner;

    BankAccount(String owner, double initial) {
        this.owner = owner; this.balance = initial;
    }

    class Transaction {
        void deposit(double amount) {
            balance += amount; // accesses outer field directly
            System.out.println(owner + " deposited " + amount);
        }
    }
}

BankAccount acct = new BankAccount("Alice", 500);
BankAccount.Transaction tx = acct.new Transaction();
tx.deposit(100); // Alice deposited 100.0

Mengakses Anggota Kelas Luar

Kelas inner dapat mengakses semua anggota kelas luar — bahkan field dan metode privat.

class Encryption {
    private final String secretKey = "s3cr3t"; // private!

    class Encryptor {
        String encrypt(String data) {
            // Inner class accesses private outer field
            return data + "|" + secretKey.hashCode();
        }
    }

    class Decryptor {
        String decrypt(String encrypted) {
            int idx = encrypted.lastIndexOf('|');
            return encrypted.substring(0, idx);
        }
    }
}

Penyamaran Nama dengan this

Jika kelas inner memiliki field dengan nama yang sama seperti kelas luar, gunakan OuterClass.this.field untuk merujuk ke field milik kelas luar.

class Outer {
    int value = 10;

    class Inner {
        int value = 20; // shadows outer.value

        void printBoth() {
            System.out.println("Inner value: " + value);         // 20
            System.out.println("Outer value: " + Outer.this.value); // 10
        }
    }
}

new Outer().new Inner().printBoth();
// Inner value: 20
// Outer value: 10

Pola Iterator dengan Kelas Inner

Salah satu penggunaan klasiknya adalah mengimplementasikan iterator sebagai kelas inner yang mengakses data privat koleksi yang membungkusnya.

class NumberRange implements Iterable<Integer> {
    private final int start;
    private final int end;

    NumberRange(int start, int end) {
        this.start = start; this.end = end;
    }

    @Override
    public java.util.Iterator<Integer> iterator() {
        return new RangeIterator(); // inner class instance
    }

    private class RangeIterator implements java.util.Iterator<Integer> {
        private int current = start; // accesses outer start

        public boolean hasNext() { return current <= end; }
        public Integer next()    { return current++; }
    }
}

for (int n : new NumberRange(1, 5)) System.out.print(n + " ");
// 1 2 3 4 5

Listener Peristiwa sebagai Kelas Inner

Pemrograman GUI dan berbasis peristiwa biasanya menggunakan kelas inner untuk mengimplementasikan listener peristiwa yang dapat mengakses state komponen antarmuka pengguna yang membungkusnya.

// Swing-style example (conceptual)
class LoginPanel {
    private String username = "";

    class LoginButtonListener {
        void onButtonClicked() {
            if (username.isEmpty()) {
                System.out.println("Please enter username"); // accesses outer field
            } else {
                System.out.println("Logging in as: " + username);
            }
        }
    }

    void setUsername(String name) { this.username = name; }
}
LoginPanel panel = new LoginPanel();
panel.setUsername("alice");
panel.new LoginButtonListener().onButtonClicked();
// Logging in as: alice

Kelas Inner dalam Koleksi

Beberapa implementasi koleksi menggunakan kelas inner untuk menyimpan kursor atau tampilan yang didukung oleh koleksi yang membungkusnya.

class SimpleStack<T> {
    private Object[] elements;
    private int size = 0;

    SimpleStack(int capacity) {
        elements = new Object[capacity];
    }

    void push(T item) {
        if (size >= elements.length) throw new StackOverflowError();
        elements[size++] = item;
    }

    T pop() {
        if (size == 0) throw new java.util.EmptyStackException();
        T item = (T) elements[--size];
        elements[size] = null;
        return item;
    }

    int size() { return size; }
}

Peringatan Kebocoran Memori

Instance kelas inner menyimpan referensi ke instance luar. Jika kelas inner keluar dari kelas luar (misalnya disimpan dalam koleksi yang berumur panjang), instance luar tidak dapat dibersihkan oleh pengumpul sampah.

// Memory leak: anonymous inner class (implicit outer ref) stored statically
class LeakExample {
    byte[] data = new byte[1024 * 1024]; // 1MB

    // BAD: this Runnable holds a reference to LeakExample.this
    Runnable leak = new Runnable() {
        public void run() { System.out.println(data.length); }
    };
}
// If 'leak' is stored somewhere, LeakExample (and its 1MB) is never GC'd

// FIX: use a static nested class or a lambda that captures only needed values
static Runnable noLeak(byte[] data) {
    return () -> System.out.println(data.length); // captures array, not outer
}

Membandingkan Kelas Inner dan Lambda

Lambda Java modern sering menggantikan kelas inner anonim untuk antarmuka dengan satu metode. Lambda lebih ringkas, tetapi TIDAK memiliki this sendiri.

// Old way: anonymous inner class
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running (inner class) — this is the Runnable");
    }
};

// Modern: lambda
Runnable r2 = () -> System.out.println("Running (lambda)");

r1.run();
r2.run();

// Lambda this = enclosing class (not the Runnable)
// Inner class this = the Runnable instance itself

Kapan Menggunakan Kelas Inner

Gunakan kelas inner nonstatis jika:

Kelas tersebut perlu mengakses state privat instance yang membungkusnya
Setiap instance inner secara logis terikat pada instance luar tertentu
Pola Iterator digunakan untuk merangkum logika traversal

Praktik: Paginator

Paginator praktis dengan kelas dalam yang menyimpan status halaman dan mengakses daftar data luar.

import java.util.*;

class Paginator<T> {
    private final List<T> items;
    private final int pageSize;

    Paginator(List<T> items, int pageSize) {
        this.items = items; this.pageSize = pageSize;
    }

    class Page {
        private int pageIndex = 0;

        List<T> current() {
            int start = pageIndex * pageSize;
            int end = Math.min(start + pageSize, items.size()); // outer
            return start < items.size() ? items.subList(start, end) : List.of();
        }
        boolean hasNext() { return (pageIndex + 1) * pageSize < items.size(); }
        void next() { if (hasNext()) pageIndex++; }
    }
}
Paginator<String> p = new Paginator<>(List.of("a","b","c","d","e"), 2);
Paginator.Page page = p.new Page();
System.out.println(page.current()); // [a, b]
page.next();
System.out.println(page.current()); // [c, d]

Pemeriksaan Singkat

Apa yang disimpan oleh kelas dalam (nonstatis) yang tidak disimpan oleh kelas bersarang statis?

Ringkasan: Kelas Dalam dan Akses ke Kelas Luar

Inti pembelajaran:

Kelas dalam nonstatis menyimpan referensi implisit ke instans kelas luar yang membungkusnya
Buat instans kelas dalam hanya melalui instans kelas luar: outer.new Inner()
Kelas dalam dapat mengakses semua anggota kelas luar, termasuk bidang privat
Gunakan Outer.this.field untuk membedakan bidang yang namanya tertutupi
Kasus penggunaan terbaik: Iterator, listener peristiwa, dan struktur data dalam
Risiko: instans kelas dalam mencegah instans kelas luar dikumpulkan oleh pengumpul sampah

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Class Dalam dan Akses ke Class Luar” gratis?

Ya — teks lengkap “Class Dalam dan Akses ke Class Luar” 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 Dalam dan Akses ke Class Luar”?

Gunakan class dalam nonstatis yang menyimpan referensi ke instans class luar. 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 2 dari 4.

Berapa lama pelajaran “Class Dalam dan Akses ke Class Luar” 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