Menu

Tutoriel sur l'interface Java et les classes abstraites avec des exemples

  • Principal
  • Autre
  • Tutoriel sur l'interface Java et les classes abstraites avec des exemples

java interface abstract class tutorial with examples

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel vidéo explique ce qu'est l'interface Java, comment l'implémenter et l'héritage multiple à l'aide d'interfaces en Java avec des exemples:

Dans l'un de nos tutoriels précédents, nous avons discuté de l'abstraction en détail. Nous y avons discuté des classes abstraites et des méthodes abstraites. Nous savons que les classes abstraites fournissent de l'abstraction car nous pouvons également avoir une méthode non abstraite dans la classe abstraite.

La fonctionnalité qui fournit 100% d'abstraction en Java s'appelle ' Interface ». Dans ce tutoriel, nous discuterons interfaces en Java.

=> Jetez un œil au guide du débutant Java ici.

Interfaces Java et classes abstraites

Ce que vous apprendrez:

Tutoriels vidéo sur les interfaces et les classes abstraites

Introduction aux interfaces et aux classes abstraites en Java - Partie 1:

Présentation des interfaces et des classes abstraites en Java - Partie 2:

Abstraction et héritage en Java:

Qu'est-ce qu'une interface en Java

Une interface en Java est définie comme un type abstrait qui spécifie le comportement de classe. Une interface est une sorte de protocole qui définit des règles concernant la manière dont une classe particulière doit se comporter.

Une interface en Java peut contenir des méthodes abstraites et des constantes statiques. Par défaut, toutes les méthodes de l'interface sont publiques et abstraites.

Un exemple simple d'interface en Java est donné ci-dessous.

interface shape{ public static final String color = “Red”; public void calculateArea(); }

L’exemple ci-dessus définit une interface «shape» qui a une variable statique et une méthode abstraite «CalculateArea ()».

Une interface est une entité qui n'a que des méthodes abstraites comme corps. Il peut également contenir des variables finales statiques.

Donc, tout comme la classe, une interface peut également avoir des méthodes et des variables, mais notez que les méthodes sont abstraites (sans implémentation) et les variables sont statiques.

Vous trouverez ci-dessous quelques propriétés à garder à l'esprit liées aux interfaces:

  • Les interfaces sont des plans pour une classe. Ils disent à la classe quoi faire grâce à leurs méthodes.
  • Une interface spécifie les méthodes abstraites et les classes implémentant cette interface doivent également implémenter ces méthodes.
  • Si une classe implémentant l'interface ne définit pas toutes les méthodes de l'interface, alors cette classe devient une classe abstraite.

La syntaxe générale de la déclaration d'interface est donnée ci-dessous.

interface { //constant or static fields declaration //abstract method declaration //default declarations }

Comme indiqué dans la déclaration ci-dessus, nous utilisons un mot-clé Java «interface» qui indique que nous déclarons une interface maintenant.

java passant un tableau à une méthode

Un mot-clé «interface» est suivi du nom_interface, puis des accolades ouvrantes. Ensuite, nous avons diverses déclarations de méthodes abstraites, déclaration de champs statiques, etc. Enfin, nous fermons les accolades.

Par exemple,si nous voulons déclarer une interface «TestInterface» avec deux méthodes, à savoir method_one et method_two, alors la déclaration de TestInterface sera comme ci-dessous:

interface TestInterface{ void method_one(); void method_two(); }

Utilisations de l'interface en Java

