Java imbricat și clasa interioară (cu exemple)

În acest tutorial, veți afla despre clasa imbricată în Java și tipurile sale cu ajutorul exemplelor.

În Java, puteți defini o clasă în cadrul altei clase. O astfel de clasă este cunoscută sub numele de nested class. De exemplu,

 class OuterClass ( //… class NestedClass ( //… ) )

Există două tipuri de clase imbricate pe care le puteți crea în Java.

  • Clasa imbricată nestatică (clasa interioară)
  • Clasa imbricată static

Citire recomandată :

  • Modificatori de acces Java
  • Cuvânt cheie static Java

Să ne uităm mai întâi la clase imbricate nestatice.

Clasa imbricată nestatică (clasa interioară)

O clasă imbricată nestatică este o clasă din cadrul altei clase. Are acces la membrii clasei de închidere (clasa exterioară). Este cunoscut sub numele de inner class.

Deoarece inner classexistă în cadrul clasei exterioare, trebuie să instanțiați mai întâi clasa exterioară, pentru a instanția clasa interioară.

Iată un exemplu despre cum puteți declara clase interioare în Java.

Exemplul 1: Clasa interioară

 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()); ) )

Ieșire :

 Cache procesor = 4,3 Viteză RAM ceas = 5,5

În programul de mai sus, există două clase imbricate: Procesor și RAM în interiorul clasei exterioare: CPU. Putem declara clasa interioară ca fiind protejată. Prin urmare, am declarat clasa RAM ca fiind protejată.

În clasa principală,

  • am creat mai întâi o instanță a unui procesor de clasă externă numit cpu.
  • Folosind instanța clasei exterioare, am creat apoi obiecte din clasele interioare:
     CPU.Processor processor = cpu.new Processor; CPU.RAM ram = cpu.new RAM();

Notă : Folosim .operatorul dot ( ) pentru a crea o instanță a clasei interioare folosind clasa exterioară.

Accesarea membrilor clasei externe din clasa interioară

Putem accesa membrii clasei exterioare utilizând acest cuvânt cheie. Dacă doriți să aflați despre acest cuvânt cheie, vizitați Java acest cuvânt cheie.

Exemplul 2: accesarea membrilor

 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()); ) )

Ieșire :

 Tipul motorului pentru 8WD = Mai mare tip de motor pentru 4WD = Mai mic

În programul de mai sus, avem clasa interioară numită Motor în clasa exterioară Car. Aici, observați linia,

 if(Car.this.carType.equals("4WD")) (… )

Folosim thiscuvinte cheie pentru a accesa variabila carType din clasa exterioară. Este posibil să fi observat că, în loc să folosim, this.carTypeam folosit Car.this.carType.

Acest lucru se datorează faptului că dacă nu am fi menționat numele clasei exterioare Car, atunci thiscuvântul cheie va reprezenta membrul din clasa interioară.

În mod similar, accesăm și metoda clasei exterioare din clasa interioară.

 if (Car.this.getCarName().equals("Crysler") (… )

Este important de reținut că, deși getCarName()este o privatemetodă, suntem capabili să o accesăm din clasa interioară.

Clasa imbricată static

În Java, putem defini și o staticclasă în interiorul altei clase. O astfel de clasă este cunoscută sub numele de static nested class. Clasele statice imbricate nu se numesc clase interioare statice.

Spre deosebire de clasa interioară, o clasă statică imbricată nu poate accesa variabilele membre ale clasei exterioare. Acest lucru se datorează faptului că clasa statică imbricată nu necesită crearea unei instanțe a clasei exterioare.

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

Aici, creăm un obiect al clasei statice imbricate utilizând pur și simplu numele clasei clasei exterioare. Prin urmare, nu se poate face referire la clasa exterioară folosind OuterClass.this.

Exemplul 3: Clasa interioară statică

 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()); ) )

Ieșire :

 Total porturi = 3

În programul de mai sus, am creat o clasă statică numită USB în cadrul clasei MotherBoard. Observați linia,

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

Aici, creăm un obiect USB folosind numele clasei exterioare.

Acum, să vedem ce s-ar întâmpla dacă încercați să accesați membrii clasei exterioare:

Exemplul 4: Accesarea membrilor clasei externe din cadrul clasei interioare statice

 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()); ) )

Când încercăm să rulăm programul, vom primi o eroare:

 eroare: variabilă nestatică, aceasta nu poate fi menționată dintr-un context static

This is because we are not using the object of the outer class to create an object of the inner class. Hence, there is no reference to the outer class Motherboard stored in Motherboard.this.

Key Points to Remember

  • Java treats the inner class as a regular member of a class. They are just like methods and variables declared inside a class.
  • Since inner classes are members of the outer class, you can apply any access modifiers like private, protected to your inner class which is not possible in normal classes.
  • Since the nested class is a member of its enclosing outer class, you can use the dot (.) notation to access the nested class and its members.
  • Using the nested class will make your code more readable and provide better encapsulation.
  • Clasele nestatice nestatice (clasele interioare) au acces la alți membri ai clasei externe / de închidere, chiar dacă sunt declarate private.

Articole interesante...