Vnořená a vnitřní třída Java (s příklady)

V tomto kurzu se na příkladech dozvíte o vnořené třídě v Javě a jejích typech.

V Javě můžete definovat třídu v jiné třídě. Taková třída je známá jako nested class. Například,

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

V Javě můžete vytvořit dva typy vnořených tříd.

  • Nestatická vnořená třída (vnitřní třída)
  • Statická vnořená třída

Doporučená literatura :

  • Modifikátory přístupu Java
  • Statické klíčové slovo Java

Nejprve se podívejme na nestatické vnořené třídy.

Nestatická vnořená třída (vnitřní třída)

Nestatická vnořená třída je třída v jiné třídě. Má přístup k členům obklopující třídy (vnější třídy). To je běžně známé jako inner class.

Vzhledem k tomu, že inner classexistuje ve vnější třídě, musíte nejprve vytvořit instanci vnější třídy, aby se vytvořila instance vnitřní třídy.

Zde je příklad toho, jak můžete deklarovat vnitřní třídy v Javě.

Příklad 1: Vnitřní třída

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

Výstup :

 Mezipaměť procesoru = 4,3 Taktovací frekvence RAM = 5,5

Ve výše uvedeném programu existují dvě vnořené třídy: Procesor a RAM uvnitř vnější třídy: CPU. Můžeme deklarovat vnitřní třídu jako chráněnou. Proto jsme deklarovali třídu RAM jako chráněnou.

Uvnitř hlavní třídy

  • nejprve jsme vytvořili instanci procesoru vnější třídy s názvem cpu.
  • Pomocí instance vnější třídy jsme poté vytvořili objekty vnitřních tříd:
     CPU.Processor processor = cpu.new Processor; CPU.RAM ram = cpu.new RAM();

Poznámka : Pomocí .operátoru dot ( ) vytvoříme instanci vnitřní třídy pomocí vnější třídy.

Přístup k členům vnější třídy v rámci vnitřní třídy

Můžeme přistupovat k členům vnější třídy pomocí tohoto klíčového slova. Pokud se chcete dozvědět více o tomto klíčovém slovu, navštivte Java toto klíčové slovo.

Příklad 2: Přístup k členům

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

Výstup :

 Typ motoru pro 8WD = Větší typ motoru pro 4WD = Menší

Ve výše uvedeném programu máme vnitřní třídu s názvem Engine uvnitř vnější třídy Car. Tady si všimněte řádku

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

Používáme thisklíčové slovo pro přístup k proměnné carType vnější třídy. Možná jste si všimli, že místo použití this.carTypejsme použili Car.this.carType.

Je to proto, že pokud jsme nezmínili název vnější třídy Car, pak thisklíčové slovo bude představovat člena uvnitř vnitřní třídy.

Podobně také přistupujeme k metodě vnější třídy z vnitřní třídy.

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

Je důležité si uvědomit, že i když se getCarName()jedná o privatemetodu, jsme k ní schopni přistupovat z vnitřní třídy.

Statická vnořená třída

V Javě můžeme také definovat statictřídu uvnitř jiné třídy. Taková třída je známá jako static nested class. Statické vnořené třídy se nenazývají statické vnitřní třídy.

Na rozdíl od vnitřní třídy nemůže statická vnořená třída přistupovat k proměnným členů vnější třídy. Je to proto, že statická vnořená třída nevyžaduje, abyste vytvořili instanci vnější třídy.

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

Tady vytváříme objekt statické vnořené třídy jednoduše pomocí názvu třídy vnější třídy. Na vnější třídu tedy nelze odkazovat pomocí OuterClass.this.

Příklad 3: Statická vnitřní třída

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

Výstup :

 Celkový počet portů = 3

Ve výše uvedeném programu jsme uvnitř třídy MotherBoard vytvořili statickou třídu s názvem USB. Všimněte si řádku,

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

Tady vytváříme objekt USB pomocí názvu vnější třídy.

Nyní se podívejme, co by se stalo, kdybyste se pokusili získat přístup ke členům vnější třídy:

Příklad 4: Přístup k členům vnější třídy uvnitř statické vnitřní třídy

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

Při pokusu o spuštění programu se zobrazí chyba:

 chyba: nestatická proměnná, na kterou nelze odkazovat ze statického kontextu

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.
  • Nestatické vnořené třídy (vnitřní třídy) mají přístup k ostatním členům vnější / obklopující třídy, i když jsou prohlášeny za soukromé.

Zajímavé články...