Qu'est ce qu'une interface en Java?

Juste comme un contrepoint à cette question: qu'est ce qu'une interface en Java?

Sommes-nous à droit de vote de votre réponse à votre question, que vous avez posté immédiatement ?
Votebait, à mon humble avis.
Flagrant votebait, oui. Pourquoi est-ce un problème? C'est la question légitime? Il ajoute à la connaissance stockés dans des? Ceux-ci semblent comme plus pertinente préoccupations que mes points de réputation.
Je pense que cela devrait au moins être de la communauté-wiki.
j'ai eu le même idear après la lecture de "Ce qui est une classe abstraite Java". Mais tout cela est plus facile pour google, qu'à rechercher dans la.
Je dois avouer que c'était assez difficile de copier et de coller le lien de Wikipedia 🙂
Pour l'anecdote, c'est pas que je me soucie grandement sur mon score de réputation, c'est juste qu'il semble hypocrite de me critiquer pour votebaiting ici. N'est pas du tout le point de réputation pour encourager les gens à écrire de bons postes, ce qui rend chaque bon de poster ici un votebait? Il semble idiot. De toute façon, la communauté wikified comme le suggère.

InformationsquelleAutor |

53

Une interface est une forme particulière d'une classe abstraite qui ne met pas en œuvre toutes les méthodes. En Java, vous créez une interface comme ceci:
```
interface Interface
{
    void interfaceMethod();
}
```
Depuis l'interface ne peut pas mettre en œuvre toutes les méthodes, il est implicite que la chose entière, y compris toutes les méthodes, sont à la fois public et abstraite (abstract en Java termes signifie "pas mis en œuvre 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 d'implémenter l'interface. De nombreuses classes peuvent implémenter une interface et une classe peut implémenter plusieurs 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 ceci:
```
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 pourriez jamais procédez de la manière suivante:
```
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, c'est que y est de type interfaceA, et 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.

Je l'ai mentionné plus tôt que les interfaces sont juste une forme particulière 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ériter 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 mettre en œuvre des méthodes.
```
interface Interface
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}
```
L'interface ci-dessus génère une erreur de compilation, car il a une implémentation pour implementedMethod(). Si vous vouliez mettre en œuvre la méthode, mais ne pas être en mesure d'instancier la classe, vous auriez à le faire comme ceci:
```
abstract public class AbstractClass
{
    public void implementedMethod()
    {
        System.out.println("implementedMethod()");
    }
}
```
Ce n'est pas beaucoup d'une classe abstraite car aucun de ses membres sont abstraites, mais il est légal de Java.

L'autre différence entre les interfaces et les classes abstraites est qu'une classe peut hériter de plusieurs interfaces, mais ne peut hériter 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, pas parce que les classes sont toutes vides, mais parce que InheritsFromTwoAbstractClasses est d'essayer d'hériter de deux classes abstraites, ce qui est illégal. La suite 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 pour la deuxième 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()"); }
}
```
Il n'y a pas de problème avec le code ci-dessus, car InterfaceA et InterfaceB n'ont rien à cacher. Il est facile de dire qu'un appel à method imprimé "méthode()".

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 que celle de notre exemple précédent, sauf que parce que nous sommes autorisés à mettre en œuvre des méthodes dans les classes abstraites, nous l'avons fait, et parce que nous n'avons pas à mettre en œuvre, déjà mis en œuvre des méthodes dans une classe qui hérite, nous n'avons pas. Mais vous avez peut-être remarqué, il y a un problème. Ce qui se passe lorsque nous appelons new InheritsFromTwoAbstractClasses().method()? Est-il print "Bonjour" ou "au Revoir"? Vous ne le savez probablement pas, et ni ne le compilateur Java. Une autre langue, C++ ont permis ce genre d'héritage et ils ont résolu ces problèmes par des moyens qui étaient souvent très compliqué. Pour éviter ce genre d'ennuis, Java a décidé de faire de cet "héritage multiple" illégale.

L'inconvénient de Java est la solution que le suivant ne peut pas être fait:
```
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 "mixin" ou les classes qui ne sont pas destinés à être instancié mais d'ajouter des fonctionnalités pour les classes qu'ils sont "mélangés dans les" 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 parce que Java ne le permet pas.

