Qu'est ce qu'une interface en Java?

Interface est un contrat. Un simple exemple est un Locataire et Propriétaire 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, l'interface est un contact qui contient diverses méthodes (Déclaration) que la Partie doit implémenter (fournir des corps de méthode).Ici la première partie est la classe qui implémente l'interface et la seconde partie est le client et le chemin utiliser et l'interface est d'avoir "Référence d'interface" et "Objet de classe d'implémentation" : voici 3 composants: (Expliqué à l'aide d'un exemple)

Composant 1] Interface: Le contrat

interface myInterface{

 public void myMethod();

 }

Composant 2] Classe d'implémentation: Partie numéro 1

 class myClass implements myInterface {

 @Override

 public void myMethod() {

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

 }

 }

Composant 3] Code 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

 }

 }

Interface : Service de configuration requise.

Description : Supposons qu'un client ait besoin d'une fonctionnalité "c'est-à-dire d'une interface JDBC API" et d'un autre serveurApache , Jetty , WebServer ils fournissent tous des implémentations de cela. Il a donc délimité le document d'exigence quel fournisseur de services a fourni à l'utilisateur qui utilise la connexion de données avec ces serveurs Apache , Jetty , WebServer .

Une interface en java est un projet de classe. Il a des constantes statiques et des méthodes abstraites uniquement.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 le corps de la méthode. Il est utilisé pour obtenir une abstraction complète et un héritage multiple en Java. Une interface est une collection de méthodes abstraites. Une classe implémente une interface, héritant ainsi des méthodes abstraites de l'interface. Une interface est pas une classe. Écrire une interface est similaire à é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 est abstraite, toutes les méthodes de l'interface doivent être définies dans la classe.Étant donné que l'héritage multiple n'est pas autorisé en java, l'interface est le seul moyen d'implémenter l'héritage multiple. Voici un exemple pour comprendre 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();  
 }  
}

Interface est le plan d'une classe.

Il existe un concept de poo appelé Data abstractionsous lequel il y a deux catégories, l'une est abstract classet l'autre est 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 n'importe quel nombre d'interface et vous pouvez implémenter n'importe quel nombre de classe.

Si une classe implémente l'interface, la classe doit également implémenter les méthodes abstraites

L'interface ne peut pas être instanciée.

interface A() {
    void print()
}

Cette question a 6 ans et beaucoup de choses ont changé la définition de l'interface au fil des ans.

À Partir d'oracle 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 ne peut contenir que constantes, signatures de méthodes, méthodes par défaut, méthodes statiques et types imbriqués. Les corps de méthode existent uniquement pour les méthodes par défaut et les méthodes statiques. Les interfaces ne peuvent pas être instanciés - ils ne peuvent être implémentés que par des classes ou étendus par d'autres interfaces.

Jetez un oeil aux questions SE connexes pour une meilleure explication:

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

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

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, à la fois les méthodes et les variables, et les déclarations de méthodes non-static. Il n'est pas permis d'avoir des variables non-static.
Une déclaration d'une méthode diffère d'une méthode normale dans plusieurs choses; en voici une à titre d'exemple:

[public] [abstract] ReturnType methodName();

Ces déclarations peuvent être marquées comme public et abstract, représenté par [optional braces]. Il n'est pas nécessaire de le faire, car c'est la valeur par défaut. private, protected, package-private (aka. nothing) et le modificateur final ne sont pas autorisés et marqués comme une erreur du compilateur. Ils n'ont pas de mise en œuvre, il y a donc un point-virgule au lieu d'accolades.

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

À quoi cela sert
L'une de ses utilisations est qu'il soit utilisé comme visage pour un service. Lorsque deux parties travaillent ensemble pour former une relation de type demandeur et fournisseur de services, le fournisseur de services fournit le visage du service (à quoi ressemble le service) dans le forme d'une interface.
L'un des concepts de POO est "Abstraction", ce qui signifie cacher 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. Cela peut être réalisé à travers interface où dans chaque module est visualisé (et également mis en œuvre) pour travailler à travers l'interface d'un autre module