  • Les interfaces en Java fournissent une abstraction à 100% car elles ne peuvent avoir que des méthodes abstraites.
  • En utilisant des interfaces, nous pouvons réaliser plusieurs héritages en Java, ce qui n'est pas possible avec des classes.
  • Pour obtenir un couplage lâche, une interface peut être utilisée.

Comment implémenter une interface en Java

Une fois l'interface déclarée, nous pouvons l'utiliser dans une classe en utilisant le mot-clé 'implements' dans la déclaration de classe.

Ce mot clé 'implements' apparaît après le nom de la classe comme indiqué ci-dessous:

class implements { //class body }

Implémenter une interface équivaut à signer un contrat. Par conséquent, une classe implémentant une interface signifie qu'elle a signé un contrat et a accepté d'implémenter les méthodes abstraites de l'interface ou, en d'autres termes, d'exécuter le comportement spécifié par l'interface.

Si la classe implémentant l'interface n'implémente pas le comportement exact spécifié dans l'interface, la classe doit être déclarée comme abstraite.

Exemple d'implémentation d'interface

Vous trouverez ci-dessous un exemple simple d'interface en Java.

//interface declaration interface Polygon_Shape { void calculateArea(int length, int breadth); } //implement the interface class Rectangle implements Polygon_Shape { //implement the interface method public void calculateArea(int length, int breadth) { System.out.println('The area of the rectangle is ' + (length * breadth)); } } class Main { public static void main(String() args) { Rectangle rect = new Rectangle(); //declare a class object rect.calculateArea(10, 20); //call the method } }

Production:

Exemple de sortie de zone de rectangle

Le programme ci-dessus illustre l'exemple simple des interfaces en Java. Ici, nous déclarons une interface nommée Polygon_Shape puis la classe Rectangle l'implémente.

Convention de dénomination d'interface en Java

Les conventions de dénomination Java sont les directives de dénomination que nous devons suivre en tant que programmeurs afin de pouvoir produire un code cohérent lisible. Java utilise des notations «TitleCase» pour les classes de dénomination et les interfaces. Il utilise les notations «CamelCase» pour les variables, les méthodes, etc.

En ce qui concerne l'interface, le nom de l'interface est dans le cas du titre avec la première lettre de chaque mot du nom de l'interface en majuscule. Les noms d'interface sont sélectionnés de manière à ce qu'ils soient généralement des adjectifs. Mais lorsque les interfaces représentent la famille de classes comme map ou list, elles peuvent être nommées d'après des noms.

Quelques exemples de noms d'interface valides sont donnés ci-dessous:

public interface Iterable {} public interface List {} public interface Serializable {} public interface Clonable {} public interface Runnable {}

Constructeur d'interface

La question suivante est de savoir si une interface a un constructeur?

Nous savons que nous avons besoin d'objets pour invoquer des méthodes. Pour créer des objets, nous avons besoin de constructeurs. Mais dans le cas des interfaces en Java, les méthodes ne sont pas implémentées.

Les méthodes des interfaces sont toutes abstraites. Il est donc inutile d'appeler ces méthodes depuis l'interface. Deuxièmement, les interfaces étant abstraites par défaut, nous ne pouvons pas créer d'objets de l'interface. Ainsi, nous n'avons pas besoin de constructeurs pour Interface.

Méthodes d'interface

Dans cette section, nous verrons comment déclarer les méthodes d'interface. Par règle, une interface ne peut avoir que des méthodes publiques ou par défaut, les méthodes d'interface sont publiques. Aucun autre modificateur d'accès n'est autorisé à être utilisé à l'intérieur de l'interface.

Ainsi, que nous le déclarions explicitement ou non, chaque méthode de l'interface est abstraite par défaut avec une visibilité publique.

Par conséquent, si void printMethod () est le prototype que nous avons l'intention de déclarer dans une interface, alors les déclarations suivantes sont les mêmes.

void printMethod(); public void printMethod(); abstract void printMethod (); public abstract void printMethod ();

Notez que nous ne pouvons pas utiliser les modificateurs suivants dans l'interface pour les méthodes d'interface.

