Java geneste en innerlijke klasse
Java genest en innerlijke klasse
In deze zelfstudie leert u met behulp van voorbeelden over de geneste klasse in Java en zijn typen.
In Java kun je 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 (binnenste klasse)
- Statische geneste klasse
Aanbevolen lectuur :
- Java-toegangsmodificaties
- Java statisch zoekwoord
Laten we eerst kijken naar niet-statische geneste klassen.
Niet-statische geneste klasse (Inner Class)
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 .
Sinds de inner class bestaat binnen de buitenste klasse, moet u eerst de buitenste klasse instantiëren om de binnenste klasse te instantiëren.
Hier is een voorbeeld van hoe je 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());
}
} Uitvoer :
Processor Cache = 4.3 Ram Clock speed = 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.
In de hoofdklasse,
- we hebben eerst een instantie gemaakt van een outer class CPU genaamd 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 punt (. ) operator 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 sleutelwoord te gebruiken. Als u meer wilt weten over dit trefwoord, gaat u naar Java this keyword.
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());
}
} Uitvoer :
Engine Type for 8WD= Bigger Engine Type for 4WD = Smaller
In het bovenstaande programma hebben we de innerlijke klasse genaamd Engine binnen de buitenste klasse Auto . Hier, let op de lijn,
if(Car.this.carType.equals("4WD")) {...}
We gebruiken this trefwoord om toegang te krijgen tot het carType variabele van de buitenklasse. Je hebt misschien gemerkt dat in plaats van this.carType we hebben Car.this.carType gebruikt .
Het is omdat als we de naam van de buitenste klasse niet hadden genoemd Auto , dan this trefwoord vertegenwoordigt het lid binnen de innerlijke klasse.
Op dezelfde manier benaderen we ook de methode van de buitenste klasse vanuit de binnenste klasse.
if (Car.this.getCarName().equals("Crysler") {...}
Het is belangrijk op te merken dat, hoewel de getCarName() is een private methode hebben we er toegang toe vanuit de innerlijke klasse.
Statische geneste klasse
In Java kunnen we ook een static . definiëren klas binnen een andere klas. Een dergelijke klasse staat bekend als static nested class . Statisch geneste klassen worden geen statische innerlijke klassen genoemd.
In tegenstelling tot de binnenklasse, heeft een statische geneste klasse geen toegang tot de lidvariabelen van de buitenste klasse. Het is omdat de statische geneste klasse vereist niet dat u een instantie van de buitenste klasse maakt.
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());
}
} Uitvoer :
Total Ports = 3
In het bovenstaande programma hebben we een statische klasse gemaakt met de naam USB in de klas MotherBoard . Let op de lijn,
MotherBoard.USB usb = new MotherBoard.USB(); Hier maken we een object van USB 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:
error: non-static variable this cannot be referenced from a static context
Dit komt omdat we het object van de buitenste klasse niet gebruiken om een object van de binnenste klasse te maken. Daarom is er geen verwijzing naar de buitenste klasse Motherboard opgeslagen in Motherboard.this .
Belangrijkste punten om te onthouden
- Java behandelt de innerlijke klas als een gewoon lid van een klas. Ze zijn net als methoden en variabelen die in een klasse worden gedeclareerd.
- Aangezien innerlijke klassen lid zijn van de buitenste klasse, kun je alle toegangsmodifiers toepassen, zoals
private,protectednaar je innerlijke klas wat niet mogelijk is in normale lessen. - Omdat de geneste klasse lid is van de omsluitende buitenste klasse, kun je de punt gebruiken (
.) notatie om toegang te krijgen tot de geneste klasse en zijn leden. - Het gebruik van de geneste klasse maakt je code leesbaarder en zorgt voor een betere inkapseling.
- Niet-statische geneste klassen (binnenklassen) hebben toegang tot andere leden van de buitenste/omsluitende klasse, zelfs als ze privé zijn verklaard.
Java