Java - Innerlijke klassen
In dit hoofdstuk zullen we innerlijke klassen van Java bespreken.
Geneste klassen
In Java kunnen, net als methoden, variabelen van een klasse ook een andere klasse als lid hebben. Het schrijven van een klasse binnen een andere is toegestaan in Java. De klasse die erin wordt geschreven, wordt de geneste klasse . genoemd , en de klasse die de binnenste klasse bevat, wordt de buitenste klasse . genoemd .
Syntaxis
Hieronder volgt de syntaxis om een geneste klasse te schrijven. Hier, de klas Outer_Demo is de buitenste klasse en de klasse Inner_Demo is de geneste klasse.
class Outer_Demo {
class Inner_Demo {
}
}
Geneste klassen zijn onderverdeeld in twee typen −
-
Niet-statische geneste klassen − Dit zijn de niet-statische leden van een klas.
-
Statische geneste klassen − Dit zijn de statische leden van een klas.
Innerlijke klassen (niet-statische geneste klassen)
Innerlijke klassen zijn een beveiligingsmechanisme in Java. We weten dat een klasse niet kan worden gekoppeld aan de toegangsmodifier private , maar als we de klasse als lid van een andere klasse hebben, kan de innerlijke klasse privé worden gemaakt. En dit wordt ook gebruikt om toegang te krijgen tot de privéleden van een klas.
Er zijn drie soorten innerlijke klassen, afhankelijk van hoe en waar je ze definieert. Ze zijn −
- Innerlijke klasse
- Methode-lokale innerlijke klasse
- Anonieme innerlijke klasse
Innerlijke klasse
Het creëren van een innerlijke klasse is vrij eenvoudig. Je hoeft alleen maar een klas binnen een klas te schrijven. In tegenstelling tot een klasse kan een innerlijke klasse privé zijn en als je een innerlijke klasse eenmaal privé verklaart, is deze niet toegankelijk vanaf een object buiten de klasse.
Hieronder volgt het programma om een innerlijke klasse te creëren en er toegang toe te krijgen. In het gegeven voorbeeld maken we de innerlijke klasse privé en hebben we toegang tot de klasse via een methode.
Voorbeeld
Live demo
class Outer_Demo {
int num;
// inner class
private class Inner_Demo {
public void print() {
System.out.println("This is an inner class");
}
}
// Accessing he inner class from the method within
void display_Inner() {
Inner_Demo inner = new Inner_Demo();
inner.print();
}
}
public class My_class {
public static void main(String args[]) {
// Instantiating the outer class
Outer_Demo outer = new Outer_Demo();
// Accessing the display_Inner() method.
outer.display_Inner();
}
}
Hier kunt u zien dat Outer_Demo is de buitenste klasse, Inner_Demo is de innerlijke klasse, display_Inner() is de methode waarbinnen we de innerlijke klasse instantiëren, en deze methode wordt aangeroepen vanuit de main methode.
Als u het bovenstaande programma compileert en uitvoert, krijgt u het volgende resultaat −
Uitvoer
This is an inner class.
Toegang tot de privéleden
Zoals eerder vermeld, worden interne klassen ook gebruikt om toegang te krijgen tot de privéleden van een klasse. Stel dat een klas privéleden heeft om toegang te krijgen. Schrijf er een inner class in, retourneer de private leden van een methode binnen de inner class, bijvoorbeeld getValue() , en ten slotte vanuit een andere klasse (van waaruit u toegang wilt krijgen tot de privéleden) roept u de methode getValue() van de innerlijke klasse aan.
Om de innerlijke klasse te instantiëren, moet je in eerste instantie de buitenste klasse instantiëren. Daarna, met behulp van het object van de buitenste klasse, volgt de manier waarop u de binnenste klasse kunt instantiëren.
Outer_Demo outer = new Outer_Demo(); Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
Het volgende programma laat zien hoe je toegang krijgt tot de privé-leden van een klas met behulp van inner class.
Voorbeeld
Live demo
class Outer_Demo {
// private variable of the outer class
private int num = 175;
// inner class
public class Inner_Demo {
public int getNum() {
System.out.println("This is the getnum method of the inner class");
return num;
}
}
}
public class My_class2 {
public static void main(String args[]) {
// Instantiating the outer class
Outer_Demo outer = new Outer_Demo();
// Instantiating the inner class
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
System.out.println(inner.getNum());
}
}
Als u het bovenstaande programma compileert en uitvoert, krijgt u het volgende resultaat −
Uitvoer
This is the getnum method of the inner class: 175
Methode-lokale innerlijke klasse
In Java kunnen we een klasse binnen een methode schrijven en dit zal een lokaal type zijn. Net als lokale variabelen is het bereik van de innerlijke klasse beperkt binnen de methode.
Een methode-lokale binnenklasse kan alleen worden geïnstantieerd binnen de methode waar de binnenklasse is gedefinieerd. Het volgende programma laat zien hoe je een methode-lokale innerlijke klasse gebruikt.
Voorbeeld
Live demo
public class Outerclass {
// instance method of the outer class
void my_Method() {
int num = 23;
// method-local inner class
class MethodInner_Demo {
public void print() {
System.out.println("This is method inner class "+num);
}
} // end of inner class
// Accessing the inner class
MethodInner_Demo inner = new MethodInner_Demo();
inner.print();
}
public static void main(String args[]) {
Outerclass outer = new Outerclass();
outer.my_Method();
}
}
Als u het bovenstaande programma compileert en uitvoert, krijgt u het volgende resultaat −
Uitvoer
This is method inner class 23
Anonieme innerlijke klasse
Een inner class gedeclareerd zonder class name staat bekend als een anonieme inner class . In het geval van anonieme innerlijke klassen, declareren en instantiëren we ze tegelijkertijd. Over het algemeen worden ze gebruikt wanneer u de methode van een klasse of een interface moet overschrijven. De syntaxis van een anonieme innerlijke klasse is als volgt −
Syntaxis
AnonymousInner an_inner = new AnonymousInner() {
public void my_method() {
........
........
}
};
Het volgende programma laat zien hoe je de methode van een klasse kunt overschrijven met behulp van anonieme innerlijke klasse.
Voorbeeld
Live demo
abstract class AnonymousInner {
public abstract void mymethod();
}
public class Outer_class {
public static void main(String args[]) {
AnonymousInner inner = new AnonymousInner() {
public void mymethod() {
System.out.println("This is an example of anonymous inner class");
}
};
inner.mymethod();
}
}
Als u het bovenstaande programma compileert en uitvoert, krijgt u het volgende resultaat −
Uitvoer
This is an example of anonymous inner class
Op dezelfde manier kunt u de methoden van de concrete klasse en de interface overschrijven met behulp van een anonieme interne klasse.
Anonieme innerlijke klasse als argument
Als een methode een object van een interface, een abstracte klasse of een concrete klasse accepteert, kunnen we over het algemeen de interface implementeren, de abstracte klasse uitbreiden en het object doorgeven aan de methode. Als het een klasse is, kunnen we deze direct doorgeven aan de methode.
Maar in alle drie de gevallen kun je een anonieme innerlijke klasse aan de methode doorgeven. Hier is de syntaxis van het doorgeven van een anonieme innerlijke klasse als een methodeargument −
obj.my_Method(new My_Class() {
public void Do() {
.....
.....
}
});
Het volgende programma laat zien hoe je een anonieme inner class kunt doorgeven als argument voor een methode.
Voorbeeld
Live demo
// interface
interface Message {
String greet();
}
public class My_class {
// method which accepts the object of interface Message
public void displayMessage(Message m) {
System.out.println(m.greet() +
", This is an example of anonymous inner class as an argument");
}
public static void main(String args[]) {
// Instantiating the class
My_class obj = new My_class();
// Passing an anonymous inner class as an argument
obj.displayMessage(new Message() {
public String greet() {
return "Hello";
}
});
}
}
Als je het bovenstaande programma compileert en uitvoert, krijg je het volgende resultaat −
Uitvoer
Hello, This is an example of anonymous inner class as an argument
Statische geneste klasse
Een statische binnenklasse is een geneste klasse die een statisch lid is van de buitenklasse. Het is toegankelijk zonder de buitenste klasse te instantiëren, met behulp van andere statische leden. Net als statische leden heeft een statische geneste klasse geen toegang tot de instantievariabelen en methoden van de buitenste klasse. De syntaxis van statische geneste klasse is als volgt −
Syntaxis
class MyOuter {
static class Nested_Demo {
}
}
Het instantiëren van een statische geneste klasse is een beetje anders dan het instantiëren van een innerlijke klasse. Het volgende programma laat zien hoe je een statisch geneste klasse kunt gebruiken.
Voorbeeld
Live demo
public class Outer {
static class Nested_Demo {
public void my_method() {
System.out.println("This is my nested class");
}
}
public static void main(String args[]) {
Outer.Nested_Demo nested = new Outer.Nested_Demo();
nested.my_method();
}
}
Als u het bovenstaande programma compileert en uitvoert, krijgt u het volgende resultaat −
Uitvoer
This is my nested class
Java