Une interface est une construction de type classe qui ne contient que des constantes et des méthodes abstraites (Introduction à la programmation java, n. d.). De plus, il peut étendre plus d'une interface par exemple une Superclasse. Java n'autorise qu'un seul héritage pour l'extension de classe mais autorise plusieurs extensions pour interfaces (Introduction à la programmation Java, s. 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. En outre, une interface peut hériter d'autres interfaces en utilisant le mot clé extends.

public interface NewInterface extends Interface1, ... , InterfaceN {

}

Référence

Introduction à la programmation Java. Interfaces et classes abstraites (n. d). Extrait le 10 mars 2017 de https://viewer.gcu.edu/7NNUKW

En général, nous préférons les interfaces lorsqu'il y a deux implémentations de plus que nous avons. Où l'interface est agit comme protocole.

Le codage à l'interface, pas les implémentations Le codage à l'interface fait un couple lâche.

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 des méthodes abstraites de l'interface. Avec des 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

De la dernière définition par Oracle , l'interface est:

Il y a un certain nombre de situations dans le génie logiciel quand il est important pour les groupes disparates de programmeurs d'accepter 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. D'une manière générale, les interfaces sont telles contrat.

Par exemple, imaginez un société futuriste où contrôlé par ordinateur les voitures robotisées transportent les passagers dans les rues de la ville sans être humaines opérateur. Les constructeurs automobiles écrivent des logiciels (Java, bien sûr) qui actionne l'automobile-arrêtez, démarrez, accélérez, tournez à gauche, et ainsi de suite. Un autre groupe industriel, instrument de guidage électronique fabricants, faire des systèmes informatiques qui reçoivent GPS (Global Système de positionnement) données de position et transmission sans fil du trafic conditions et utilisation que informations pour conduire la voiture.

Les constructeurs automobiles doivent publier une interface conforme aux normes de l'industrie cela explique en détail quelles méthodes peuvent être invoquées pour fabriquer la voiture déplacer (n'importe quelle voiture, de n'importe quel fabricant). Les fabricants de conseils peuvent ensuite, écrivez un logiciel qui invoque les méthodes décrites dans le interface pour commander la voiture. Aucun des deux groupes industriels n'a besoin de savoir comment le logiciel de l'autre groupe est implémenté. En fait, chaque groupe considère son logiciel très propriétaire et se réserve le droit de modifier à tout moment, tant qu'il continue à respecter les interface publiée.

[...] Une interface est un type de référence, similaire à une classe, qui peut contient uniquement des constantes, des signatures de méthode, des méthodes par défaut, des méthodes et types imbriqués. Les corps de méthode existent uniquement par défaut méthodes et méthodes statiques. Les interfaces ne peuvent pas être instanciées-elles ne peut être implémenté que par des classes ou étendu par d'autres interface.

L'utilisation la plus populaire des interfaces est comme API (Application Programming Interface) qui sont communs dans les produits logiciels commerciaux. En règle générale, une entreprise vend un progiciel contenant des méthodes complexes qu'une autre entreprise souhaite utiliser dans son propre produit logiciel.

Un exemple pourrait être un ensemble de méthodes de traitement d'image numérique qui sont vendues à des entreprises fabriquant des programmes graphiques pour l'utilisateur final.

La société de traitement d'images écrit son classes pour implémenter une interface, qu'il rend publique à ses clients. La société graphique appelle ensuite les méthodes de traitement d'image en utilisant les signatures et les types de retour définis dans l'interface. Bien que l'API de la société de traitement d'images soit rendue publique (à ses clients), son implémentation de l'API est gardée secrète - en fait, elle peut réviser l'implémentation à une date ultérieure tant qu'elle continue à implémenter l'interface d'origine sur laquelle ses clients se sont appuyés sur.

Découvrez à en savoir plus sur les interfaces.

En plus de ce que d'autres ont mentionné et par comparaison illogique c'est un travail de cadre pour les méthodes d'emballage afin qu'elles puissent être stockées dans variables.

Ainsi, à la volée, vous pouvez assimiler la variable d'interface à n'importe quelle méthode ou collection de méthodes au moins dans ce sens, une bonne raison pour laquelle vous voudriez généralement le faire est d'échapper à la logique répétitive qui sera certainement un ennemi de progrès dans la demi-vie de votre code à n'importe quel taux de décomposition, soyez prudent avec le scénario ci-dessous la discrétion de l'utilisateur est conseillée.

SCÉNARIO

Vous avez un jeu avec une méthode drawSillyThings() dans une classe SoulAvenger, qui doit dessiner des images ou des sprites. Maintenant, drawSillyThings() a une liste d'autres méthodes qu'il doit appeler pour dessiner un métamorphosé glorifié-âme-ranger après que l'utilisateur tue le faucheuse au niveau 5k, c'est-à-dire drawSillyThings() doit appeler l'un ou l'autre des inviteTheGrimReaper(), drawUpperCut(), drawTotalKO(), drawVictoryAndGlorifiedRanger(), drawDefeatAndMockery(), drawFightRecap() et drawGameOver() chaque fois que les bonnes situations se présentent pendant l'expérience de jeu, mais tout cela entraînerait une logique indésirable dans drawSillyThings() qui pourrait ralentir le jeu, c'est-à-dire

public static class SoulAvenger{

        public SoulAvenger(){
             //constructor logic
        }

        private void loadLevel5k(){...}

        private void dontAllowUserWinOnTime(){...}

        private void loadGrimReaperFight(){...}

        private void drawSillyThings(){
            ... //unaccounted game logic
            while(fighting_in_level_5k){
                while(soul_ranger_has_enough_lives){
                    if(game_state=fight)inviteTheGrimReaper();
                    else if(game_state=medium_blows)drawUpperCut();
                    else if(game_state=heavy_blows)drawTotalKO();
                    else if(game_state=lost)drawDefeatAndMockery();
                    else if(game_state=won)drawVictoryAndGlorifiedRanger();
                    else if(game_state=end)drawFightRecap();
                }else drawGameOver();
            }
        }
}

Le problème ici est les vérifications booléennes imbriquées en boucle qui doivent être effectuées à chaque fois que le âme-ranger est toujours en vie où comme vous pourriez simplement avoir une classe alternative qui s'assure que drawSillyThings() n'a pas besoin d'un game_state pour être vérifié à chaque fois afin d'appeler la bonne méthode, mais pour ce faire, vous devez stocker la bonne méthode dans une variable afin que par la suite vous puissiez un peu variable = new method et aussi un peu variable.invoke(). Si ce n'était pas quelque chose, jetez un oeil

public static class InterfaceTest{

    public interface Method{
        public void invoke();
    }

    public static void main(String[] args){
        //lets create and store a method in a variable shall we
        Method method_variable=new Method(){
            @Override
            public void invoke(){
                //do something        
            }
        };

        //lets call or invoke the method from the variable in order to do something
        method_variable.invoke();

        //lets change the method to do something else
        method_variable=new Method(){
            @Override
            public void invoke(){
                //do something else       
            }
        };

        //lets do something else
        method_variable.invoke();            

     }

}

C'était probablement ce que les gars de oracle avaient découvert qu'il manquait à Java plusieurs années avant que des rumeurs de certains développeurs planifiant une protestation massive ne fassent surface sur le Web, mais revenons au SoulAvenger, car le gameplay se produit, vous le feriez certainement je veux juste avoir un peu une variable être assimilée pour donner la bonne méthode à invoquer dans drawSillyThings() afin d'exécuter les choses d'une manière stupide donc

public static class SoulAvenger{

    private interface SillyRunner{
        public void run_things();
    }

    ...//soul avenging variables
    private SillyRunner silly_runner;

    public SoulAvenger(int game_state){
        //logic check is performed once instead of multiple times in a nested loop
        if(game_state=medium_blows){
            silly_runner=new SillyRunner(){
                @Override
                public void run_things(){
                    drawUpperCut();
                }
            };
        }else if(game_state=heavy_blows){
            silly_runner=new SillyRunner(){
                @Override
                public void run_things(){
                    drawTotalKO();
                }
            };
        }else if(game_state=lost){
            silly_runner=new SillyRunner(){
                @Override
                public void run_things(){
                    drawDefeatAndMockery();
                }
            };
        }else if(game_state=won){
            silly_runner=new SillyRunner(){
                @Override
                public void run_things(){
                    drawVictoryAndGlorifiedRanger();
                }
            };
        }else if(game_state=fight){
            silly_runner=new SillyRunner(){
                @Override
                public void run_things(){
                    drawFightRecap();
                }
            };

        }

    }

    private void loadLevel5k(){
        //an event triggered method to change how you run things to load level 5k
        silly_runner=new SillyRunner(){
            @Override
            public void run_things(){
                //level 5k logic
            }
        };
    }

    private void dontAllowUserWinOnTime(){
        //an event triggered method to help user get annoyed and addicted to the game
        silly_runner=new SillyRunner(){
            @Override
            public void run_things(){
                drawDefeatAndMockery();
            }
        };
    }

    private void loadGrimReaperFight(){
        //an event triggered method to send an invitation to the nearest grim-reaper
        silly_runner=new SillyRunner(){
            @Override
            public void run_things(){
                inviteTheGrimReaper();
            }
        };
    }

    private void drawSillyThings(){
        ...//unaccounted game logic
        while(fighting_in_level_5k){
            while(soul_ranger_has_enough_lives){
                silly_runner.run_things();
            }
        }
    }

}

Maintenant, le drawSillyThings() n'a pas besoin d'effectuer de if logique tout en dessinant parce que lorsque les bons événements sont déclenchés, le {[23] } est assimilé à sa run_things() méthode invoque une méthode différente utilisant ainsi une variable pour stocker et invoquer une méthode un peu-ish bien que dans le monde réel du jeu(je veux dire en fait dans un console) plusieurs threads fonctionneront de manière asynchrone pour modifier les variables d'interface afin d'exécuter différents morceaux de code avec le même appel.

Une interface en java est un type spécial de classe Abstraite, l'Interface a fourni l'Abstraction à 100%, mais comme java introduit de nouvelles fonctionnalités dans java 8, la signification de l'interface entière est le changement. Les interfaces sont utilisées pour dire ce qui doit être fait. Mais en raison de nouvelles fonctionnalités, nous donnons maintenant des implémentations de méthodes dans l'Interface, cela a changé la signification de l'Interface. Dans l'interface, la méthode est public abstract par défaut

interface Bird{
        void sound();
         void eat();
        }

Java ne fournit pas la fonctionnalité d'héritages multiples une classe n'a pas deux parents, mais nous étendons plusieurs interfaces en java.

Une interface est un contrat entre le système et l'environnement externe. Plus précisément à Java - un contrat pour une classe (pour un comportement spécifique), implémenté sous une forme qui ressemble à une classe abstraite pure.