(Je sais que c'est un long post, donc si il y a des erreurs dans s'il vous plaît laissez-moi savoir et je vais les corriger.)
- Une petite remarque, vous appelez votre classe "InheritsFromTwoInterfaces", mais lorsque vous utilisez des interfaces, vous êtes habituellement ne parle pas d'Hériter, mais la mise en Œuvre, parce que l'interface ne contient aucune logique et/ou la mise en œuvre, vous pouvez hériter. Il est donc préférable de parler de la mise en œuvre (c'est du moins ce qu'ils ont appris de moi).
- Vous êtes correct. Cependant, je ne pense pas que la distinction entre "hérite" et "met en œuvre" est tout ce qui importe, surtout en considérant que, dans de nombreux cas, on hérite à la fois et met en œuvre une classe abstraite. J'ai choisi de garder le schéma de nommage pour être moins à confusion.
- l'interface est semblable à un tuyau à travers lequel vous pouvez accéder aux différentes classes d'objets d'une manière standardisée. Depuis Java vous ne pouvez pas prolonger plus d'une classe, l'interface est là pour satisfaire le besoin pour plus d'un héritage complexe.
- Non, les interfaces ne sont pas utilisées pour l'héritage. Les Interfaces sont des "contrats" qui définissent les fonctions et les membres d'une classe doit avoir lors de l'implémentation de l'interface. Interfaces pas être utilisée pour contourner le "étendre problème" (qui ne vous permet pas de prolonger de 2 ou plusieurs classes). lors de l'extension d'une classe, la fonctionnalité de la classe vous étendez est toujours accessible (par le biais de l'extension de la classe), mais depuis une interface n'a pas de fonctionnalité vous ne pouvez pas l'utiliser pour omettre l'héritage multiple restriction, parce que les membres et les fonctions doivent être écrites dans la mise en œuvre de la classe.
InformationsquelleAutor Imagist
1

Interface est un contrat. Un simple exemple est un Locataire et Propriétaire qui sont les deux parties et la contrat est le Contrat de Location. Contrat de location contient divers clause de Locataires à les suivre. De même, l'Interface est un contact qui contient plusieurs méthode (Déclaration) dont la Partie est à mettre en œuvre (fournir le corps de méthode).Ici partie est la classe qui implémentent l'interface et la deuxième partie est Client et la façon de les utiliser et l'interface est d'avoir “Référence de l'Interface” et “Objet de la mise en Œuvre de la classe”: ci-dessous sont 3 composantes:(Expliqué avec l'aide de l'exemple)

Composante 1] De L'Interface : Le Contrat
```
interface myInterface{

 public void myMethod();

 }
```
Le volet 2] la mise en Œuvre de la Classe : Partie du numéro de 1
```
 class myClass implements myInterface {

 @Override

 public void myMethod() {

 System.out.println("in MyMethod");

 }

 }
```
Composante 3] code de Client : numéro 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

 }

 }
```
InformationsquelleAutor
0

Une interface en java est un projet de classe. Il a des constantes statiques et méthodes abstraites seulement.L'interface en java est un mécanisme destiné à réaliser pleinement l'abstraction. Il peut y avoir que des méthodes abstraites dans l'interface java pas de corps de méthode. Il est utilisé pour réaliser pleinement l'abstraction et l'héritage multiple en Java. Une interface est un ensemble de méthodes abstraites. Une classe implémente une interface, héritant ainsi les méthodes abstraites de l'interface.
Une interface n'est pas une classe. L'écriture d'une interface est similaire à l'écriture d'une classe, mais ils 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 est abstraite, toutes les méthodes de l'interface doivent être définies dans la classe.Depuis l'héritage multiple n'est pas autorisé en java, donc l'interface est la seule façon de mettre en œuvre l'héritage multiple.
Voici un exemple pour la compréhension de l'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();  
 }  
}
```
InformationsquelleAutor
0

