Java annidato e classe interna (con esempi)

In questo tutorial imparerai a conoscere la classe nidificata in Java e i suoi tipi con l'aiuto di esempi.

In Java, puoi definire una classe all'interno di un'altra classe. Tale classe è nota come nested class. Per esempio,

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

Esistono due tipi di classi nidificate che puoi creare in Java.

  • Classe nidificata non statica (classe interna)
  • Classe annidata statica

Lettura consigliata :

  • Modificatori di accesso Java
  • Parola chiave statica Java

Diamo prima un'occhiata alle classi nidificate non statiche.

Classe annidata non statica (classe interna)

Una classe nidificata non statica è una classe all'interno di un'altra classe. Ha accesso ai membri della classe che la racchiude (classe esterna). È comunemente noto come inner class.

Poiché inner classesiste all'interno della classe esterna, è necessario istanziare prima la classe esterna, al fine di istanziare la classe interna.

Ecco un esempio di come puoi dichiarare classi interne in Java.

Esempio 1: classe interna

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

Uscita :

 Cache processore = 4,3 Velocità RAM Clock = 5,5

Nel programma sopra, ci sono due classi nidificate: Processore e RAM all'interno della classe esterna: CPU. Possiamo dichiarare la classe interna protetta. Quindi, abbiamo dichiarato la classe RAM come protetta.

All'interno della classe principale,

  • abbiamo prima creato un'istanza di una CPU di classe esterna denominata cpu.
  • Utilizzando l'istanza della classe esterna, abbiamo quindi creato gli oggetti delle classi interne:
     CPU.Processor processor = cpu.new Processor; CPU.RAM ram = cpu.new RAM();

Nota : utilizziamo l' .operatore punto ( ) per creare un'istanza della classe interna utilizzando la classe esterna.

Accesso ai membri della classe esterna all'interno della classe interna

Possiamo accedere ai membri della classe esterna utilizzando questa parola chiave. Se vuoi conoscere questa parola chiave, visita Java questa parola chiave.

Esempio 2: accesso ai membri

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

Uscita :

 Tipo di motore per 8WD = Tipo di motore più grande per 4WD = Più piccolo

Nel programma precedente, abbiamo la classe interna denominata Engine all'interno della classe esterna Car. Qui, nota la linea,

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

Stiamo usando la thisparola chiave per accedere alla variabile carType della classe esterna. Avrai notato che invece di usare this.carTypeabbiamo usato Car.this.carType.

È perché se non avessimo menzionato il nome della classe esterna Car, la thisparola chiave rappresenterà il membro all'interno della classe interna.

Allo stesso modo, stiamo anche accedendo al metodo della classe esterna dalla classe interna.

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

È importante notare che, sebbene getCarName()sia un privatemetodo, siamo in grado di accedervi dalla classe interna.

Classe annidata statica

In Java, possiamo anche definire una staticclasse all'interno di un'altra classe. Tale classe è nota come static nested class. Le classi nidificate statiche non sono chiamate classi interne statiche.

A differenza della classe interna, una classe annidata statica non può accedere alle variabili membro della classe esterna. È perché la classe annidata statica non richiede la creazione di un'istanza della classe esterna.

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

Qui, stiamo creando un oggetto della classe annidata statica semplicemente utilizzando il nome della classe della classe esterna. Pertanto, non è possibile fare riferimento alla classe esterna utilizzando OuterClass.this.

Esempio 3: classe interna statica

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

Uscita :

 Porte totali = 3

Nel programma precedente, abbiamo creato una classe statica chiamata USB all'interno della classe MotherBoard. Notare la linea,

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

Qui stiamo creando un oggetto USB utilizzando il nome della classe esterna.

Ora, vediamo cosa succederebbe se provassi ad accedere ai membri della classe esterna:

Esempio 4: accesso ai membri della classe Outer all'interno di Static Inner Class

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

Quando proviamo a eseguire il programma, otterremo un errore:

 errore: variabile non statica a cui non è possibile fare riferimento da un contesto statico

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.
  • Le classi nidificate non statiche (classi interne) hanno accesso ad altri membri della classe esterna / inclusiva, anche se dichiarate private.

Articoli interessanti...