In deze tutorial leer je met behulp van voorbeelden over de geneste klasse in Java en zijn typen.
In Java kunt u een klasse binnen een andere klasse definiëren. Een dergelijke klasse staat bekend als nested class. Bijvoorbeeld,
class OuterClass ( //… class NestedClass ( //… ) )
Er zijn twee soorten geneste klassen die u in Java kunt maken.
- Niet-statische geneste klasse (innerlijke klasse)
- Statische geneste klasse
Aanbevolen lectuur :
- Java Access Modifiers
- Java statisch sleutelwoord
Laten we eerst kijken naar niet-statische geneste klassen.
Niet-statische geneste klasse (innerlijke klasse)
Een niet-statische geneste klasse is een klasse binnen een andere klasse. Het heeft toegang tot leden van de omsluitende klasse (buitenste klasse). Het is algemeen bekend als inner class.
Omdat het inner classbestaat binnen de buitenste klasse, moet je eerst de buitenste klasse instantiëren om de innerlijke klasse te instantiëren.
Hier is een voorbeeld van hoe u innerlijke klassen in Java kunt declareren.
Voorbeeld 1: Innerlijke klasse
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()); ) )
Uitgang :
Processor Cache = 4,3 Ram Kloksnelheid = 5,5
In het bovenstaande programma zijn er twee geneste klassen: Processor en RAM binnen de buitenste klasse: CPU. We kunnen de innerlijke klasse als beschermd verklaren. Daarom hebben we de RAM-klasse als beschermd verklaard.
Binnen de hoofdklasse,
- we hebben eerst een instantie gemaakt van een CPU uit de buitenste klasse met de naam cpu.
- Met behulp van de instantie van de buitenste klasse hebben we vervolgens objecten van de binnenste klassen gemaakt:
CPU.Processor processor = cpu.new Processor; CPU.RAM ram = cpu.new RAM();
Opmerking : we gebruiken de .operator dot ( ) om een instantie van de binnenste klasse te maken met behulp van de buitenste klasse.
Toegang tot leden van Outer Class binnen Inner Class
We hebben toegang tot de leden van de buitenste klasse door dit trefwoord te gebruiken. Als u meer wilt weten over dit trefwoord, bezoek dan dit trefwoord in Java.
Voorbeeld 2: Toegang tot leden
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()); ) )
Uitgang :
Motortype voor 8WD = groter Motortype voor 4WD = kleiner
In het bovenstaande programma hebben we de binnenste klasse genaamd Motor in de buitenste klasse Auto. Let hier op de lijn,
if(Car.this.carType.equals("4WD")) (… )
We gebruiken thistrefwoord om toegang te krijgen tot de variabele carType van de buitenste klasse. Je hebt misschien gemerkt dat in plaats van het gebruik van this.carTypehebben we gebruikt Car.this.carType.
Het is omdat als we de naam van de buitenste klasse Auto niet hadden genoemd, het thistrefwoord het lid binnen de binnenste klasse vertegenwoordigt.
Evenzo hebben we ook toegang tot de methode van de buitenste klasse vanuit de binnenste klasse.
if (Car.this.getCarName().equals("Crysler") (… )
Het is belangrijk op te merken dat, hoewel het getCarName()een privatemethode is, we er toegang toe hebben vanuit de innerlijke klasse.
Statische geneste klasse
In Java kunnen we ook een staticklasse binnen een andere klasse definiëren . Een dergelijke klasse staat bekend als static nested class. Statische geneste klassen worden geen statische innerlijke klassen genoemd.
In tegenstelling tot de binnenste klasse heeft een statische geneste klasse geen toegang tot de lidvariabelen van de buitenste klasse. Dit komt doordat u voor de statische geneste klasse geen instantie van de buitenste klasse hoeft te maken.
OuterClass.NestedClass obj = new OuterClass.NestedClass();
Hier maken we een object van de statische geneste klasse door simpelweg de klassenaam van de buitenste klasse te gebruiken. Daarom kan er niet naar de buitenste klasse worden verwezen met OuterClass.this.
Voorbeeld 3: Statische innerlijke klasse
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()); ) )
Uitgang :
Totaal aantal poorten = 3
In het bovenstaande programma hebben we een statische klasse gemaakt met de naam USB in de klasse Moederbord. Let op de lijn,
MotherBoard.USB usb = new MotherBoard.USB();
Hier maken we een USB-object met de naam van de buitenste klasse.
Laten we nu eens kijken wat er zou gebeuren als je probeert toegang te krijgen tot de leden van de buitenste klasse:
Voorbeeld 4: Toegang tot leden van Outer class binnen 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()); ) )
Wanneer we het programma proberen uit te voeren, krijgen we een foutmelding:
fout: niet-statische variabele waarnaar niet kan worden verwezen vanuit een statische context
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,protectedto 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.
- Niet-statische geneste klassen (innerlijke klassen) hebben toegang tot andere leden van de buitenste / omsluitende klasse, zelfs als ze privé zijn verklaard.
