Java Nested dan Kelas Dalam

Dalam tutorial ini, Anda akan belajar tentang kelas bersarang di Java dan jenisnya dengan bantuan contoh.

Di Java, Anda dapat mendefinisikan kelas di dalam kelas lain. Kelas tersebut dikenal sebagai nested class . Misalnya,

class OuterClass {
    // ...
    class NestedClass {
        // ...
    }
}

Ada dua jenis kelas bersarang yang dapat Anda buat di Java.

Kelas bersarang non-statis (kelas dalam)
Kelas bertingkat statis

Bacaan yang disarankan :

Pengubah Akses Java
Kata Kunci Statis Java

Pertama-tama mari kita lihat kelas bersarang non-statis.

Kelas Bersarang Non-Statis (Kelas Dalam)

Kelas bersarang non-statis adalah kelas di dalam kelas lain. Ini memiliki akses ke anggota kelas terlampir (kelas luar). Biasanya dikenal sebagai inner class .

Sejak inner class ada di dalam kelas luar, Anda harus membuat instance kelas luar terlebih dahulu, untuk membuat instance kelas dalam.

Berikut adalah contoh bagaimana Anda dapat mendeklarasikan kelas dalam di Java.

Contoh 1:Kelas dalam

class CPU {
    double price;
    // nested class
    class Processor{

        // members of nested class
        double cores;
        String manufacturer;

        double getCache(){
            return 4.3;
        }
    }

    // nested protected class
    protected class RAM{

        // members of protected nested class
        double memory;
        String manufacturer;

        double getClockSpeed(){
            return 5.5;
        }
    }
}

public class Main {
    public static void main(String[] args) {

        // create object of Outer class CPU
        CPU cpu = new CPU();

       // create an object of inner class Processor using outer class
        CPU.Processor processor = cpu.new Processor();

        // create an object of inner class RAM using outer class CPU
        CPU.RAM ram = cpu.new RAM();
        System.out.println("Processor Cache = " + processor.getCache());
        System.out.println("Ram Clock speed = " + ram.getClockSpeed());
    }
}

Keluaran :

Processor Cache = 4.3
Ram Clock speed = 5.5

Dalam program di atas, ada dua kelas bersarang:Processor dan RAM di dalam kelas luar:CPU . Kita dapat mendeklarasikan inner class sebagai protected. Oleh karena itu, kami telah mendeklarasikan kelas RAM sebagai protected.

Di dalam kelas Utama,

pertama kali kita membuat instance dari kelas luar CPU bernama cpu .

Menggunakan instance kelas luar, kita kemudian membuat objek kelas dalam:

CPU.Processor processor = cpu.new Processor;

CPU.RAM ram = cpu.new RAM();

Catatan :Kami menggunakan titik (. ) operator untuk membuat instance kelas dalam menggunakan kelas luar.

Mengakses Anggota Kelas Luar dalam Kelas Dalam

Kita dapat mengakses anggota kelas luar dengan menggunakan kata kunci ini. Jika Anda ingin mempelajari tentang kata kunci ini, kunjungi Java kata kunci ini.

Contoh 2:Mengakses Anggota

class Car {
    String carName;
    String carType;

    // assign values using constructor
    public Car(String name, String type) {
        this.carName = name;
        this.carType = type;
    }

    // private method
    private String getCarName() {
        return this.carName;
    }

// inner class
    class Engine {
        String engineType;
        void setEngine() {

           // Accessing the carType property of Car
            if(Car.this.carType.equals("4WD")){

                // Invoking method getCarName() of Car
                if(Car.this.getCarName().equals("Crysler")) {
                    this.engineType = "Smaller";
                } else {
                    this.engineType = "Bigger";
                }

            }else{
                this.engineType = "Bigger";
            }
        }
        String getEngineType(){
            return this.engineType;
        }
    }
}

public class Main {
    public static void main(String[] args) {

// create an object of the outer class Car
        Car car1 = new Car("Mazda", "8WD");

        // create an object of inner class using the outer class
        Car.Engine engine = car1.new Engine();
        engine.setEngine();
        System.out.println("Engine Type for 8WD= " + engine.getEngineType());

        Car car2 = new Car("Crysler", "4WD");
        Car.Engine c2engine = car2.new Engine();
        c2engine.setEngine();
        System.out.println("Engine Type for 4WD = " + c2engine.getEngineType());
    }
}

Keluaran :

Engine Type for 8WD= Bigger
Engine Type for 4WD = Smaller

