Classes imbriquées et classes internes Java

Dans ce tutoriel, vous apprendrez les classes imbriquées en Java et leurs types à l'aide d'exemples.

En Java, vous pouvez définir une classe dans une autre classe. Ce type de classe est appelé nested class (classe imbriquée). Par exemple,

class OuterClass {
　　　　//　...
　　　　class NestedClass {
　　　　　　　　//　...
　　　　}
}

Vous pouvez créer deux types de classes imbriquées en Java.

• Classe interne non statique (classe interne)

• 静态嵌套类

Lecture supplémentaire:

• Java Access Modifiers

• Java Static Keyword

Permettons d'examiner d'abord la classe interne non statique.

Classe interne non statique (classe interne)

Classe interne non statique est une classe dans une autre classe. Elle a le droit d'accéder aux membres de la classe fermée (classe externe). Elle est généralement appelée inner class (classe interne).

Comme la classe interne existe à l'intérieur de la classe externe, il est nécessaire de premierer instancier la classe externe afin d'instancier la classe interne.

Voici un exemple de comment déclarer une classe interne en Java.

示例1：Classe interne

class CPU {
　　　　double price;
　　　　//　Classe imbriquée
　　　　class Processor{
　　　　　　　　//Membres de la classe interne
　　　　　　　　double cores;
　　　　　　　　String manufacturer;
　　　　　　　　double getCache(){
　　　　　　　　　　　　return　4.3;
　　　　　　　　}
　　　　}
　　　　//Classe imbriquée protégée
　　　　protected class RAM{
　　　　　　　　//Membres de la classe interne protégée
　　　　　　　　double memory;
　　　　　　　　String manufacturer;
　　　　　　　　double getClockSpeed(){
　　　　　　　　　　　　return　5.5;
　　　　　　　　}
　　　　}
}
public class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Créer un objet de la classe externe CPU
　　　　　　　　CPU cpu = new CPU();
　　　　　　　//Créer un objet de la classe interne Processor à l'aide de la classe externe
　　　　　　　　CPU.Processor processor = cpu.new Processor();
　　　　　　　　//Créer un objet de la classe interne RAM à l'aide de la classe externe CPU
　　　　　　　　CPU.RAM ram = cpu.new RAM();
　　　　　　　　System.out.println("Processor Cache = ");　+　processor.getCache());
　　　　　　　　System.out.println("Ram Clock speed = ");　+　ram.getClockSpeed());
　　　　}
}

输出:

Processor Cache =　4.3
Ram Clock speed =　5.5

Dans le programme ci-dessus, il y a deux classes imbriquées : Processor 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 créons d'abord une instance de la classe externe CPU nommée cpu.

• Ensuite, utilisez l'instance de la classe externe pour créer un objet de la classe interne :　

  CPU.Processor processor = cpu.new Processor();
  CPU.RAM ram = cpu.new RAM();

Attention：Nous utilisons l'opérateur de point (.) pour utiliser la classe externe pour créer une instance de la classe interne.

Accéder aux membres de la classe externe dans une classe interne

Nous pouvons utiliser le mot-clé this pour accéder aux membres de la classe externe. Si vous souhaitez en savoir plus sur ce mot-clé, veuillez consulterLe mot-clé this en Java。}}　

示例2：Accès aux membres

class Car {
　　　　String carName;
　　　　String carType;
　　　　//Affectation de la valeur avec le constructeur
　　　　public Car(String name, String type) {
　　　　　　　　this.carName = name;
　　　　　　　　this.carType = type;
　　　　}
　　　　//　Méthode privée
　　　　private String getCarName() {
　　　　　　　　return this.carName;
　　　　}
　　　　//Classe interne
　　　　class Engine {
　　　　　　　　String engineType;
　　　　　　　　void setEngine() {
　　　　　　　　　　　//Accès à l'attribut carType de Car
　　　　　　　　　　　　if(Car.this.carType.equals("4WD")){
　　　　　　　　　　　　　　　　//Appel de la méthode getCarName() de Car
　　　　　　　　　　　　　　　　if(Car.this.getCarName().equals("Crysler")) {
　　　　　　　　　　　　　　　　　　　　this.engineType = "Smaller";
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　　this.engineType = "Bigger";
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　this.engineType = "Bigger";
　　　　　　　　　　　　}
　　　　　　　　}
　　　　　　　　String getEngineType(){
　　　　　　　　　　　　return this.engineType;
　　　　　　　　}
　　　　}
}
public class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Création d'un objet de la classe externe Car
　　　　　　　　Car car1　= new Car("Mazda", "8WD");
　　　　　　　　//Création d'un objet de la classe interne à partir de la classe externe
　　　　　　　　Car.Engine engine = car1.new Engine();
　　　　　　　　engine.setEngine();
　　　　　　　　System.out.println("8WD moteur de type = "　+　engine.getEngineType());
　　　　　　　　Car car2　= new Car("Crysler", "4WD");
　　　　　　　　Car.Engine c2engine = car2.new Engine();
　　　　　　　　c2engine.setEngine();
　　　　　　　　System.out.println("4WD moteur de type = "　+　c2engine.getEngineType());
　　　　}
}

