Classe imbriquée et interne Java
Classe Java imbriquée et interne
Dans ce didacticiel, vous découvrirez la classe imbriquée en Java et ses types à l'aide d'exemples.
En Java, vous pouvez définir une classe dans une autre classe. Cette classe est connue sous le nom de nested class . Par exemple,
class OuterClass {
// ...
class NestedClass {
// ...
}
} Il existe deux types de classes imbriquées que vous pouvez créer en Java.
- Classe imbriquée non statique (classe interne)
- Classe imbriquée statique
Lecture recommandée :
- Modificateurs d'accès Java
- Mot clé statique Java
Examinons d'abord les classes imbriquées non statiques.
Classe imbriquée non statique (classe interne)
Une classe imbriquée non statique est une classe dans une autre classe. Il a accès aux membres de la classe englobante (classe externe). Il est communément appelé inner class .
Depuis le inner class existe dans la classe externe, vous devez d'abord instancier la classe externe, afin d'instancier la classe interne.
Voici un exemple de la façon dont vous pouvez déclarer des classes internes en Java.
Exemple 1 :Classe interne
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());
}
} Sortie :
Processor Cache = 4.3 Ram Clock speed = 5.5
Dans le programme ci-dessus, il y a deux classes imbriquées :Processeur et RAM à l'intérieur de la classe externe :CPU . Nous pouvons déclarer la classe interne comme protégée. Par conséquent, nous avons déclaré la classe RAM comme protégée.
Dans la classe Main,
- nous avons d'abord créé une instance d'une classe externe CPU nommé processeur .
- En utilisant l'instance de la classe externe, nous avons ensuite créé des objets de classes internes :
CPU.Processor processor = cpu.new Processor; CPU.RAM ram = cpu.new RAM();
Remarque :On utilise le point (. ) pour créer une instance de la classe interne à l'aide de la classe externe.
Accéder aux membres de la classe externe dans la classe interne
Nous pouvons accéder aux membres de la classe externe en utilisant ce mot clé. Si vous voulez en savoir plus sur ce mot-clé, visitez Java ce mot-clé.
Exemple 2 :Accéder aux membres
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());
}
} Sortie :
Engine Type for 8WD= Bigger Engine Type for 4WD = Smaller
Dans le programme ci-dessus, nous avons la classe interne nommée Engine à l'intérieur de la classe externe Car . Ici, remarquez la ligne,
if(Car.this.carType.equals("4WD")) {...}
Nous utilisons this mot-clé pour accéder au carType variable de la classe externe. Vous avez peut-être remarqué qu'au lieu d'utiliser this.carType nous avons utilisé Car.this.carType .
C'est parce que si nous n'avions pas mentionné le nom de la classe externe Car , puis this le mot-clé représentera le membre à l'intérieur de la classe interne.
De même, nous accédons également à la méthode de la classe externe à partir de la classe interne.
if (Car.this.getCarName().equals("Crysler") {...}
Il est important de noter que, bien que le getCarName() est un private méthode, nous pouvons y accéder à partir de la classe interne.
Classe imbriquée statique
En Java, on peut aussi définir un static classe à l'intérieur d'une autre classe. Cette classe est connue sous le nom de static nested class . Les classes imbriquées statiques ne sont pas appelées classes internes statiques.
Contrairement à la classe interne, une classe imbriquée statique ne peut pas accéder aux variables membres de la classe externe. C'est parce que la classe imbriquée statique ne vous oblige pas à créer une instance de la classe externe.
OuterClass.NestedClass obj = new OuterClass.NestedClass();
Ici, nous créons un objet de la classe imbriquée statique en utilisant simplement le nom de classe de la classe externe. Par conséquent, la classe externe ne peut pas être référencée à l'aide de OuterClass.this .
Exemple 3 :Classe interne statique
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());
}
} Sortie :
Total Ports = 3
Dans le programme ci-dessus, nous avons créé une classe statique nommée USB à l'intérieur de la classe MotherBoard . Remarquez la ligne,
MotherBoard.USB usb = new MotherBoard.USB(); Ici, nous créons un objet de USB en utilisant le nom de la classe externe.
Voyons maintenant ce qui se passerait si vous tentiez d'accéder aux membres de la classe externe :
Exemple 4 :Accéder aux membres de la classe externe à l'intérieur de la classe interne statique
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());
}
} Lorsque nous essayons d'exécuter le programme, nous obtenons une erreur :
error: non-static variable this cannot be referenced from a static context
C'est parce que nous n'utilisons pas l'objet de la classe externe pour créer un objet de la classe interne. Par conséquent, il n'y a aucune référence à la classe externe Motherboard stocké dans Motherboard.this .
Points clés à retenir
- Java traite la classe interne comme un membre normal d'une classe. Ils sont comme des méthodes et des variables déclarées à l'intérieur d'une classe.
- Étant donné que les classes internes sont membres de la classe externe, vous pouvez appliquer n'importe quel modificateur d'accès comme
private,protectedà votre classe intérieure, ce qui n'est pas possible dans les classes normales. - Étant donné que la classe imbriquée est membre de sa classe externe englobante, vous pouvez utiliser le point (
.) notation pour accéder à la classe imbriquée et à ses membres. - L'utilisation de la classe imbriquée rendra votre code plus lisible et fournira une meilleure encapsulation.
- Les classes imbriquées non statiques (classes internes) ont accès aux autres membres de la classe externe/englobante, même si elles sont déclarées privées.
Java