Dans ce didacticiel, vous découvrirez la classe imbriquée dans 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
Regardons 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.
Puisque le inner classexiste 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 intérieure
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 :
Cache du processeur = 4,3 Vitesse d'horloge RAM = 5,5
Dans le programme ci-dessus, il existe 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.
À l'intérieur de la classe principale,
- nous avons d'abord créé une instance d'un processeur de classe externe nommé cpu.
- 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 : Nous utilisons l' .opérateur dot ( ) pour créer une instance de la classe interne en utilisant la classe externe.
Accès 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 souhaitez en savoir plus sur ce mot-clé, visitez Java ce mot-clé.
Exemple 2: accès 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 :
Type de moteur pour 8WD = Type de moteur plus gros pour 4WD = Plus petit
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 des thismots clés pour accéder à la variable carType de la classe externe. Vous avez peut-être remarqué qu'au lieu d'utiliser, this.carTypenous avons utilisé Car.this.carType.
C'est parce que si nous n'avions pas mentionné le nom de la classe externe Car, alors le thismot-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 depuis la classe interne.
if (Car.this.getCarName().equals("Crysler") (… )
Il est important de noter que, bien que la méthode getCarName()soit une privateméthode, nous pouvons y accéder depuis la classe interne.
Classe imbriquée statique
En Java, nous pouvons également définir une staticclasse dans 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 :
Nombre total de 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 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ès aux membres de la classe Outer à 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:
erreur: variable non statique qui ne peut pas être référencée à partir d'un contexte statique
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.
- 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.
