Une classe abstraite est une classe déclarée en Java via le mot clé "Abstract". Les classes abstraites sont un concept de l'un des quatre principes de la programmation orientée objet (POO) appelé « héritage ». L'héritage fait référence à une fonctionnalité des classes Java dans laquelle une classe appelée « sous-classe » hérite de toutes les propriétés de la classe. La classe parent est souvent appelée « superclasse ».
En Java, une classe abstraite fait référence à une super classe de base dont d'autres sous-classes peuvent hériter. Il peut contenir des méthodes abstraites et non abstraites.
Étape 1 - Identifiez les méthodes de la classe qui ont une implémentation par défaut ou aucune implémentation.
Étape 2 - Supprimez l'implémentation de ces méthodes.
Étape 3 - Ajoutez le mot-clé abstract à la déclaration de classe.
Étape 4 - Ajoutez le mot-clé abstract à la déclaration de méthode modifiée à l'étape 2.
Étape 5 - Si la classe a des variables d'instance qui doivent être initialisées, ajoutez un constructeur pour les initialiser.
Étape 6 - Mettez à jour toutes les sous-classes de la classe abstraite pour implémenter des méthodes abstraites ou se rendre abstraites.
Regardons la syntaxe d'instanciation des classes abstraites en Java -
// Abstract Class
abstract class Shape {
public abstract void draw();
}
Les classes abstraites étant des classes incomplètes, elles ne peuvent pas être instanciées directement à l'aide du mot-clé "new".
Sous-classes concrètes - Afin d'instancier correctement une classe abstraite ambiguë ou incomplète, il existe une option permettant d'utiliser une sous-classe concrète. En s'étendant de manière transparente à partir de cette abstraction parent et en implémentant chacune de ses exigences de méthode, les utilisateurs peuvent créer et implémenter avec succès cette sous-classe nouvellement instanciée sans erreurs ni incohérences dans son fonctionnement.
Expressions Lambda - Pour créer des objets à partir de classes abstraites, vous avez une autre option : utiliser des expressions lambda qui fournissent des implémentations pour toutes ses abstractions. Cette création lambda est ensuite affectée à une variable d'interface fonctionnelle compatible basée sur ces signatures.
Voyons un exemple d'extrait de code pour comprendre l'utilisation des classes abstraites. Le premier scénario fournit du code avec des classes non abstraites.
class Shape {
public void printName() {
System.out.println("I'm a shape");
}
public float area() {
return 0;
}
public void printDetails() {
this.printName();
System.out.println("... and my area is " + this.area());
}
}
class Circle extends Shape {
private float radius;
public Circle(float radius) {
this.radius = radius;
}
public void printName() {
System.out.println("I'm a circle");
}
public float area() {
return (float) (Math.PI * Math.pow(radius, 2));
}
}
class Rectangle extends Shape {
private float length;
private float width;
public Rectangle(float length, float width) {
this.length = length;
this.width = width;
}
public void printName() {
System.out.println("I'm a rectangle");
}
public float area() {
return length * width;
}
}
public class Main {
public static void main(String[] args) {
Shape[] shapes = { new Circle(3.5f), new Rectangle(4.0f, 5.0f) };
for (Shape shape : shapes) {
shape.printDetails();
}
}
}
I'm a circle ... and my area is 38.48451 I'm a rectangle ... and my area is 20.0
Les classes Circle et Rectangle héritent des méthodes printName(), Area() et printDetails() de la superclasse "Shape". Cependant, aucune des deux classes ne remplace la méthode Area() pour fournir sa propre implémentation.
En appelant la méthode printDetails() de l'objet Circle, le résultat sera "Je suis un cercle... et mon aire est 38,48451". De même, appeler la méthode printDetails() sur un objet Rectangle affichera "Je suis un rectangle... et ma surface est de 20,0". Cela garantit que le résultat reflète la forme correcte et sa zone correspondante en fonction de la mise en œuvre spécifique fournie dans chaque cours
// With abstract class
abstract class Shape {
public abstract void printName();
public abstract float area();
public void printDetails() {
this.printName();
System.out.println("... and my area is " + this.area());
}
}
// Concrete class
class Circle extends Shape {
private float radius;
public Circle(float radius) {
this.radius = radius;
}
public void printName() {
System.out.print("I'm a circle");
}
public float area() {
return (float) (Math.PI * Math.pow(radius, 2));
}
}
// Concrete class
class Rectangle extends Shape {
private float length;
private float width;
public Rectangle(float length, float width) {
this.length = length;
this.width = width;
}
public void printName() {
System.out.print("I'm a rectangle");
}
public float area() {
return length * width;
}
}
// Main class
public class Main {
public static void main(String[] args) {
Shape[] shapes = { new Circle(10), new Rectangle(5, 10) };
for (Shape shape : shapes) {
shape.printDetails();
}
}
}
I'm a circle... and my area is 314.15927 I'm a rectangle... and my area is 50.0
Dans le code mis à jour ci-dessus, les classes Circle et Rectangle implémentent les méthodes abstraites printName() et Area() définies dans la classe abstraite "Shape". La méthode printDetails() de la classe Shape peut utiliser ces méthodes pour imprimer les noms de formes et leurs régions respectives.
En faisant de Shape une classe abstraite et en définissant des méthodes abstraites, nous garantissons que toute classe qui étend la classe Shape doit fournir sa propre implémentation pour les méthodes printName() et Area().
interface Nameable {
String getName();
}
abstract class Shape {
private Nameable nameable;
public Shape(Nameable nameable) {
this.nameable = nameable;
}
public abstract float area();
public void printDetails() {
System.out.println("I'm a " + nameable.getName() + " ... and my area is " + this.area());
}
}
class Circle extends Shape {
private float radius;
public Circle(float radius) {
super(() -> "circle");
this.radius = radius;
}
@Override
public float area() {
return (float) (Math.PI * Math.pow(radius, 2));
}
}
class Rectangle extends Shape {
private float width;
private float height;
public Rectangle(float width, float height) {
super(() -> "rectangle");
this.width = width;
this.height = height;
}
@Override
public float area() {
return width * height;
}
}
public class Main {
public static void main(String[] args) {
Shape[] shapes = { new Circle(10), new Rectangle(5, 10) };
for (Shape shape : shapes) {
shape.printDetails();
}
}
}
I'm a circle ... and my area is 314.15927 I'm a rectangle ... and my area is 50.0
Dans la dernière mise à jour de ce code, nous avons introduit une manière améliorée de spécifier Shape en tant que classe abstraite tout en internalisant sa fonction getName(). Une autre amélioration consiste à intégrer la méthode printName, qui utilise avec succès les données de getName() pour afficher le nom de chaque forme correspondante. Pour les sous-classes Circle et Rectangle, elles remplacent désormais le getName correspondant à l'aide d'une expression lambda afin que la forme attendue soit identifiée avec précision.
En résumé, une classe abstraite ne peut être instanciée que via sa sous-classe de base, pas directement. Il s’agit d’un concept hérité.
La raison principale derrière cela est qu'une classe abstraite n'est pas une implémentation complète de ses méthodes et objets, mais est utilisée par les sous-classes pour en hériter.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
