Du début java8, l'interface est pas seulement un lieu que les déclarations des méthodes, nous pouvons quand la méthode déclarant, une méthode pour la mise en œuvre par défaut, que nous appelons la méthode d'interface par défaut, de sorte que tous les sous-classe qui implémente cette interface peut contenir l'implémentation par défaut de cette méthode.
I. Contexte introduction procédé d'interface par défaut
java8 peut être considéré comme l'un des, mais après tant d'années de développement et de l'itération, la source java semblent les plus mise à jour de la version java version change processus itératif (nous devrions être heureux avec le temps, avant d'être immortel,) d'être un monstre d'aller à la guerre à un tel volume, certainement pas facile. Alors, quand pour la première fois voir la méthode interface par défaut java8 du temps, je pense que c'est la première java concepteur avant le remplissage creuser la fosse.
Les explications que nous connaissons ces dernières java8 ajoutent un certain nombre de méthodes sur les interfaces existantes, telles que la liste des sort(Comparator<? super E> c)méthodes. Si vous suivez les idées de conception avant interface java8, lorsqu'il est ajouté à une déclaration de méthode d'interface, la classe qui implémente l'interface doit être ajoutée pour obtenir la méthode appropriée pour nouvellement ajouté. Considérer la compatibilité, ce n'est pas souhaitable, il était une fosse, et les nouvelles fonctionnalités et les exigences ont dû ajouter quelques nouvelles méthodes pour l'interface, afin d'avoir les deux poissons et la patte d'ours, les concepteurs de java8 proposé méthode d'interface par défaut concept.
Dans cette optique, la méthode d'interface par défaut semble concepteurs de api développés de nous les développeurs ordinaires aussi une distance, pensez un peu Tucson casser, même si nous ne devons pas concevoir jdk, mais notre processus de développement quotidien il y avait encore un besoin de fournir des services à d'autres parties appels api, lorsque nous mettons à jour notre api, quand il est la méthode par défaut peut être utilisé pour fournir des fonctionnalités plus avancées, tout en conservant la compatibilité.
II. Les définitions de méthode d'interface par défaut
La définition de la méthode d'interface par défaut est très simple, tant que l'ancienne méthode pour ajouter une définition de l'interface defaultmots - clés, les éléments suivants:
public interface A {
/ **
* La définition de la méthode par défaut
* /
Procédé défaut void () {
System.out.println ( « Ceci est une méthode par défaut! »);
}
}
Lorsque nous définissons une méthode par défaut, toutes les sous-classes qui implémente sont détenues indirectement cette interface par la méthode. Ou voulez-vous comme moi sentir de plus en plus comme des interfaces et des classes abstraites, vraiment, mais il y a encore des différences entre eux comme suit:
1. classe A ne peut hériter d'une classe, mais peut implémenter plusieurs interfaces 2. Une classe abstraite peut définir des variables, et l'interface ne peut
Résumé En plus de faire face aux problèmes que nous avons mentionnés ci-dessus, a aussi les avantages suivants:
1. Pour certaines méthodes ne sont pas requis pour chaque sous-classe, nous lui donnons une implémentation par défaut, évitant ainsi nous nous rendons compte de son sens (En général, nous allons lancer de nouveaux UnsupportedException ()) dans une sous-classe 2. La méthode par défaut de fournir java héritage multiple d'une nouvelle façon (bien que nous ne pouvons hériter d'une classe, mais nous pouvons mettre en œuvre plusieurs interfaces ah, maintenant l'interface peut également définir la méthode par défaut)
III. Le conflit et sa solution
Parce qu'une classe peut implémenter plusieurs interfaces, lorsque les instruments de classe, une pluralité d'interfaces, et même deux ou plusieurs de ces interfaces signatures de méthode par défaut présentent dans une collision se produit, java8 défini comme suit trois principes pour résoudre les conflits :
Une méthode de la classe mère ou les classes explicitement déclarée, il est prioritaire sur toute la méthode par défaut 2. Si une règle échoue, la classe actuelle est sélectionnée par défaut la méthode de mise en œuvre spécifique le plus proche 3. Si la règle 2 échoue également, la nécessité de préciser explicitement l'interface
Plusieurs exemples seront décrits ci-après:
exemple 1
public interface A {
/ **
* La définition de la méthode par défaut
* /
Procédé défaut void () {
System.out.println ( "méthode par défaut d'un!");
}
}
public interface B extends A {
/ **
* La définition de la méthode par défaut
* /
Procédé défaut void () {
System.out.println ( "méthode par défaut de B!");
}
}
public class C outils A, B {
public static void main (String [] args) {
new C () méthode ().
}
}
// sortie: méthode par défaut de B!
Ici, parce que l'interface à l'A-B proche de C, avec une méthode particulière B est une implémentation par défaut, selon les règles 2, donc ici appelle en fait l'interface B est la méthode par défaut
exemple 2
public class A {D met en œuvre
}
public class C étend D met en œuvre A, B {
public static void main (String [] args) {
new C () méthode ().
}
}
// sortie: méthode par défaut de B!
Exemple 2 Dans les interfaces d'origine A, B du ajouté la mise en œuvre d'un port de classe D A, C hérite de la classe D et atteindre A et B, bien que C de D plus, mais parce que la mise en œuvre spécifique du D dans un, B, la méthode par défaut ou obtenir le plus proche par défaut, conformément à l'article 2, appelle en fait ici est la méthode par défaut B, respectivement.
exemple 3
// A Interface inchangé
public interface B {
/ **
* La définition de la méthode par défaut
* /
Procédé défaut void () {
System.out.println ( "méthode par défaut de B!");
}
}
public class C outils A, B {
@Passer outre
Procédé public void () {
// doit spécifier explicitement
B.super.method ();
}
public static void main (String [] args) {
new C () méthode ().
}
}
Dans l' exemple 3 , les inherits B d'interface de l'interface A plus, dans ce cas l'appel de méthode par défaut dans C en method()particulier des interfaces A et B pour atteindre la même distance, le compilateur ne peut pas déterminer, l'erreur à ce besoin de temps pour spécifier explicitement: B.super.method().