Interface est le modèle d'une classe.

Il est l'un de la programmation orientée objet concept appelé abstraction de Données sous qu'il y a deux catégories, l'une est classe abstraite et un autre interface.

Classe abstraite réalise seulement partielle de l'abstraction mais l'interface réalise pleinement l'abstraction.

Dans l'interface, il n'est abstrait des méthodes et des variables final..vous pouvez s'étend à un nombre quelconque de l'interface et vous pouvez implémenter un certain nombre de classes.

Si toute la classe est la mise en œuvre de l'interface, puis la classe doit implémenter les méthodes abstraites trop

Interface ne peut pas être instanciée.
```
interface A() {
    void print()
}
```
InformationsquelleAutor
0

Cette question est de 6 ans et beaucoup de choses ont changé la définition de l'interface au cours des années.

À partir d'oracle la documentation page ( post Java 8 release) :

Dans le langage de programmation Java, une interface est un type de référence, similaire à une classe, qui peut uniquement contenir des constantes, des signatures de méthode, par défaut, les méthodes, les méthodes statiques et les types imbriqués. Le corps de méthode existent seulement pour les méthodes par défaut et méthodes statiques. Les Interfaces ne peuvent pas être instanciées—elles ne peuvent être implémentées par les classes ou prolongé par d'autres interfaces.

Regarder liées SE questions pour mieux expliquer:

Est-il plus une interface que d'avoir les bonnes méthodes

Quelle est la différence entre une interface et une classe abstraite?

InformationsquelleAutor
0

Ce que c'est

Un interface est un type de référence, tout comme un classe est. 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'une normale classe peut contenir. Cela inclut tout ce qui est static, les deux méthodes et variables, et nonstatic des déclarations de méthode. Il n'est pas permis nonstatic variables.

Une déclaration d'une méthode diffère de la méthode habituelle en plusieurs choses; ici est un exemple:
```
[public] [abstract] ReturnType methodName();
```
Ces déclarations peuvent être marquées comme public et abstract, comme représenté avec [optional braces]. Il n'est pas nécessaire de le faire, comme il l'est par défaut. private, protected, package-private (aka. rien) et le final modificateur ne sont pas autorisés et marqué comme une erreur du compilateur. Ils ne l'ont pas mise en œuvre, il y a donc un point-virgule au lieu d'accolades.

De Java 8, ils peut tenir non-static méthodes avec de mise en œuvre, ceux-ci doivent être marqués avec le default modificateur. Cependant, les mêmes restrictions que pour les autres modificateurs s'appliquent (en ajoutant que strictfp est maintenant valide et abstract est pas plus).

Ce que c'est utile pour

Une de ses utilisations est pour qu'il soit utilisé comme un visage pour un service. Lorsque les deux parties à travailler ensemble pour former un service demandeur & prestataire de service de type de relation, le fournisseur de services fournit le visage du service (comme à ce que le service ressemble) sous la forme d'une interface.

L'un des concept de la programmation orientée objet est "l'Abstraction", ce qui signifie pour se cacher de travail complexes des systèmes et de montrer que ce qui est nécessaire pour comprendre le système. Cela permet de visualiser le fonctionnement d'un système complexe.
Ceci peut être réalisé par interface où dans chaque module est visualisé (et aussi mis en place) à travailler par le biais de l'interface d'un autre module

InformationsquelleAutor
0

Une interface est une classe de construction qui ne contient que des constantes et méthodes abstraites (Introduction à la programmation java, n.d.). En outre, elle peut s'étendre à plus d'une interface par exemple un super-classe. Java permet seulement d'héritage unique pour l'extension de classe, mais permet à de multiples extensions pour
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. Toutefois, ils ne peuvent pas contenir des méthodes abstraites. Aussi, une interface peut hériter d'autres interfaces à l'aide du mot-clé extends.
```
public interface NewInterface extends Interface1, ... , InterfaceN {

}
```
Référence