输出:

8WD moteur de type = Bigger
4WD moteur de type = Smaller

Dans le programme ci-dessus, nous avons une classe interne Engine dans la classe externe Car. Notez cette ligne,

if(Car.this.carType.equals("4WD")) { ... }

Nous utilisons le mot-clé this pour accéder à la variable carType de la classe externe Car. Vous avez peut-être remarqué que nous utilisons Car.this.carType plutôt que this.carType.

C'est parce que si nous n'avons pas mentionné le nom de la classe externe Car, le mot-clé this indiquera le membre de la classe interne.

同样，我们也从内部类访问外部类的方法。

if　(Car.this.getCarName().equals("Crysler")　{...

需要注意的是，尽管getCarName()是一个private方法，但我们能够从内部类访问它。

静态嵌套类

在Java中，我们还可以在另一个类中定义一个静态（static）类。 这种类称为静态嵌套类（static nested class）。 静态嵌套类不称为静态内部类。

与内部类不同，静态嵌套类无法访问外部类的成员变量。这是因为静态嵌套类不需要您创建外部类的实例。

OuterClass.NestedClass obj = new OuterClass.NestedClass();

在这里，我们仅通过使用外部类的类名来创建静态嵌套类的对象。因此，不能使用OuterClass.this引用外部类。

示例3:静态内部类

class MotherBoard {
　　　//静态嵌套类
　　　static class USB{
　　　　　　　int usb2　=　2;
　　　　　　　int usb3　=　1;
　　　　　　　int getTotalPorts(){
　　　　　　　　　　　return usb2　+　usb3;
　　　　　　　}
　　　}
}
public class Main {
　　　public static void main(String[] args) {
　　　　　　　//创建静态嵌套类的对象
　　　　　　　//使用外部类的名称
　　　　　　　MotherBoard.USB usb = new MotherBoard.USB();
　　　　　　　System.out.println("Total　Ports　=　"　+　usb.getTotalPorts());
　　　}
}

输出:

Total　Ports　=　3

在上面的程序中，我们在类MotherBoard中创建了一个名为USB的静态类。 注意这一行，

MotherBoard.USB usb = new MotherBoard.USB();

在这里，我们使用外部类的名称创建一个USB对象。

现在，让我们看看如果尝试访问外部类的成员会发生什么：

示例4：在静态内部类内部访问外部类的成员

class MotherBoard {
　　　String model;
　　　public MotherBoard(String model) {
　　　　　　　this.model = model;
　　　}
　　　//静态嵌套类
　　　static class USB{
　　　　　　　int usb2　=　2;
　　　　　　　int usb3　=　1;
　　　　　　　int getTotalPorts(){
　　　　　　　　　　　//访问外部类的变量model
　　　　　　　　　　　if(MotherBoard.this.model.equals("MSI")) {
　　　　　　　　　　　　　　　return　4;
　　　　　　　　　　　}
　　　　　　　　　　　else {
　　　　　　　　　　　　　　　return usb2　+　usb3;
　　　　　　　　　　　}
　　　　　　　}
　　　}
}
public class Main {
　　　public static void main(String[] args) {
　　　　　　　//创建静态嵌套类的对象
　　　　　　　MotherBoard.USB usb = new MotherBoard.USB();
　　　　　　　System.out.println("Total　Ports　=　"　+　usb.getTotalPorts());
　　　}
}

When we try to run the program, an error will occur:

error: non-static variable this cannot be referenced from a static context

This is because we did not use the object of the external class to create an object of the inner class. Therefore, there is no reference stored in Motherboard.this of the external class Motherboard.

Points to Remember

• Java treats inner classes as regular class members. They are like methods and variables declared within the class.

• Since the inner class is a member of the outer class, any access modifier (such as private, protected) can be applied to the inner class, which is not possible in a normal class.

• Since the nested class is a member of the enclosed external class, you can use the dot notation (.) to access the nested class and its members.

• Using nested classes will make your code more readable and provide better encapsulation.

• Non-static nested classes (inner classes) can access the outer class./Other members of the enclosed class, even if they are declared as private, are also accessible.