inner, nested, dan anonymous class

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan Java di Coddy. Pelajaran 49 dari 87.

Java memungkinkan kamu mendefinisikan class di dalam class lain. Inner class ini membantu mengatur kode dengan mengelompokkan fungsi yang saling terkait dan dapat mengakses anggota class luar secara langsung.

class dalam bersarang didefinisikan sebagai anggota dari class lain. Class ini memiliki akses ke semua field dan method dari class luar, termasuk yang bersifat private:

class Outer {
    private String message = "Hello";
    
    class Inner {
        void display() {
            System.out.println(message);  // Bisa mengakses field private
        }
    }
}

// Penggunaan
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.display();  // Mencetak: Hello

local inner class didefinisikan di dalam sebuah method. Class ini hanya dapat digunakan di dalam method tersebut dan dapat mengakses variabel lokal yang secara efektif bersifat final:

void process() {
    String prefix = "Result: ";
    
    class LocalHelper {
        void print(int value) {
            System.out.println(prefix + value);
        }
    }
    
    new LocalHelper().print(42);
}

class dalam tanpa nama adalah class tanpa nama yang dibuat dan diinstansiasi dalam satu ekspresi. Biasanya, class ini digunakan untuk mengimplementasikan interface atau memperluas class secara langsung:

Comparator<String> comp = new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
};

Inner class sangat berguna saat sebuah class hanya relevan bagi satu class lain, sehingga kodemu tetap terorganisasi dan terenkapsulasi.

Tantangan

Mudah

Mari buat sistem keranjang belanja yang menampilkan ketiga jenis inner class. Kamu akan membuat ShoppingCart yang menggunakan nested inner class untuk merepresentasikan item, local inner class untuk menghitung diskon, dan anonymous inner class untuk memformat struk akhir.

Kamu akan menyusun kodemu dalam dua file:

ShoppingCart.java: Buat outer class yang mengelola pengalaman berbelanja. ShoppingCart harus memiliki field privat customerName (String).
Di dalam ShoppingCart, definisikan nested inner class bernama Item dengan dua field privat: name (String) dan price (double). Beri Item sebuah konstruktor untuk menginisialisasi kedua field dan method getDetails() yang mengembalikan: [name]: $[price]

ShoppingCart memerlukan konstruktor yang menerima nama pelanggan, serta method bernama checkout() yang menerima sebuah Item dan persentase diskon (double). Di dalam checkout():
1. Buat local inner class bernama DiscountCalculator dengan method applyDiscount(double originalPrice) yang mengembalikan harga setelah persentase diskon diterapkan.
2. Gunakan local class untuk menghitung harga akhir.
3. Buat anonymous inner class yang mengimplementasikan interface Formatter (yang akan kamu definisikan) untuk memformat struk. Anonymous class harus meng-override method format() yang mengembalikan string struk beberapa baris.
Method checkout() harus mengembalikan string struk yang sudah diformat dengan format persis berikut:
```
--- Receipt ---
Customer: [customerName]
Item: [item details from getDetails()]
Discount: [discount]%
Final Price: $[calculated price]
```
Formatter.java: Definisikan interface sederhana dengan satu method: String format(). Interface ini akan diimplementasikan oleh anonymous inner class di dalam method checkout.
Main.java: Hidupkan keranjang belanjamu! Kamu akan menerima tiga input: nama pelanggan (String), nama item (String), dan harga item (double). Persentase diskon ditetapkan sebesar 10.0.
Buat ShoppingCart dengan nama pelanggan. Lalu buat Item menggunakan sintaks referensi outer class: cart.new Item(name, price). Panggil checkout() dengan item dan diskon, lalu cetak struk yang dikembalikan.

Kamu akan menerima tiga input secara berurutan: nama pelanggan, nama item, dan harga item.

Misalnya, jika inputnya adalah Alice, Laptop, dan 1000.0, harga akhirnya setelah diskon 10% adalah 900.0.

Perhatikan bagaimana setiap jenis inner class memiliki tujuan yang berbeda: nested class mengelompokkan data terkait dengan outer class, local class merangkum logika yang hanya diperlukan di dalam satu method, dan anonymous class menyediakan implementasi interface sekali pakai dengan cepat!

Coba sendiri

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Baca input
        String customerName = scanner.nextLine();
        String itemName = scanner.nextLine();
        double itemPrice = scanner.nextDouble();
        
        double discount = 10.0;
        
        // TODO: Buat ShoppingCart dengan nama pelanggan
        
        // TODO: Buat Item menggunakan: cart.new Item(itemName, itemPrice)
        
        // TODO: Panggil checkout() dengan item dan diskon, lalu cetak hasilnya
        
    }
}