Les interfaces et les classes abstraites sont les composants essentiels pour réaliser l'abstraction et le polymorphisme.
Une interface en Java est un type de référence, similaire à une classe, qui ne peut contenir que des méthodes abstraites, des méthodes statiques, des méthodes par défaut et des variables finales statiques (constantes). Les interfaces sont utilisées pour réaliser l'abstraction et l'héritage multiple en Java. Les interfaces ne peuvent pas être directement instanciées.
?Avant Java 8, les interfaces ne pouvaient avoir que des méthodes abstraites.
La mise en œuvre de ces méthodes doit être assurée dans une classe distincte. Ainsi, si une nouvelle méthode doit être ajoutée dans une interface, alors son code d'implémentation doit être fourni dans la classe implémentant la même interface.
?Pour pallier ce problème, Java 8 a introduit le concept de méthodes par défaut qui permettent aux interfaces d'avoir des méthodes avec implémentation sans affecter les classes qui implémentent l'interface .
Les méthodes par défaut peuvent être remplacées en implémentant des classes si nécessaire.
Une classe abstraite en Java est une classe qui ne peut pas être instanciée seule et peut contenir des méthodes abstraites (méthodes sans corps) et des méthodes concrètes (méthodes avec corps). Les classes abstraites sont utilisées pour fournir une base commune aux sous-classes, permettant la réutilisation du code et la définition d'un comportement partagé.
Java ne prend en charge qu'un seul héritage, ce qui signifie que chaque classe peut hériter des champs et des méthodes d'une seule classe. Si vous devez hériter de propriétés de plusieurs sources, Java fournit le concept d'interfaces, qui est une forme d'héritage multiple.
?Les interfaces sont similaires aux classes. Cependant, ils définissent uniquement la signature des méthodes et non leurs implémentations. Les méthodes déclarées dans l'interface sont implémentées dans les classes. L'L'héritage multiple se produit lorsqu'une classe implémente plusieurs interfaces.
En Java, l'héritage multiple est réalisé via des interfaces plutôt que des classes. Cela permet à une classe d'implémenter plusieurs interfaces, héritant des signatures de méthode de chacune d'elles. Vous trouverez ci-dessous un exemple illustrant l'héritage multiple à l'aide d'interfaces.
Définissons deux interfaces, Flyable et Swimmable, et une classe Duck qui implémente les deux interfaces.
public interface Flyable {
void fly();
}
public interface Swimmable {
void swim();
}
public class Duck implements Flyable, Swimmable {
@Override
public void fly() {
System.out.println("Duck is flying");
}
@Override
public void swim() {
System.out.println("Duck is swimming");
}
public static void main(String[] args) {
Duck duck = new Duck();
duck.fly();
duck.swim();
}
}
Interfaces :
Classe :
Méthode principale :
Duck is flying Duck is swimming
Voici un schéma simple pour illustrer la relation :
+----------------+
| Flyable |<--------------->Interface
|----------------|
| + fly() |
+----------------+
^
|
| Implements
|
+----------------+
| Duck |<--------------->Class
|----------------|
| + fly() |
| + swim() |
+----------------+
^
|
| Implements
|
+----------------+
| Swimmable |<--------------->Interface
|----------------|
| + swim() |
+----------------+
Dans cet exemple, la classe Duck démontre l'héritage multiple en implémentant les interfaces Flyable et Swimmable. Cela permet à la classe Duck d'hériter et de fournir des implémentations pour les méthodes définies dans les deux interfaces, montrant comment Java réalise un héritage multiple via les interfaces.
Les classes abstraites en Java sont utilisées pour fournir une base commune à une famille de classes liées. Ils peuvent contenir à la fois des méthodes abstraites (méthodes sans corps) et des méthodes concrètes (méthodes avec corps). Vous trouverez ci-dessous un exemple illustrant l'utilisation d'une classe abstraite.
Définissons une classe abstraite Animal et deux sous-classes Dog et Cat qui étendent la classe Animal.
public abstract class Animal {
// Abstract method (does not have a body)
public abstract void makeSound();
// Concrete method (has a body)
public void sleep() {
System.out.println("The animal is sleeping");
}
}
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Dog says: Woof!");
}
public static void main(String[] args) {
Dog dog = new Dog();
dog.makeSound();
dog.sleep();
}
}
public class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Cat says: Meow!");
}
public static void main(String[] args) {
Cat cat = new Cat();
cat.makeSound();
cat.sleep();
}
}
Classe abstraite : Animal
Sous-classe : Chien
Sous-classe : Chat
Pour la classe Chien :
public interface Flyable {
void fly();
}
Pour la classe Chat :
public interface Swimmable {
void swim();
}
Voici un schéma simple pour illustrer la relation :
public class Duck implements Flyable, Swimmable {
@Override
public void fly() {
System.out.println("Duck is flying");
}
@Override
public void swim() {
System.out.println("Duck is swimming");
}
public static void main(String[] args) {
Duck duck = new Duck();
duck.fly();
duck.swim();
}
}
Dans cet exemple, la classe abstraite Animal fournit une base commune pour les sous-classes Dog et Cat. La classe Animal définit une méthode abstraite makeSound() qui doit être implémentée par n'importe quelle sous-classe, et une méthode concrète sleep() qui fournit une implémentation par défaut. Les classes Dog et Cat étendent la classe Animal et fournissent leurs propres implémentations de la méthode makeSound().
Duck is flying Duck is swimming
Les interfaces sont couramment utilisées pour définir des API, des frameworks et des bibliothèques. Par exemple, l'interface java.util.List fournit un contrat pour les implémentations de listes, telles que ArrayList et LinkedList.
+----------------+
| Flyable |<--------------->Interface
|----------------|
| + fly() |
+----------------+
^
|
| Implements
|
+----------------+
| Duck |<--------------->Class
|----------------|
| + fly() |
| + swim() |
+----------------+
^
|
| Implements
|
+----------------+
| Swimmable |<--------------->Interface
|----------------|
| + swim() |
+----------------+
Les classes abstraites sont souvent utilisées pour fournir une classe de base à une famille de classes apparentées. Par exemple, la classe java.util.AbstractList fournit une implémentation squelettique de l'interface List, réduisant ainsi la quantité de code que les sous-classes doivent implémenter.
public interface Flyable {
void fly();
}
| SNo | Interface | Abstract Class |
|---|---|---|
| 1 | Interfaces cannot be instantiated | Abstract classes cannot be instantiated |
| 2 | It can have both abstract and non-abstract methods | It can have both abstract and non-abstract methods |
| 3 | In interfaces, all fields are automatically public, static, and final, and all methods that you declare or define (as default methods) are public | In abstract classes, you can declare fields that are not static and final, and define public, protected, and private concrete methods |
| 4 | Interface supports multiple inheritance. Multiple interfaces can be implemented | Abstract class or class can extend only one class |
| 5 | It is used if you expect that unrelated classes would implement your interface. Eg, the interfaces Comparable and Cloneable are implemented by many unrelated classes | It is used if you want to share code among several closely related classes |
| 6 | It is used if you want to specify the behavior of a particular data type, but not concerned about who implements its behavior. | It is used if you expect that classes that extend your abstract class have many common methods or fields, or require access modifiers other than public (such as protected and private) |
Réf : https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html
Lorsqu'une classe abstraite est sous-classée, la sous-classe fournit généralement des implémentations pour toutes les méthodes abstraites de sa classe parent. Cependant, si ce n'est pas le cas, la sous-classe doit également être déclarée abstraite.
Selon Joshua Bloch, auteur de "Effective Java", les interfaces sont préférées aux classes abstraites pour définir des types car elles sont plus flexibles et prennent en charge l'héritage multiple. Cependant, les classes abstraites sont utiles pour fournir des fonctionnalités partagées et réduire la duplication de code.
"Les interfaces sont idéales pour définir des mixins. Les classes, en revanche, sont idéales pour définir des objets qui ont des propriétés intrinsèques."
- Josué Bloch
Explorez la puissance des interfaces et des classes abstraites dans vos propres projets Java. Expérimentez en définissant des contrats à l'aide d'interfaces et en fournissant des fonctionnalités partagées à l'aide de classes abstraites. Partagez vos idées et expériences avec la communauté Java pour contribuer à la connaissance et à la croissance collectives.
Toutes corrections ou ajouts à cet article sont les bienvenus.
public interface Flyable {
void fly();
}
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!
Que signifie la marge en CSS
Quelle est la différence entre passer par valeur et passer par référence en Java
Qu'en est-il de l'échange Binance ?
valeur absolue python
index.html qu'est-ce que c'est
Quelles sont les principales technologies de pare-feux ?
Le rôle de l'outil formatfactory
Scripts VBS couramment utilisés
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
