Classe abstraite Java et méthodes abstraites
Classe abstraite Java et méthodes abstraites
Dans ce didacticiel, nous allons découvrir les classes et méthodes abstraites Java à l'aide d'exemples. Nous découvrirons également l'abstraction en Java.
Classe abstraite Java
La classe abstraite en Java ne peut pas être instanciée (nous ne pouvons pas créer d'objets de classes abstraites). Nous utilisons le abstract mot clé pour déclarer une classe abstraite. Par exemple,
// create an abstract class
abstract class Language {
// fields and methods
}
...
// try to create an object Language
// throws an error
Language obj = new Language(); Une classe abstraite peut avoir à la fois les méthodes régulières et les méthodes abstraites. Par exemple,
abstract class Language {
// abstract method
abstract void method1();
// regular method
void method2() {
System.out.println("This is regular method");
}
} Pour en savoir plus sur les méthodes non abstraites, consultez les méthodes Java. Ici, nous allons en apprendre davantage sur les méthodes abstraites.
Méthode abstraite Java
Une méthode qui n'a pas de corps est appelée méthode abstraite. Nous utilisons le même abstract mot-clé pour créer des méthodes abstraites. Par exemple,
abstract void display();
Ici, display() est une méthode abstraite. Le corps de display() est remplacé par ; .
Si une classe contient une méthode abstraite, alors la classe doit être déclarée abstraite. Sinon, cela générera une erreur. Par exemple,
// error
// class should be abstract
class Language {
// abstract method
abstract void method1();
} Exemple :classe et méthode abstraites Java
Bien que les classes abstraites ne puissent pas être instanciées, nous pouvons créer des sous-classes à partir de celles-ci. On peut alors accéder aux membres de la classe abstraite en utilisant l'objet de la sous-classe. Par exemple,
abstract class Language {
// method of abstract class
public void display() {
System.out.println("This is Java Programming");
}
}
class Main extends Language {
public static void main(String[] args) {
// create an object of Main
Main obj = new Main();
// access method of abstract class
// using object of Main class
obj.display();
}
} Sortie
This is Java programming
Dans l'exemple ci-dessus, nous avons créé une classe abstraite nommée Language . La classe contient une méthode régulière display() .
Nous avons créé la classe Main qui hérite de la classe abstraite. Remarquez la déclaration,
obj.display(); Ici, obj est l'objet de la classe enfant Main . Nous appelons la méthode de la classe abstraite en utilisant l'objet obj .
Implémentation de méthodes abstraites
Si la classe abstraite inclut une méthode abstraite, alors toutes les classes filles héritées de la superclasse abstraite doivent fournir l'implémentation de la méthode abstraite. Par exemple,
abstract class Animal {
abstract void makeSound();
public void eat() {
System.out.println("I can eat.");
}
}
class Dog extends Animal {
// provide implementation of abstract method
public void makeSound() {
System.out.println("Bark bark");
}
}
class Main {
public static void main(String[] args) {
// create an object of Dog class
Dog d1 = new Dog();
d1.makeSound();
d1.eat();
}
} Sortie
Bark bark I can eat.
Dans l'exemple ci-dessus, nous avons créé une classe abstraite Animal . La classe contient une méthode abstraite makeSound() et une méthode non abstraite eat() .
Nous avons hérité d'une sous-classe Chien de la superclasse Animal . Ici, la sous-classe Chien fournit l'implémentation de la méthode abstraite makeSound() .
Nous avons ensuite utilisé l'objet d1 du Chien classe pour appeler les méthodes makeSound() et eat() .
Remarque :Si le Chien la classe ne fournit pas l'implémentation de la méthode abstraite makeSound() , Chien doit également être déclaré comme abstrait. C'est parce que la sous-classe Chien hérite de makeSound() de Animal .
Constructeur d'accès aux classes abstraites
Une classe abstraite peut avoir des constructeurs comme la classe normale. Et, nous pouvons accéder au constructeur d'une classe abstraite à partir de la sous-classe en utilisant le super mot-clé. Par exemple,
abstract class Animal {
Animal() {
….
}
}
class Dog extends Animal {
Dog() {
super();
...
}
}
Ici, nous avons utilisé le super() à l'intérieur du constructeur de Dog pour accéder au constructeur de Animal .
Notez que le super doit toujours être la première instruction du constructeur de la sous-classe. Visitez Java super mot-clé pour en savoir plus.
Abstraction Java
L'utilisation principale des classes et des méthodes abstraites est de réaliser l'abstraction en Java.
L'abstraction est un concept important de la programmation orientée objet qui nous permet de masquer les détails inutiles et de n'afficher que les informations nécessaires.
Cela nous permet de gérer la complexité en omettant ou en masquant des détails avec une idée plus simple et de niveau supérieur.
Un exemple pratique d'abstraction peut être les freins de moto. Nous savons ce que fait le frein. Lorsque nous appliquons le frein, la moto s'arrête. Cependant, le fonctionnement du frein nous est caché.
Le principal avantage de masquer le fonctionnement du frein est que maintenant le fabricant peut implémenter le frein différemment pour différentes motos, cependant, ce que fait le frein sera le même.
Prenons un exemple qui nous aide à mieux comprendre l'abstraction Java.
Exemple 3 :abstraction Java
abstract class MotorBike {
abstract void brake();
}
class SportsBike extends MotorBike {
// implementation of abstract method
public void brake() {
System.out.println("SportsBike Brake");
}
}
class MountainBike extends MotorBike {
// implementation of abstract method
public void brake() {
System.out.println("MountainBike Brake");
}
}
class Main {
public static void main(String[] args) {
MountainBike m1 = new MountainBike();
m1.brake();
SportsBike s1 = new SportsBike();
s1.brake();
}
} Sortie :
MountainBike Brake SportsBike Brake
Dans l'exemple ci-dessus, nous avons créé une super classe abstraite MotorBike . La super classe MotorBike a une méthode abstraite brake() .
Le brake() la méthode ne peut pas être implémentée dans MotorBike . C'est parce que chaque vélo a une implémentation différente des freins. Ainsi, toutes les sous-classes de MotorBike aurait une implémentation différente de brake() .
Ainsi, l'implémentation de brake() en moto est caché.
Ici, MountainBike fait sa propre implémentation de brake() et vélo de sport fait sa propre implémentation de brake() .
Remarque :Nous pouvons également utiliser des interfaces pour réaliser une abstraction en Java. Pour en savoir plus, visitez l'interface Java.
Points clés à retenir
- Nous utilisons le
abstractmot-clé pour créer des classes et des méthodes abstraites. - Une méthode abstraite n'a pas d'implémentation (corps de la méthode).
- Une classe contenant des méthodes abstraites doit également être abstraite.
- Nous ne pouvons pas créer d'objets d'une classe abstraite.
- Pour implémenter les fonctionnalités d'une classe abstraite, nous en héritons des sous-classes et créons des objets de la sous-classe.
- Une sous-classe doit remplacer toutes les méthodes abstraites d'une classe abstraite. Cependant, si la sous-classe est déclarée abstraite, il n'est pas obligatoire de redéfinir les méthodes abstraites.
- Nous pouvons accéder aux attributs et méthodes statiques d'une classe abstraite en utilisant la référence de la classe abstraite. Par exemple,
Animal.staticMethod();
Java