Classes abstraites et méthodes abstraites Java

Dans ce tutoriel, nous allons apprendre l'abstraction en Java. Nous allons apprendre les classes abstraites et les méthodes en Java, ainsi que leur utilisation dans les programmes.

Classe abstraite Java

Une classe abstraite est une classe qui ne peut pas être instanciée (nous ne pouvons pas créer d'objets de classe abstraite). En Java, nous utilisons la clé abstraite pour déclarer une classe abstraite.

abstract　class　Animal　{
　　　//Propriétés et méthodes
}

Si vous essayez de créer un objet de classe abstraite, une erreur de compilation se produira. Par exemple,

Animal a1　= new Animal()

Il produira une erreur de compilation :

　L'animal est abstrait; il ne peut pas être instancié

Bien que nous ne puissions pas instancier une classe abstraite, nous pouvons en créer des sous-classes. Nous pouvons créer des objets de sous-classes pour accéder aux membres de la classe abstraite.

Avant de le comprendre en détail, nous devons comprendre la méthode abstraite.

Méthode abstraite Java

Nous utilisons le même mot-clé abstract pour créer une méthode abstraite. Nous avons déclaré une méthode abstraite sans l'implémenter. Par exemple,

abstract　void　makeSound();

Dans ce cas, makeSound() est une méthode abstraite.

Une classe abstraite peut contenir des méthodes abstraites et non abstraites. Voici un exemple.

abstract　class　Animal　{
　　　public void displayInfo() {
　　　　　　System.out.println(“Je suis un animal.”);
　　　}
　　　abstract　void　makeSound();
}

Dans l'exemple précédent, nous avons créé une classe abstraite Animal. Elle contient une méthode abstraite makeSound() et une méthode non abstraite displayInfo().

Héritage de la classe abstraite

Une classe abstraite ne peut pas être instanciée. Pour accéder aux membres d'une classe abstraite, nous devons l'hériter. Par exemple

Exemple1：Héritage de la classe abstraite

abstract　class　Animal　{
　public void displayInfo() {
　　　System.out.println("Je suis un animal.");
　}
}
class　Dog　extends　Animal　{
}
class　Main　{
　public　static　void　main(String[]　args)　{
　　　Dog　d1　=　new　Dog();
　　　d1.displayInfo();
　}
}

Sortie：

Je suis un animal.

Dans l'exemple précédent, nous avons créé une classe abstraite Animal. Nous ne pouvons pas créer d'objet de la classe Animal. Pour accéder à la méthode displayInfo() de la classe Animal, nous avons hérité de la sous-classe Dog d'Animal.

Puis, nous utilisons d1L'objet accède à la méthode displayInfo().

Surcharge de la méthode abstraite

En Java, il est obligatoire de surcharger les méthodes abstraites de la super-classe dans la sous-classe. Cela est dû au fait que la sous-classe hérite des méthodes abstraites de la super-classe.

　Parce que notre sous-classe contient des méthodes abstraites, nous devons les surcharger.

Remarque :Si la sous-classe est également déclarée abstraite, il n'est pas nécessaire de surcharger la méthode abstraite.

Exemple2：Surcharge de la méthode abstraite

abstract　class　Animal　{
　　　abstract　void　makeSound();
　　　public void eat() {
　　　　　　System.out.println("Je peux manger.");
　　　}
}
class　Dog　extends　Animal　{
　　　public　void　makeSound()　{
　　　　　　System.out.println("Hou hou");
　　　}
}
class　Main　{
　　　public　static　void　main(String[]　args)　{
　　　　　　Dog　d1　=　new　Dog();
　　　　　　d1.makeSound();
　　　　　　d1.eat();
　　　}
}

Sortie：

Hou hou.
Je peux manger.

Dans l'exemple précédent, nous avons créé une classe abstraite Animal. Cette classe contient une méthode abstraite makeSound() et une méthode non abstraite eat().

　Puis nous avons créé l'objet Dog d1. En utilisant cet objet, nous avons appelé d1.displayInfo() et d1méthode .eat().

Accéder au constructeur d'une classe abstraite

De la même manière que pour les classes non abstraites, nous utilisons le mot-clé super pour accéder au constructeur d'une classe abstraite. Par exemple,

abstract　class　Animal　{
　　　Animal()　{
　　　　　　….
　　　}
}
class　Dog　extends　Animal　{
　　　Dog()　{
　　　　　　super();
　　　　　　...
　　　}
}

Dans cet exemple, nous utilisons super() dans le constructeur de Dog pour accéder au constructeur de la classe Animal.

Notez que le mot-clé super doit toujours être la première instruction dans le constructeur de la sous-classe. AccèsMots-clés superieur JavaPour en savoir plus.

Pourquoi utiliser l'abstraction Java ?

L'abstraction est une importante notion de programmation orientée objet. L'abstraction ne montre que les informations nécessaires, et tous les détails inutiles restent cachés. Cela nous permet de gérer la complexité en omettant ou en cachant les détails à l'aide d'idées plus simples et plus avancées.

Un exemple réel d'abstraction peut être le frein de moto. Nous connaissons le rôle du frein. Lorsque nous appuyons sur le frein, la moto s'arrête. Mais, le fonctionnement du frein reste caché pour nous.

L'un des principaux avantages de la compréhension du fonctionnement du frein est que les fabricants peuvent utiliser différents freins pour différents motocycles, mais le rôle du frein reste le même.

Laissez-nous prendre un exemple pour mieux comprendre l'abstraction Java.

Exemple3：Java abstraction

abstract　class　Animal　{
　　　abstract　void　makeSound();
}
class　Dog　extends　Animal　{
　　　public　void　makeSound()　{
　　　　　　System.out.println("Bark　bark.");
　　　}
}
class　Cat　extends　Animal　{
　　　public　void　makeSound()　{
　　　　　　System.out.println("Meows　");
　　　}
}
class　Main　{
　　　public　static　void　main(String[]　args)　{
　　　　　　Dog　d1　=　new　Dog();
　　　　　　d1.makeSound();
　　　　　　Cat　c1　=　new　Cat();
　　　　　　c1.makeSound();
　　　}
}

Sortie：

Bark　bark
Meows

Dans l'exemple ci-dessus, nous avons créé une classe mère Animal. La classe mère Animal possède une méthode abstraite makeSound().

Le méthode makeSound() ne peut pas être implémentée à l'intérieur de Animal. Cela est dû au fait que chaque animal émet des sons différents. Par conséquent, toutes les sous-classes d'Animal ont des méthodes d'implémentation makeSound() différentes.

We cannot implement makeSound() in Animal in a way that is correct for all subclasses of Animal. Therefore, the implementation of makeSound() in Animal remains hidden.

　In the above example, Dog implements its own makeSound() implementation, Cat implements its own makeSound().

Points to remember

• We use the abstract keyword to create abstract classes and methods.

• Abstract methods have no implementation (no method body).

• The class that contains abstract methods should also be abstract.

• We cannot create an object of an abstract class.

• To implement the functionality of an abstract class, we inherit from its subclass and create an object of that subclass.

• The subclass must override all abstract methods of the abstract class. However, if the subclass is declared as abstract, it is not mandatory to override the abstract methods.

• We can use the reference of an abstract class to access the static attributes and methods of the abstract class. For example,

  Animal.staticMethod();

Java interface

In Java, interfaces are similar to abstract classes. However, interfaces have no non-abstract methods. In the next tutorial, we will learn more about interfaces.