  • final
  • statique
  • Privé
  • protégé
  • synchronisé
  • originaire de
  • strictfp

Maintenant, implémentons un programme Java pour démontrer la visibilité de la méthode d'interface.

//declare an interface interface TestInterface { void printMethod(); //default visibility is public. } //interface implementation class TestClass implements TestInterface { //if the access modifier is changed to any other, compiler generates error public void printMethod() { System.out.println('TestClass::printMethod()'); } } class Main { public static void main(String() args) { TestClass tc = new TestClass(); //create an object tc.printMethod(); //call concrete method } }

Production:

TestClass printMethod

Comme déjà mentionné, par défaut, les méthodes d'interface sont publiques. Par conséquent, lorsque nous ne spécifions aucun modificateur d'accès pour la méthode d'interface, elle est publique comme dans le programme ci-dessus.

Supposons que nous modifions la déclaration de la méthode d'interface dans le programme ci-dessus comme suit:

private void printMethod ();

Cela signifie alors que nous avons spécifié la méthode d'interface printMethod () comme private. Lorsque nous compilons le programme, nous obtenons l'erreur de compilation suivante.

erreur: le modificateur privé n'est pas autorisé ici

private void printMethod ();

Le deuxième cas que nous pouvons tester est en changeant le modificateur de la méthode implémentée dans la classe TestClass de public à private. Désormais, le modificateur par défaut de la classe est privé. Nous supprimons donc simplement le mot-clé public du prototype de méthode dans la classe comme suit:

void printMethod() { System.out.println('TestClass::printMethod()'); }

Maintenant, si nous compilons le programme, nous obtenons l'erreur suivante.

erreur: printMethod () dans TestClass ne peut pas implémenter printMethod () dans TestInterface
void printMethod ()
^
tentative d'attribution de privilèges d'accès plus faibles; était public

Par conséquent, le point à noter ici est que nous ne pouvons pas changer le modificateur d'accès de la méthode implémentée de l'interface en un autre modificateur d'accès. Comme les méthodes d'interface sont publiques par défaut, lorsqu'elles sont implémentées par des classes qui implémentent des interfaces, ces méthodes doivent également être publiques.

Champs d'interface en Java

Les champs ou variables déclarés dans une interface sont par défaut public, static et final. Cela signifie qu'une fois déclarée, leur valeur ne peut pas être modifiée.

Notez que si les champs d'interface sont définis sans spécifier aucun de ces modificateurs, les compilateurs Java assument ces modificateurs. Par exemple, si nous ne spécifions pas de modificateur public lors de la déclaration du champ dans l'interface, alors il est supposé par défaut.

Lorsqu'une interface est implémentée par une classe, elle fournit une implémentation pour toutes les méthodes abstraites de l'interface. De même, tous les champs déclarés dans l'interface sont également hérités par la classe qui implémente l'interface. Ainsi, une copie du champ d'interface est présente dans la classe d'implémentation.

Désormais, tous les champs de l'interface sont statiques par défaut. Par conséquent, nous pouvons y accéder en utilisant le nom de l'interface directement comme nous accédons aux champs statiques de la classe en utilisant le nom de la classe et non l'objet.

L'exemple de programme Java ci-dessous montre comment accéder aux champs de l'interface.

//interface declaration interface TestInterface{ public static int value = 100; //interface field public void display(); } //Interface implementation class TestClass implements TestInterface{ public static int value = 5000; //class fields public void display() { System.out.println('TestClass::display () method'); } public void show() { System.out.println('TestClass::show () method'); } } public class Main{ public static void main(String args()) { TestClass testObj = new TestClass(); //print interface and class field values. System.out.println('Value of the interface variable (value): '+TestInterface.value); System.out.println('Value of the class variable (value): '+testObj.value); } }

Production:

Exemple de champ d

Comme indiqué dans le programme ci-dessus, les champs d'interface sont accessibles en utilisant un nom d'interface suivi de l'opérateur point (.), Puis de la variable réelle ou du nom de champ.

L'interface générique en Java

Nous avons discuté des génériques Java dans nos précédents tutoriels. En plus d'avoir des classes génériques, des méthodes, etc., nous pouvons également avoir des interfaces génériques. Les interfaces génériques peuvent être spécifiées de la même manière que nous spécifions les classes génériques.

Les interfaces génériques sont déclarées avec des paramètres de type qui les rendent indépendantes d'un type de données.

La syntaxe générale de l'interface générique est la suivante:

bonne application de téléchargement de mp3 pour android
interface { //interface methods and variables }

Maintenant, si nous voulons utiliser l'interface générique ci-dessus dans une classe, alors nous pouvons avoir la définition de classe comme indiqué ci-dessous:

class implements interface_name { //class body }

Notez que nous devons spécifier la même liste de paramètres avec la classe qu'avec l'interface.

Le programme Java suivant illustre les interfaces génériques en Java.

//generic interface declaration interface MinInterface>{ T minValue(); } //implementation for generic interface class MinClassImpl> implements MinInterface { T() intArray; MinClassImpl(T() o) { intArray = o; } public T minValue() { T v = intArray(0); for (int i = 1; i intMinValue = new MinClassImpl (intArray); MinClassImpl charMinValue = new MinClassImpl(charArray); //call interface method minValue for int type array System.out.println('Min value in intOfArray: ' + intMinValue.minValue()); //call interface method minValue for char type array System.out.println('Min value in charOfArray: ' + charMinValue.minValue()); }

Production:

Sortie d

Le programme ci-dessus implémente une interface contenant une méthode pour trouver la valeur minimale dans le tableau. Ceci est une interface générique. La classe implémente cette interface et remplace la méthode. Dans la méthode principale, nous appelons la méthode d'interface pour trouver la valeur minimale dans un entier et un tableau de caractères.

Plusieurs interfaces en Java

Dans notre rubrique sur l'héritage, nous avons vu que Java ne permet pas à une classe d'hériter de plusieurs classes car il en résulte une ambiguïté appelée «Diamond Problem».

Cependant, une classe peut hériter ou implémenter plusieurs interfaces. Dans ce cas, on parle d'héritage multiple. Ainsi, bien que nous ne soyons pas autorisés à implémenter l'héritage multiple en Java via des classes, nous pouvons le faire en utilisant des interfaces.

Le diagramme suivant montre l'héritage multiple à l'aide d'interfaces. Ici, une classe implémente deux interfaces, à savoir Interface_one et Interface_two.

Plusieurs interfaces en Java

Notez que lorsqu'une classe implémente les multiples interfaces, les noms d'interface sont séparés par des virgules dans la déclaration de classe. Nous pouvons implémenter autant d'interfaces tant que nous pouvons gérer la complexité.

Le programme Java qui présente plusieurs interfaces est illustré ci-dessous.

//Interface_One declaration interface Interface_One{ void print(); } //Interface_Two declaration interface Interface_Two{ void show(); } //multiple inheritance - DemoClass implementing Interface_One&Interface_Two class DemoClass implements Interface_One,Interface_Two{ public void print(){ //Override Interface_One print() System.out.println('Democlass::Interface_One_Print ()'); } public void show(){ //Override Interface_Two show() System.out.println('DemoClass::Interface_Two_Show ()'); } } public class Main{ public static void main(String args()){ DemoClass obj = new DemoClass(); //create DemoClass object and call methods obj.print(); obj.show(); } }

Production:

exemple d

fusion de tri code source C ++

Comme indiqué ci-dessus, nous implémentons deux interfaces. Ensuite, nous remplaçons leurs méthodes respectives et les appelons dans la méthode principale.

L'héritage multiple en Java offre tous les avantages de l'héritage multiple dans le C ++. Mais contrairement à l'héritage multiple utilisant des classes, l'héritage multiple utilisant des interfaces est sans ambiguïté.

Héritage d'interface en Java: l'interface étend l'interface

Quand une classe implémente une interface, cela se fait en utilisant le ' met en oeuvre ' mot-clé. En Java, une interface peut hériter d'une autre interface. Ceci est fait en utilisant le ' étend ' mot-clé. Lorsqu'une interface étend une autre interface, elle s'appelle ' Héritage d'interface »En Java.

l

Le programme Java pour implémenter l'héritage d'interface est illustré ci-dessous.

//Interface_One declaration interface Interface_One{ void print(); } //Interface_Two declaration; inherits from Interface_One interface Interface_Two extends Interface_One{ void show(); } //multiple inheritance - DemoClass implementing Interface_Two class DemoClass implements Interface_Two{ public void print(){ //Override Interface_Two print() System.out.println('Democlass public class Main{ public static void main(String args()){ DemoClass obj = new DemoClass(); //create DemoClass object and call methods obj.print(); obj.show(); } }

Production:

sortie d

Nous avons modifié le même programme que nous avons utilisé pour l'héritage multiple en utilisant des interfaces pour démontrer l'héritage d'interface. Ici, nous étendons Interface_one dans Interface_two, puis nous allons implémenter Interface_two dans une classe. Lorsque les interfaces sont héritées, les deux méthodes sont disponibles pour la substitution.

Questions fréquemment posées

Q # 1) Quelle est l'utilisation de l'interface en Java?

Répondre: Une interface en Java est une entité utilisée pour atteindre 100% d'abstraction. Il ne peut contenir que des méthodes abstraites qui peuvent être remplacées par la classe implémentant l'interface.

L'interface agit en quelque sorte comme un plan de la classe dans lequel elle fournit à la classe les prototypes de méthode abstraite et les constantes statiques, puis la classe doit remplacer ces méthodes en implémentant l'interface.

Q # 2) Quels sont les avantages de l'interface en Java?

Répondre: Certains des avantages d'Interface sont les suivants:

