Java ligzdotā un iekšējā klase (ar piemēriem)

Šajā apmācībā jūs uzzināsit par Java ligzdoto klasi un tās tipiem, izmantojot piemērus.

Java valodā jūs varat definēt klasi citas klases ietvaros. Šāda klase ir pazīstama kā nested class. Piemēram,

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

Java var izveidot divu veidu ligzdotas klases.

  • Nestatiska ligzdota klase (iekšējā klase)
  • Statiskā ligzdotā klase

Ieteicamā literatūra :

  • Java piekļuves modifikatori
  • Java statiskais atslēgvārds

Vispirms aplūkosim nestatiskās ligzdotās klases.

Nestatiska ligzdota klase (iekšējā klase)

Nestatiska ligzdota klase ir klase citā klasē. Tam ir piekļuve norobežojošās klases (ārējās klases) dalībniekiem. Tas ir plaši pazīstams kā inner class.

Tā kā tā inner classpastāv ārējā klasē, jums vispirms jāpiedalās ārējai klasei, lai iekšējā klase kļūtu aktuālāka.

Šis ir piemērs tam, kā jūs varat deklarēt Java iekšējās klases.

1. piemērs: iekšējā klase

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

Izeja :

 Procesora kešatmiņa = 4,3 RAM pulksteņa ātrums = 5,5

Iepriekš minētajā programmā ir divas ligzdotas klases: Procesors un RAM ārējā klasē: CPU. Mēs varam pasludināt iekšējo klasi par aizsargātu. Tādējādi mēs esam paziņojuši, ka RAM klase ir aizsargāta.

Galvenās klases iekšpusē,

  • Vispirms mēs izveidojām ārējās klases CPU instanci ar nosaukumu CPU.
  • Izmantojot ārējās klases gadījumu, mēs izveidojām iekšējo klašu objektus:
     CPU.Processor processor = cpu.new Processor; CPU.RAM ram = cpu.new RAM();

Piezīme . Mēs izmantojam .operatoru dot ( ), lai izveidotu iekšējās klases instanci, izmantojot ārējo klasi.

Piekļuve iekšējās klases ārējās klases dalībniekiem

Izmantojot šo atslēgvārdu, mēs varam piekļūt ārējās klases dalībniekiem. Ja vēlaties uzzināt par šo atslēgvārdu, apmeklējiet Java šo atslēgvārdu.

2. piemērs: Piekļuve dalībniekiem

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

Izeja :

 Dzinēja tips 8WD = lielāks motora tips 4WD = mazāks

Iepriekš minētajā programmā mums ir iekšējā klase ar nosaukumu Dzinējs ārējās klases automašīnas iekšpusē. Lūk, pamaniet līniju,

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

Mēs izmantojam thisatslēgvārdu, lai piekļūtu ārējās klases mainīgajam carType. Jūs, iespējams, pamanījāt, ka tā vietā, lai izmantotu, this.carTypemēs esam izmantojuši Car.this.carType.

Tas ir tāpēc, ka, ja mēs nebūtu minējuši ārējās klases automašīnas nosaukumu, tad thisatslēgvārds pārstāvēs locekli iekšējās klases iekšienē.

Līdzīgi mēs arī piekļūstam ārējās klases metodei no iekšējās klases.

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

Ir svarīgi atzīmēt, ka, lai arī šī getCarName()ir privatemetode, mēs spējam tai piekļūt no iekšējās klases.

Statiskā ligzdotā klase

Java valodā mēs varam definēt staticklasi arī citas klases iekšienē. Šāda klase ir pazīstama kā static nested class. Statiskās ligzdotās klases netiek sauktas par statiskām iekšējām klasēm.

Atšķirībā no iekšējās klases, statiskā ligzdotā klase nevar piekļūt ārējās klases dalībnieku mainīgajiem. Tas ir tāpēc, ka statiskā ligzdotā klase neprasa, lai jūs izveidotu ārējās klases instanci.

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

Šeit mēs izveidojam statiskās ligzdotās klases objektu, vienkārši izmantojot ārējās klases klases nosaukumu. Tādējādi uz ārējo klasi nevar atsaukties, izmantojot OuterClass.this.

3. piemērs: Statiskā iekšējā klase

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

Izeja :

 Kopējais ostu skaits = 3

Iepriekš minētajā programmā mēs esam izveidojuši statisko klasi ar nosaukumu USB, kas ir Motherboard. Ievērojiet līniju,

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

Šeit mēs izveidojam USB objektu, izmantojot ārējās klases nosaukumu.

Apskatīsim, kas notiktu, ja mēģinātu piekļūt ārējās klases dalībniekiem:

4. piemērs: piekļuve ārējās klases dalībniekiem statiskajā iekšējā klasē

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

Mēģinot palaist programmu, tiks parādīta kļūda:

 kļūda: nestatisks mainīgais uz to nevar atsaukties no statiskā konteksta

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.
  • Nestatiskām ligzdotām klasēm (iekšējām klasēm) ir piekļuve citiem ārējās / norobežojošās klases dalībniekiem, pat ja viņi ir pasludināti par privātiem.

Interesanti raksti...