Dalam program di atas, kita memiliki kelas dalam bernama Engine di dalam kelas luar Mobil . Di sini, perhatikan barisnya,

if(Car.this.carType.equals("4WD")) {...}

Kami menggunakan this kata kunci untuk mengakses carType variabel dari kelas luar. Anda mungkin telah memperhatikan bahwa alih-alih menggunakan this.carType kami telah menggunakan Car.this.carType .

Itu karena jika kita tidak menyebutkan nama kelas luar Mobil , lalu this kata kunci akan mewakili anggota di dalam kelas dalam.

Demikian pula, kami juga mengakses metode kelas luar dari kelas dalam.

if (Car.this.getCarName().equals("Crysler") {...}

Penting untuk dicatat bahwa, meskipun getCarName() adalah private metode, kami dapat mengaksesnya dari kelas dalam.

Kelas Bersarang Statis

Di Java, kita juga dapat mendefinisikan static kelas di dalam kelas lain. Kelas tersebut dikenal sebagai static nested class . Kelas bersarang statis tidak disebut kelas dalam statis.

Tidak seperti kelas dalam, kelas bersarang statis tidak dapat mengakses variabel anggota kelas luar. Ini karena kelas bertingkat statis tidak mengharuskan Anda membuat instance kelas luar.

OuterClass.NestedClass obj = new OuterClass.NestedClass();

Di sini, kita membuat objek dari kelas bersarang statis dengan hanya menggunakan nama kelas dari kelas luar. Oleh karena itu, kelas luar tidak dapat direferensikan menggunakan OuterClass.this .

Contoh 3:Kelas Dalam Statis

class MotherBoard {

   // static nested class
   static class USB{
       int usb2 = 2;
       int usb3 = 1;
       int getTotalPorts(){
           return usb2 + usb3;
       }
   }

}
public class Main {
   public static void main(String[] args) {

       // create an object of the static nested class
       // using the name of the outer class
       MotherBoard.USB usb = new MotherBoard.USB();
       System.out.println("Total Ports = " + usb.getTotalPorts());
   }
}

Keluaran :

Total Ports = 3

Dalam program di atas, kami telah membuat kelas statis bernama USB di dalam kelas MotherBoard . Perhatikan barisnya,

MotherBoard.USB usb = new MotherBoard.USB();

Di sini, kita membuat objek USB menggunakan nama kelas luar.

Sekarang, mari kita lihat apa yang akan terjadi jika Anda mencoba mengakses anggota kelas luar:

Contoh 4:Mengakses anggota kelas Luar di dalam Kelas Dalam Statis

class MotherBoard {
   String model;
   public MotherBoard(String model) {
       this.model = model;
   }

   // static nested class
   static class USB{
       int usb2 = 2;
       int usb3 = 1;
       int getTotalPorts(){
           // accessing the variable model of the outer classs
           if(MotherBoard.this.model.equals("MSI")) {
               return 4;
           }
           else {
               return usb2 + usb3;
           }
       }
   }
}
public class Main {
   public static void main(String[] args) {

       // create an object of the static nested class
       MotherBoard.USB usb = new MotherBoard.USB();
       System.out.println("Total Ports = " + usb.getTotalPorts());
   }
}

Saat kami mencoba menjalankan program, kami akan mendapatkan kesalahan:

error: non-static variable this cannot be referenced from a static context

Ini karena kita tidak menggunakan objek kelas luar untuk membuat objek kelas dalam. Oleh karena itu, tidak ada referensi ke kelas luar Motherboard disimpan di Motherboard.this .

Poin Penting untuk Diingat

Java memperlakukan kelas dalam sebagai anggota reguler kelas. Mereka seperti metode dan variabel yang dideklarasikan di dalam kelas.
Karena kelas dalam adalah anggota dari kelas luar, Anda dapat menerapkan pengubah akses apa pun seperti private , protected ke kelas batin Anda yang tidak mungkin dilakukan di kelas normal.
Karena kelas bersarang adalah anggota kelas luar terlampir, Anda dapat menggunakan titik (. ) notasi untuk mengakses kelas bersarang dan anggotanya.
Menggunakan kelas bersarang akan membuat kode Anda lebih mudah dibaca dan memberikan enkapsulasi yang lebih baik.
Kelas bersarang non-statis (kelas dalam) memiliki akses ke anggota lain dari kelas luar/penutup, meskipun mereka dinyatakan pribadi.

Enkapsulasi Java Kelas Statis Bersarang Java

java