  1. L'interface agit comme un modèle de la classe.
  2. L'interface fournit 100% d'abstraction en Java car elle possède toutes les méthodes abstraites.
  3. Les interfaces peuvent être utilisées pour obtenir un héritage multiple en Java. Java ne permet pas d'hériter de plusieurs classes, mais une classe peut implémenter plusieurs interfaces.

# 3) Une interface peut-elle avoir des méthodes?

Répondre: Les interfaces peuvent avoir des prototypes de méthodes et des constantes statiques et finales. Mais à partir de Java 8, les interfaces peuvent contenir des méthodes statiques et par défaut.

Q # 4) Pouvons-nous déclarer l'interface comme définitive?

Répondre: Non. Si nous déclarons une interface comme finale, alors la classe ne pourra pas l'implémenter. Sans être implémentée par aucune classe, l'interface ne servira à aucun but.

En savoir plus sur les interfaces

Les interfaces sont des plans comme la classe, mais elle n'aura que la déclaration de méthode. Il n’aura aucune méthode de mise en œuvre. Toutes les méthodes de l'interface sont abstraites publiques par défaut. L'interface Java 1.8 peut avoir des méthodes statiques et par défaut.

Les interfaces sont principalement utilisées dans les API.

Par exemple: Considérez que vous concevez le moteur d’un véhicule.

Lorsque vous avez terminé avec la partie matérielle, vous voulez que certaines des fonctionnalités logicielles soient implémentées par un client qui utilise votre moteur. Ainsi, dans ce cas, vous pouvez définir les fonctionnalités de votre moteur dans une interface.

Interface Engine { void changeGear(int a); void speedUp(int a); }

Règles à suivre pour l'interface

