Qu'est-ce qu'une interface en Java?
Juste comme un contrepoint à cette question : qu'est-ce qu'une interface en Java?
Une interface est une forme spéciale d'une classe abstraite qui n'implémente aucune méthode. En Java, vous créez une interface comme celle-ci:
interface Interface
{
void interfaceMethod();
}
Etant donné que l'interface ne peut implémenter aucune méthode, cela implique que tout, y compris toutes les méthodes, est à la fois public et abstrait (résumé en langage Java signifie "non implémenté par cette classe"). Donc, l'interface ci-dessus est identique à l'interface ci-dessous:
public interface Interface
{
abstract public void interfaceMethod();
}
Pour utiliser cette interface, il vous suffit de l'implémenter. De nombreuses classes peuvent implémenter une interface et une classe peut implémenter de nombreuses interfaces:
interface InterfaceA
{
void interfaceMethodA();
}
interface InterfaceB
{
void interfaceMethodB();
}
public class ImplementingClassA
implements InterfaceA, InterfaceB
{
public void interfaceMethodA()
{
System.out.println("interfaceA, interfaceMethodA, implementation A");
}
public void interfaceMethodB()
{
System.out.println("interfaceB, interfaceMethodB, implementation A");
}
}
public class ImplementingClassB
implements InterfaceA, InterfaceB
{
public void interfaceMethodA()
{
System.out.println("interfaceA, interfaceMethodA, implementation B");
}
public void interfaceMethodB()
{
System.out.println("interfaceB, interfaceMethodB, implementation B");
}
}
Maintenant, si vous vouliez, vous pourriez écrire une méthode comme celle-ci:
public void testInterfaces()
{
ImplementingClassA u = new ImplementingClassA();
ImplementingClassB v = new ImplementingClassB();
InterfaceA w = new ImplementingClassA();
InterfaceA x = new ImplementingClassB();
InterfaceB y = new ImplementingClassA();
InterfaceB z = new ImplementingClassB();
u.interfaceMethodA();
// prints "interfaceA, interfaceMethodA, implementation A"
u.interfaceMethodB();
// prints "interfaceB, interfaceMethodB, implementation A"
v.interfaceMethodA();
// prints "interfaceA, interfaceMethodA, implementation B"
v.interfaceMethodB();
// prints "interfaceB, interfaceMethodB, implementation B"
w.interfaceMethodA();
// prints "interfaceA, interfaceMethodA, implementation A"
x.interfaceMethodA();
// prints "interfaceA, interfaceMethodA, implementation B"
y.interfaceMethodB();
// prints "interfaceB, interfaceMethodB, implementation A"
z.interfaceMethodB();
// prints "interfaceB, interfaceMethodB, implementation B"
}
Cependant, vous pouvez jamais faire ce qui suit:
public void testInterfaces()
{
InterfaceA y = new ImplementingClassA();
InterfaceB z = new ImplementingClassB();
y.interfaceMethodB(); // ERROR!
z.interfaceMethodA(); // ERROR!
}
La raison pour laquelle vous ne pouvez pas faire cela est que y est de type interfaceA et qu'il n'y a pas de interfaceMethodB() dans interfaceA. De même, z est de type interfaceB et il n'y a pas de interfaceMethodA() dans interfaceB.
J'ai mentionné précédemment que les interfaces ne sont qu'une forme spéciale d'une classe abstraite. Pour illustrer ce point, regardez le code suivant.
interface Interface
{
void abstractMethod();
}
abstract public class AbstractClass
{
abstract public void abstractMethod();
}
Vous hériteriez de ces classes presque exactement de la même manière:
public class InheritsFromInterface
implements Interface
{
public void abstractMethod() { System.out.println("abstractMethod()"); }
}
public class InteritsFromAbstractClass
extends AbstractClass
{
public void abstractMethod() { System.out.println("abstractMethod()"); }
}
En fait, vous pouvez même changer l'interface et la classe abstraite comme ceci:
interface Interface
{
void abstractMethod();
}
abstract public class AbstractClass
implements Interface
{
abstract public void abstractMethod();
}
public class InheritsFromInterfaceAndAbstractClass
extends AbstractClass implements Interface
{
public void abstractMethod() { System.out.println("abstractMethod()"); }
}
Cependant, il existe deux différences entre les interfaces et les classes abstraites.
La première différence est que les interfaces ne peuvent pas implémenter de méthodes.
interface Interface
{
public void implementedMethod()
{
System.out.println("implementedMethod()");
}
}
L'interface ci-dessus génère une erreur de compilation parce qu'elle a une implémentation pour implementedMethod(). Si vous voulez implémenter la méthode sans pouvoir instancier la classe, vous devez le faire comme ceci:
abstract public class AbstractClass
{
public void implementedMethod()
{
System.out.println("implementedMethod()");
}
}
Ce n'est pas vraiment une classe abstraite car aucun de ses membres n'est abstrait, mais il s'agit de Java légal.
L'autre différence entre les interfaces et les classes abstraites est qu'une classe peut hériter de plusieurs interfaces, mais seulement d'une classe abstraite.
abstract public class AbstractClassA { }
abstract public class AbstractClassB { }
public class InheritsFromTwoAbstractClasses
extends AbstractClassA, AbstractClassB
{ }
Le code ci-dessus génère une erreur de compilation, non pas parce que les classes sont vides, mais parce que InheritsFromTwoAbstractClasses tente d'hériter de deux classes abstraites, ce qui est illégal. Ce qui suit est parfaitement légal.
interface InterfaceA { }
interface InterfaceB { }
public class InheritsFromTwoInterfaces
implements InterfaceA, InterfaceB
{ }
La première différence entre les interfaces et les classes abstraites est la raison de la seconde différence . Regardez le code suivant.
interface InterfaceA
{
void method();
}
interface InterfaceB
{
void method();
}
public class InheritsFromTwoInterfaces
implements InterfaceA, InterfaceB
{
void method() { System.out.println("method()"); }
}
Le code ci-dessus ne pose pas de problème car InterfaceA et InterfaceB n'ont rien à cacher. Il est facile de dire qu'un appel à method affichera "method ()".
Maintenant, regardez le code suivant:
abstract public class AbstractClassA
{
void method() { System.out.println("Hello"); }
}
abstract public class AbstractClassB
{
void method() { System.out.println("Goodbye"); }
}
public class InheritsFromTwoAbstractClasses
extends AbstractClassA, AbstractClassB
{ }
C'est exactement la même chose que notre autre exemple, excepté que, comme nous sommes autorisés à implémenter des méthodes dans des classes abstraites, et que nous n'avons pas à implémenter de méthodes déjà implémentées dans une classe héritante, nous ne l'avons pas fait. Mais vous avez peut-être remarqué qu'il y a un problème. Que se passe-t-il lorsque nous appelons new InheritsFromTwoAbstractClasses().method()? Est-ce qu'il affiche "Bonjour" ou "Au revoir"? Vous ne le savez probablement pas, pas plus que le compilateur Java. Un autre langage, le C++, permettait ce type d’héritage et résolvait ces problèmes de manière très compliquée. Pour éviter ce genre de problème, Java a décidé de rendre illégal cet "héritage multiple".
L'inconvénient de la solution de Java est que l'on ne peut pas faire ce qui suit:
abstract public class AbstractClassA
{
void hi() { System.out.println("Hello"); }
}
abstract public class AbstractClassB
{
void bye() { System.out.println("Goodbye"); }
}
public class InheritsFromTwoAbstractClasses
extends AbstractClassA, AbstractClassB
{ }
AbstractClassA et AbstractClassB sont des "mixins" ou des classes qui ne sont pas destinées à être instanciées mais qui ajoutent des fonctionnalités aux classes dans lesquelles elles sont "mélangées" par héritage. Il n'y a évidemment aucun problème à comprendre ce qui se passe si vous appelez new InheritsFromTwoAbstractClasses().hi() ou new InheritsFromTwoAbstractClasses().bye(), mais vous ne pouvez pas le faire car Java ne le permet pas.
(Je sais que c'est un long post, donc s'il y a des erreurs, merci de me le faire savoir et je les corrigerai.)
L'interface est un contrat. Un simple exemple est un Locataire et Propriétaire qui sont les deux parties et le contrat est le Contrat de location . Le contrat de location contient diverses clauses que les locataires doivent suivre. De même, Interface est un contact qui contient diverses méthodes (déclaration) que le parti doit implémenter (fournir des corps de méthodes). d’interface ”et“ Objet de la classe d’implémentation ”: voici 3 composants: (expliqués à l’aide de l’exemple)
Composante 1] Interface: le contrat
interface myInterface{
public void myMethod();
}
Composante 2] Classe implémentée: Partie numéro 1
class myClass implements myInterface {
@Override
public void myMethod() {
System.out.println("in MyMethod");
}
}
Composant 3] Code du client: numéro de partie 2
Client.Java
public class Client {
public static void main(String[] args) {
myInterface mi = new myClass();
// Reference of Interface = Object of Implementing Class
mi.myMethod(); // this will print in MyMethod
}
}
Une interface est une construction de type classe qui contient uniquement des constantes et des méthodes abstraites (Introduction à la programmation Java, n.d.). De plus, il peut étendre plusieurs interfaces, par exemple une Superclasse. Java n'autorise qu'un seul héritage pour l'extension de classe, mais plusieurs extensions pour les interfaces (Introduction à la programmation Java, n.d.). Par exemple,
public class NewClass extends BaseClass
implements Interface1, ..., InterfaceN {
...
}
Deuxièmement, les interfaces peuvent être utilisées pour spécifier le comportement des objets d'une classe. Cependant, ils ne peuvent pas contenir de méthodes abstraites. En outre, une interface peut hériter d’autres interfaces à l’aide du mot-clef
public interface NewInterface extends Interface1, ... , InterfaceN {
}
Référence
Introduction à la programmation Java. Interfaces et classes abstraites (n.d). Récupéré le 10 mars 2017 de https://viewer.gcu.edu/7NNUKW
Cette question a 6 ans et beaucoup de choses ont changé la définition d'interface au fil des ans.
Depuis Oracle documentation page (postérieure à Java 8):
Dans le langage de programmation Java, une interface est un type de référence, similaire à une classe, qui ne peut contenir que des constantes, des signatures de méthodes, des méthodes par défaut, des méthodes statiques et des types imbriqués . Les corps de méthodes n'existent que pour les méthodes par défaut et les méthodes statiques. Les interfaces ne peuvent pas être instanciées - elles ne peuvent être implémentées que par des classes ou étendues par d'autres interfaces.
Jetez un coup d'œil aux questions SE associées pour une meilleure explication:
Y at-il plus à une interface que d'avoir les bonnes méthodes
Quelle est la différence entre une classe d'interface et abstraite?
Ce que c'est
Un interface est un type de référence, tout comme un class is. Ce sont les deux principaux types de référence en Java.
Ce qu'il contient
Un interface peut contenir un sous-ensemble de ce qu'un normal class peut contenir. Cela inclut tout ce qui est static, les méthodes et les variables, ainsi que les déclarations de méthode non -static. Il n’est pas permis d’avoir des variables non-static.
La déclaration d’une méthode diffère d’une méthode normale à plusieurs égards; en voici un exemple:
[public] [abstract] ReturnType methodName();
Ces déclarations peuvent être marquées comme suit: public et abstract, comme indiqué par [optional braces]. Il n'est pas nécessaire de le faire, car c'est la valeur par défaut. private, protected, package-private (autrement dit rien) et le modificateur final ne sont pas autorisés et sont marqués comme une erreur du compilateur. Ils n'ont pas d'implémentation, donc il y a un point-virgule au lieu d'accolades.
Depuis Java 8, ils can conservent des méthodes non -static avec une implémentation, elles doivent être marquées avec le modificateur default. Cependant, les mêmes restrictions que pour les autres modificateurs s'appliquent (en ajoutant que strictfp est maintenant valide et que abstract n'est plus).
A quoi ça sert
L’une de ses utilisations est qu’il soit utilisé comme visage pour un service. Lorsque deux parties travaillent ensemble pour créer une relation du type demandeur de service & fournisseur de service, celui-ci fournit le visage du service (en ce qui concerne l'aspect du service) sous la forme d'une interface.
Un des OOP concepts est "Abstraction", qui consiste à dissimuler le fonctionnement complexe des systèmes et à ne montrer que ce qui est nécessaire pour comprendre le système. Cela aide à visualiser le fonctionnement d'un système complexe. Ceci peut être réalisé avec interface où dans chaque module est visualisé (et également implémenté) pour fonctionner à travers l'interface d'un autre module
Interface est le modèle d'une classe.
Il existe un concept oop appelé Abstraction de données sous lequel il existe deux catégories: l’une classe abstraite et l’autre/ interface .
La classe abstraite ne réalise qu'une abstraction partielle mais l'interface réalise une abstraction complète.
Dans l'interface, il n'y a que des méthodes abstraites et des variables finales. Vous pouvez étendre un nombre quelconque d'interfaces et vous pouvez implémenter un nombre quelconque de classes.
Si une classe implémente l'interface, elle doit également implémenter les méthodes abstraites.
L'interface ne peut pas être instanciée.
interface A() {
void print()
}
Une interface en Java est un plan détaillé d'une classe. Il a uniquement des constantes statiques et des méthodes abstraites. L'interface en Java est un mécanisme permettant d'obtenir une abstraction complète. Il ne peut y avoir que des méthodes abstraites dans l'interface Java, pas un corps de méthode. Il est utilisé pour obtenir une abstraction complète et un héritage multiple en Java. Une interface est un ensemble de méthodes abstraites. Une classe implémente une interface, héritant ainsi des méthodes abstraites de l'interface. Une interface n'est pas une classe. Écrire une interface est semblable à écrire une classe, mais ce sont deux concepts différents. Une classe décrit les attributs et les comportements d'un objet. Une interface contient des comportements (méthodes abstraites) qu'une classe implémente. À moins que la classe qui implémente l'interface soit abstraite, toutes les méthodes de l'interface doivent être définies dans la classe.Lorsque l'héritage multiple n'est pas autorisé en Java. l'interface est donc le seul moyen d'implémenter l'héritage multiple. Voici un exemple de compréhension d'interface
interface Printable{
void print();
}
interface Showable{
void print();
}
class testinterface1 implements Printable,Showable{
public void print(){System.out.println("Hello");}
public static void main(String args[]){
testinterface1 obj = new testinterface1();
obj.print();
}
}
En général, nous préférons les interfaces lorsqu'il y a deux implémentations supplémentaires. Où Interface fait office de protocole.
Le codage vers l'interface, pas les implémentations Le codage vers l'interface permet un couplage lâche.
Une interface est un type de référence en Java . C'est semblable à la classe. C'est une collection de méthodes abstraites. Une classe implémente une interface, héritant ainsi des méthodes abstraites de l'interface. Outre les méthodes abstraites, une interface peut également contenir des constantes, des méthodes par défaut, des méthodes statiques et des types imbriqués. pour plus de détails