Java Academy · Pelajaran

Class Bersarang Statis

Definisikan class bersarang statis sebagai tipe pembantu terkait tanpa referensi ke instans class pembungkus.

Class Bersarang Statis adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 1 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 Tersarang Statis

Kelas tersarang statis didefinisikan di dalam kelas lain menggunakan kata kunci static. Kelas ini tidak memiliki referensi ke instance kelas yang membungkusnya — kelas ini hanya dikelompokkan secara logis bersamanya.

Mendeklarasikan Kelas Tersarang Statis

Gunakan nama kelas luar untuk mengakses kelas tersarang dari luar.

class LinkedList<T> {
    private Node<T> head;

    // Static nested class — no outer instance reference
    private static class Node<T> {
        T data;
        Node<T> next;
        Node(T data) { this.data = data; }
    }

    public void addFirst(T item) {
        Node<T> node = new Node<>(item);
        node.next = head;
        head = node;
    }
}

Mengakses dari Luar

Referensikan kelas tersarang statis publik sebagai OuterClass.InnerClass.

class Builder {
    public static class Config {
        public final String host;
        public final int port;
        Config(String host, int port) {
            this.host = host; this.port = port;
        }
    }
}

Builder.Config config = new Builder.Config("localhost", 8080);
System.out.println(config.host + ":" + config.port); // localhost:8080

Kelas Tersarang Statis vs Inner

Perbedaan utamanya: kelas tersarang statis TIDAK memiliki referensi implisit ke instance outer. Kelas Inner (nonstatis) MEMILIKI referensi tersebut.

class Outer {
    private int x = 10;

    // Static nested: no access to x
    static class StaticNested {
        void doSomething() {
            // System.out.println(x); // compile error — no outer reference!
            System.out.println("Static nested");
        }
    }

    // Inner class: has access to x
    class Inner {
        void doSomething() {
            System.out.println(x); // 10 — can access outer fields
        }
    }
}

Pola Builder dengan Kelas Tersarang Statis

Pola Builder klasik menggunakan kelas tersarang statis sehingga pemanggil tidak memerlukan instance luar untuk membuat Builder.

class Pizza {
    private final String size, crust;
    private final List<String> toppings;

    private Pizza(Builder b) {
        this.size = b.size; this.crust = b.crust; this.toppings = List.copyOf(b.toppings);
    }

    public static class Builder {
        private String size = "medium", crust = "thin";
        private List<String> toppings = new ArrayList<>();
        public Builder size(String s)    { this.size = s; return this; }
        public Builder crust(String c)   { this.crust = c; return this; }
        public Builder topping(String t) { this.toppings.add(t); return this; }
        public Pizza build()             { return new Pizza(this); }
    }
}

Entri dalam Map

Map.Entry adalah antarmuka tersarang statis yang terkenal dan digunakan untuk melakukan iterasi pada pasangan kunci-nilai.

import java.util.*;

Map<String, Integer> scores = Map.of("Alice", 95, "Bob", 87, "Carol", 92);

for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    System.out.printf("%-10s: %d%n", entry.getKey(), entry.getValue());
}

// Modern: using var
for (var entry : scores.entrySet()) {
    System.out.println(entry.getKey() + " -> " + entry.getValue());
}

Pengujian dengan Kelas Tersarang Statis

Dalam pengujian unit, kelas tersarang statis dapat menyimpan perlengkapan pengujian atau implementasi tiruan yang cakupannya terbatas pada kelas pengujian.

class UserServiceTest {
    // Static nested fake/stub — no outer instance needed
    static class FakeUserRepository implements UserRepository {
        private final Map<Long, User> store = new HashMap<>();

        public void save(User u) { store.put(u.id(), u); }

        public Optional<User> findById(long id) {
            return Optional.ofNullable(store.get(id));
        }
    }

    // @Test methods use FakeUserRepository
    void testFindUser() {
        FakeUserRepository repo = new FakeUserRepository();
        // ...
    }
}

Kelas Tersarang Statis untuk Logika Domain

Kelompokkan tipe yang saling terkait menggunakan kelas tersarang statis agar pengorganisasian dalam model domain menjadi lebih baik.

class Order {
    private final long id;
    private final List<LineItem> items;

    // Static nested — logically belongs to Order, no outer reference needed
    public static class LineItem {
        public final String sku;
        public final int quantity;
        public final double unitPrice;

        public LineItem(String sku, int qty, double price) {
            this.sku = sku; this.quantity = qty; this.unitPrice = price;
        }

        public double total() { return quantity * unitPrice; }
    }

    // ...
}

Perbandingan: Kelas Tersarang Statis vs Tingkat Teratas

Lebih baik gunakan kelas tersarang statis jika sebuah kelas hanya digunakan dalam konteks kelas luar. Gunakan kelas tingkat teratas jika kelas tersebut memiliki penerapan yang lebih luas.

Kelas Tersarang Statis dengan Generik

Kelas tersarang statis berpartisipasi dalam generik sama seperti kelas tingkat teratas.

class Pair<A, B> {
    // Static nested with its own type params
    public static class Mutable<X, Y> {
        public X first;
        public Y second;
        public Mutable(X first, Y second) {
            this.first = first; this.second = second;
        }
    }

    public static <X, Y> Mutable<X, Y> mutableOf(X x, Y y) {
        return new Mutable<>(x, y);
    }
}
Pair.Mutable<String, Integer> p = Pair.mutableOf("Alice", 30);
System.out.println(p.first + " is " + p.second); // Alice is 30

Efisiensi Memori

Kelas tersarang statis tidak menyimpan referensi ke instance luar. Hal ini mencegah objek luar tertahan secara tidak sengaja di memori, yang dapat menyebabkan kebocoran memori pada struktur yang berumur panjang.

Pemeriksaan Singkat

Apa yang membedakan kelas tersarang statis dari kelas inner (nonstatis)?

Ringkasan: Kelas Tersarang Statis

Hal-hal penting:

Kelas tersarang statis dikelompokkan bersama kelas luar, tetapi tidak memiliki referensi ke instance luar
Akses dari luar: OuterClass.NestedClass
Tidak adanya referensi implisit berarti tidak ada penahanan instance luar di memori secara tidak sengaja
Pola Builder biasanya menggunakan kelas Builder yang tersarang statis
Map.Entry adalah antarmuka tersarang statis yang terkenal
Lebih baik gunakan kelas tersarang statis jika kelas inner tidak memerlukan akses ke instance luar

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Class Bersarang Statis” gratis?

Ya — teks lengkap “Class Bersarang Statis” 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 Bersarang Statis”?

Definisikan class bersarang statis sebagai tipe pembantu terkait tanpa referensi ke instans class pembungkus. 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 1 dari 4.

Berapa lama pelajaran “Class Bersarang Statis” 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