  • La classe qui implémente l'interface doit implémenter toutes les méthodes de l'interface.
  • Une interface peut contenir des variables finales.
public class Vehicle implements Engine { int speed; int gear; @Override public void speedUp(int a) { this.speed=a; System.out.println('speed'+speed); } @Override public void changeGear(int a) { this.gear=a; System.out.println('gear'+gear); } public static void main(String() args) { // TODO Auto-generated method stub Vehicle objv=new Vehicle(); objv.changeGear(3); objv.speedUp(70); } }

Règles à suivre pour l

Ici, la classe Vehicle est la sous-classe qui implémente l'interface du moteur.

Que sont les classes abstraites?

Une classe abstraite est comme une classe mais elle aura des méthodes abstraites et des méthodes concrètes. Les méthodes abstraites n'ont pas d'implémentation. Il n'aura que la déclaration de méthode.

Règles à suivre pour la classe abstraite

  • La classe abstraite ne peut pas être instanciée.
  • La classe enfant qui étend la classe abstraite doit implémenter toutes les méthodes abstraites de la classe parent ou la classe enfant doit être déclarée en tant que classe abstraite.

Lorsque vous souhaitez concevoir une implémentation partielle, vous pouvez opter pour une classe abstraite.

Exemple de programme de classe abstraite:

EmployeeDetails.java

public abstract class EmployeeDetails { private String name; private int emp_ID; public void commonEmpDetaills() { System.out.println('Name'+name); System.out.println('emp_ID'+emp_ID); } public abstract void confidentialDetails(int s,String p); }

Détails de l

La classe qui va étendre la classe abstraite.

HR.java

public class HR extends EmployeeDetails { private int salary; private String performance; @Override public void confidentialDetails(int s,String p) { this.salary=s; this.performance=p; System.out.println('salary=='+salary); System.out.println('performance=='+performance); } public static void main(String() args) { HR hr =new HR(); hr.confidentialDetails(5000,'good'); } }

hr-java

Points clés à noter:

  • Dans Interfaces, toutes les méthodes n'auront pas d'implémentation de méthode.
  • La classe qui implémente l'interface doit implémenter toutes les méthodes de cette interface particulière.
  • Les classes abstraites peuvent avoir des méthodes abstraites ainsi que des méthodes concrètes normales. Les méthodes abstraites n'ont pas d'implémentation.
  • La classe qui étend la classe abstraite doit avoir l'implémentation de toutes les méthodes abstraites de la classe abstraite.
  • Si la sous-classe n’a pas suffisamment d’informations pour implémenter les méthodes abstraites, la sous-classe doit être déclarée en tant que classe abstraite.

Conclusion

Dans ce tutoriel, nous avons présenté les concepts de base des interfaces en Java. Nous avons discuté de la définition de l'interface, ainsi que du besoin d'interfaces. Nous avons exploré leur syntaxe et leur définition de base. Ensuite, nous avons expliqué comment utiliser les interfaces pour lesquelles nous utilisons le mot-clé ‘implements’.

Nous avons appris à utiliser plusieurs interfaces et l'héritage d'interface en Java. En utilisant plusieurs interfaces, nous pouvons implémenter plusieurs héritages en Java. L'héritage d'interface se produit lorsqu'une interface étend une autre interface.

=> Visitez ici pour voir la série de formations Java pour tous

lecture recommandée

^