Interfaces Java et classes abstraites : comment parvenir à la réutilisation du code

"Interfaces Java et classes abstraites : comment implémenter la réutilisation du code" est un article soigneusement rédigé par l'éditeur PHP Xiaoxin. Du point de vue de la programmation Java, cet article discute en profondeur de l'importance et de l'application des interfaces et des classes abstraites dans la réutilisation du code. Grâce à l'analyse et à la comparaison d'exemples de codes, il aide les lecteurs à mieux comprendre comment utiliser les interfaces et les classes abstraites pour réaliser la réutilisation du code et améliorer la réutilisabilité et la maintenabilité du code. Cet article est un matériel d'apprentissage rare pour les lecteurs qui souhaitent apprendre systématiquement la programmation Java.

• L'interface ne contient que des méthodes abstraites et aucune implémentation concrète.
• Toutes les méthodes d'une interface sont implicitement déclarées publiques et abstraites.
• Une classe peut implémenter plusieurs interfaces.
• Les interfaces sont principalement utilisées pour définir des contrats et préciser les comportements que les classes doivent mettre en œuvre.
• Les méthodes de l'interface ne sont pas implémentées et ne peuvent donc pas être utilisées directement. Ils doivent être implémentés par la classe qui les implémente.

Cours abstrait

• Les classes abstraites peuvent contenir des méthodes abstraites et des méthodes concrètes.
• Les méthodes abstraites dans les classes abstraites doivent être implémentées par des sous-classes.
• Les méthodes concrètes dans les classes abstraites fournissent des implémentations par défaut.
• Une classe ne peut hériter que d’une seule classe abstraite.
• Les classes abstraites sont souvent utilisées pour définir un comportement commun et fournir une implémentation partielle.
• Les méthodes concrètes des classes abstraites peuvent être remplacées par des sous-classes, tandis que les méthodes abstraites doivent être implémentées.

Choisissez l'interface ou la classe abstraite

Le choix de l'interface ou de la classe abstraite dépend du scénario spécifique :

• Si vous avez besoin de définir un contrat et n'avez pas besoin d'une implémentation spécifique, choisissez une interface.
• Si vous avez besoin de définir un comportement commun et de fournir une implémentation partielle, choisissez une classe abstraite.
• Si vous avez besoin d'une classe pour prendre en charge l'héritage multiple, choisissez une interface.
• Si vous avez besoin d'une classe pour avoir une hiérarchie d'héritage plus stricte, choisissez des classes abstraites.

Réutilisation du code

Grâce aux interfaces et aux classes abstraites, nous pouvons réaliser la réutilisation du code, réduire la redondance et améliorer la flexibilité :

• Les interfaces permettent à différentes classes d'implémenter le même contrat, favorisant ainsi la réutilisation et la connectabilité du code.
• Les classes abstraites fournissent une implémentation partielle, et les sous-classes peuvent étendre cette implémentation et personnaliser des comportements spécifiques pour éviter d'écrire le même code à plusieurs reprises.

Polymorphisme

Les interfaces et les classes abstraites facilitent également le polymorphisme, la capacité à gérer différents types d'objets de manière uniforme :

• Le type défini par une interface est le type parent commun de toutes les classes qui implémentent l'interface.
• Le type défini par une classe abstraite est le type parent commun de toutes les sous-classes.
• Cela permet de manipuler des objets de manière polymorphe sans se soucier de leur type concret.

Exemple

Exemple d'interface :

public interface Shape {
double getArea();
double getPerimeter();
}

Exemple de classe abstraite :

public abstract class Animal {
protected String name;

public abstract void speak();

public void eat() {
System.out.println("Animal is eating.");
}
}

Exemple de réutilisation de code :

ClassCircle和Square通过实现Shape接口实现了getArea()和getPerimeter(), réutilisant ainsi le code de calcul de l'aire et du périmètre d'une forme.

public class Circle implements Shape {
private double radius;

@Override
public double getArea() {
return Math.PI * radius * radius;
}

@Override
public double getPerimeter() {
return 2 * Math.PI * radius;
}
}

public class Square implements Shape {
private double side;

@Override
public double getArea() {
return side * side;
}

@Override
public double getPerimeter() {
return 4 * side;
}
}

Exemple de polymorphisme :

Nous pouvons utiliser des Shape类型的变量来存储Circle和Squareobjets et appeler leurs méthodes de manière polymorphe.

Shape shape1 = new Circle(5);
Shape shape2 = new Square(10);

System.out.println(shape1.getArea()); // 78.53981633974483
System.out.println(shape2.getPerimeter()); // 40.0

En tirant parti des interfaces et des classes abstraites, les programmeurs Java peuvent réaliser la réutilisation et le polymorphisme du code, écrivant ainsi un code plus flexible et plus maintenable.

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!