Introduction à la Programmation Java. Les Interfaces et les classes Abstraites (n.d). Extrait le 10 Mars 2017 de https://viewer.gcu.edu/7NNUKW
- Assurez-vous d'utiliser les options de mise en forme pour être clair, où vous avez le code, et quand les explications: code à l'aide de ` et blocs ```
InformationsquelleAutor
0

En général, on préfère les interfaces lorsqu'il y a deux sont plus implémentations que nous avons. Où l'Interface est agit comme protocole.

De codage de l'interface, pas implémentations de Codage de l'interface rend vaguement couple.

Une interface est un type de référence en Java. Il est similaire à la classe. C'est une collection de méthodes abstraites. Une classe implémente une interface, héritant ainsi les méthodes abstraites de l'interface. Avec des méthodes abstraites, une interface peut également contenir des constantes, des méthodes par défaut, les méthodes statiques et les types imbriqués. pour plus d' détails

InformationsquelleAutor
0

À partir de la dernière définition par Oracle, l'Interface est:

Il y a un certain nombre de situations dans l'ingénierie du logiciel lorsqu'il est
important pour les différents groupes de programmeurs afin de convenir d'un "contrat"
qui définit comment leur logiciel interagit. Chaque groupe devrait être
capable d'écrire leur code sans aucune connaissance de la façon dont les autres
code est écrit. En règle générale, les interfaces sont tels
des contrats.

Par exemple, imaginez une société futuriste où contrôlés par l'ordinateur
robotique voitures de transport de passagers à travers les rues de la ville sans un homme
de l'opérateur. Les constructeurs automobiles créer un logiciel (Java, bien sûr)
qui exploite l'automobile—arrêter, démarrer, accélérer, tourner à gauche, et
ainsi de suite. Un autre groupe industriel, électronique, instrument d'orientation
les fabricants, rendre les systèmes informatiques qui reçoivent GPS (Global
Système de positionnement) des données sur la position et la transmission sans fil de la circulation
les conditions et l'utilisation de cette information pour conduire la voiture.

Les constructeurs automobiles doivent publier un standard de l'industrie de l'interface
qui énonce en détail les méthodes qui peuvent être invoquées pour rendre la voiture
déplacer (voiture, à partir de n'importe quel fabricant). Les conseils les fabricants peuvent
puis d'écrire des logiciels qui invoque les méthodes décrites dans la
l'interface de commande de la voiture. Ni le groupe industriel a besoin de savoir
comment les autres du groupe logiciel est mis en œuvre. En fait, chaque groupe
considère que son logiciel très exclusif et se réserve le droit de
modifier à tout moment, tant qu'il continue à respecter les
publié interface.

[...] Une interface est un type de référence, similaire à une classe, qui peut
contenant uniquement des constantes, les signatures de méthodes, méthodes par défaut, statique
les méthodes et les types imbriqués. Le corps de méthode existent seulement pour défaut
des méthodes et des méthodes statiques. Les Interfaces ne peuvent pas être instanciées—ils
ne peut être mis en œuvre par les classes ou prolongé par d'autres interfaces.

Utilisation la plus populaire des interfaces est que les Api (Application Programming Interface) qui sont communs dans les logiciels commerciaux de produits. Généralement, une entreprise vend un logiciel qui contient des méthodes complexes qu'une autre compagnie veut les utiliser dans son propre logiciel.

Un exemple pourrait être un paquet de l'image numérique de méthodes de traitement qui sont vendus à des entreprises de fabrication de l'utilisateur final des programmes graphiques.

Le traitement de l'image de la société, écrit-ses classes à implémenter une interface, qui elle rend public à ses clients. Le graphique de la société invoque ensuite les méthodes de traitement d'images en utilisant les signatures et les types de retour définies dans l'interface. Alors que le traitement de l'image de la société API est rendu public (à ses clients, mise en œuvre de l'API est gardé comme un secret bien gardé—en fait, il peut réviser la mise en œuvre à une date ultérieure, tant qu'il continue de mettre en œuvre l'interface d'origine que ses clients ont invoqué.

Découvrez à en savoir plus sur les interfaces.

InformationsquelleAutor

Vous devez vous connecter pour publier un commentaire.