Méthode Java par défaut

Dans Java 8, un nouveau concept nommé méthode par défaut est introduit afin d'effectuer une compatibilité ascendante qui contrôle les expressions lambda par les anciennes interfaces. De plus, les interfaces sont autorisées à avoir des fonctions avec implémentation sans causer de problèmes aux classes dans lesquelles l'interface sera implémentée. Avant l'introduction de Java 8, seules les méthodes abstraites étaient autorisées par les interfaces. De plus, les fonctions devaient être proposées dans différentes classes. Dans les sections suivantes, la syntaxe, le fonctionnement et des exemples de la méthode par défaut seront expliqués.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe

Vous trouverez ci-dessous la syntaxe d'une méthode par défaut.

public interface animal {
default void sound() {
System.out.println("This is a sample default method. . .!");
}}

Comment fonctionne la méthode par défaut en Java ?

Comme nous le savons, les interfaces telles que List et collections n'ont pas la méthode forEach. S’il est ajouté, la mise en œuvre du cadre des collections sera interrompue. Puisque la méthode par défaut est introduite dans Java 8, une implémentation par défaut peut être effectuée pour la méthode forEach. En plus de cela, une classe qui implémente 2 interfaces avec les mêmes fonctions par défaut peut être créée. Voyons comment l'ambiguïté du code est résolue.

public interface livingthings
{
default void sound()
{     . . .
System.out.println("Living things too make noise . . .") ;
}
}
public interface animals
{
default void sound()
{          . . .
System.out.println("animals too make noise . . .") ;
}
}

Il existe deux solutions à cette ambiguïté.

1. Pour remplacer l'implémentation de la méthode par défaut, créez votre propre méthode.

public class dogs implements livingthings,animals
{
default void sound()
{          . . .
System.out.println("dogs bark . . .") ;} }

2. En utilisant super, appelez la méthode par défaut

public class dogs implements livingthings,animals
{
default void sound()
{          . . .
livingthings.super.print("dogs bark . . .") ; } }

En Java, normalement n interfaces peuvent être implémentées par une classe. De plus, une interface peut être étendue par une autre interface. Supposons qu'il existe deux interfaces pour une classe et qu'une méthode par défaut est implémentée ; la classe particulière peut être confuse dans le choix de la méthode à prendre en compte pour l'appel. Afin de résoudre ces conflits, les points suivants peuvent être effectués.

• Les méthodes remplacées dans la classe sont mises en correspondance et appelées.
• Si la méthode avec la même méthode est fournie, la plus appropriée sera choisie. Supposons qu'il existe deux interfaces, A et B sont présentes pour une classe particulière. Si A étend B, alors A est ici le plus spécifique et la méthode par défaut sera sélectionnée parmi A. Si A et b sont des interfaces indépendantes, une situation de conflit grave se produira et une plainte sera déposée par un compilateur indiquant qu'il est incapable de choisir. Dans cette situation, l'utilisateur doit aider le compilateur en proposant des détails supplémentaires parmi lesquels A ou B la méthode par défaut doit être choisie. par exemple

A.super.demo() ;

ou

B.super.demo() ;

Différences entre la méthode normale et la méthode par défaut

Voyons maintenant quelques-unes des différences entre une méthode normale et une méthode par défaut

• La méthode par défaut est accompagnée d'un modificateur par défaut, contrairement aux méthodes normales.
• Les arguments des interfaces n'ont pas d'état particulier pour les méthodes par défaut.
• Les méthodes normales peuvent utiliser et modifier les arguments des méthodes et des champs de classe.
• De nouvelles fonctionnalités peuvent être ajoutées aux interfaces existantes au lieu de rompre l'implémentation précédente de ces interfaces particulières.

Lors de l'extension d'une interface composée d'une méthode par défaut, les opérations suivantes peuvent être effectuées.

• La méthode par défaut ne sera pas remplacée et elle sera héritée.
• Les méthodes par défaut seront remplacées, qui sont similaires aux méthodes remplacées dans les sous-classes.
• La méthode par défaut doit être à nouveau déclarée comme abstraite, ce qui force la substitution de la sous-classe.

Exemples d'implémentation de la méthode Java par défaut

Voici les exemples de programmes mentionnés :

Exemple n°1

Programme Java pour implémenter la méthode par défaut

Code :

//Java program to implement default method
public class DefExample {
//main method
public static void main(String args[]) {
//create an object for the interface animal
Animals obj = new Dog();
//call the print method
obj.print( );
}
}
//create an interface animal
interface Animals {
//default method
default void print( ) {
System.out.println("I have four legs. . . ! !");
}
static void sound() {
System.out.println("I used to bark alot!!!") ;
}
}
//create an interface <u>carnivores</u>
interface Carnivores {
//default method
default void print( ) {
System.out.println("I eat non veg. . .! !") ;
}
}
//class that implements the other two interfaces
class Dog implements Animals, Carnivores {
public void print( ) {
//call the print method of Animals  using super
Animals.super.print( ) ;
//call the print method of Carnivores  using super
Carnivores.super.print( );
//call the sound method of Animals
Animals.sound();
System.out.println("I am a Dog . . .!");
}
}

Sortie :

Explication : Dans ce programme, deux interfaces, Animaux et Carnivores, ont la même méthode par défaut print(), et elles sont appelées en utilisant super.

Exemple n°2

Programme Java pour implémenter la méthode par défaut

Code :

//Java program to implement default method
interface Sampleinterface{
// Since this is declared as a default method, this has to be implemented in the implementation classes
default void sammethod(){
System.out.println("a default method which is newly added to the program");
}
// existing public as well as abstract methods has to be implemented in the implementation classes
void oldmethod(String s);
}
public class DefExample implements Sampleinterface{
//  abstract method implementation
public void oldmethod(String s){
System.out.println("The string given is: "+ s);
}
public static void main(String[] args) {
DefExample obj = new DefExample();
//call the default method
obj.sammethod();
//call the abstract method
obj.oldmethod("I am the old method in the program");
}
}

Sortie :

Explication : Dans ce programme, une interface Sampleinterface est présente, et elle a une méthode par défaut sammethod(), et elle est appelée.

Conclusion

Dans Java 8, un nouveau concept nommé méthode par défaut est proposé pour effectuer une compatibilité descendante où les anciennes interfaces contrôlent les expressions lambda. De plus, les arguments d’interface n’ont pas d’état spécifique pour les méthodes par défaut. Dans cet article, la syntaxe, le fonctionnement et des exemples de la méthode par défaut sont expliqués en détail.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!