1.Tout d'abord 2. Comprendre l'interface et ses fonctionnalités pour comprendre les expressions lambda 3. Comment utiliser l'expression lambda 4. Conclusion
Bonjour. Cette fois, il s'agit d'un article sur l'expression lambda nouvellement ajoutée dans Java 8.
Au fait, l'autre jour, j'ai obtenu la certification Oracle Java SE8 Silver. Parmi eux, il fut un temps où j'ai mentionné l'expression lambda ajoutée à partir de Java 8. J'ai eu l'impression que je ne pouvais pas le comprendre simplement en le lisant dans un livre.
Et même si je cherchais et lisais un article sur l'expression lambda sur Qiita, la seule chose qui ait été écrite après tout Parce que le contenu du livre de référence qui est difficile à comprendre et ce qui est écrit dans l'API Java Je pensais que peu de gens comprenaient vraiment les avantages du style lambda.
Donc, cette fois, plutôt que ce qu'est l'expression lambda, comment utiliser l'expression lambda Je voulais écrire un article sur ses avantages.
Donc, à partir du chapitre suivant, j'expliquerai l'expression lambda, Avant cela, vous devez comprendre l'interface et ses fonctionnalités une fois pour comprendre l'expression lambda.
La raison pour laquelle de nombreux articles écrits sur les expressions lambda ne sont pas clairs est que l'auteur de l'article
Je pense que c'est parce que quelqu'un qui s'inscrit dans l'un de ces domaines. Donc, dans cet article, je décrirai d'abord deux points sur les fonctionnalités de l'interface et ses avantages. Il s'agit de polymorphisme et d'encapsulation.
Puis le premier point. À propos du polymorphisme.
Au fait, qu'est-ce qu'une interface en Java? "* Seuls les types de variables et de méthodes sont définis sans décrire le contenu de traitement spécifique des méthodes incluses dans la classe * * 1" n'est-ce pas.
Cela seul ne vient pas à une épingle, donc je vais mettre une source d'échantillon.
PrintoutMessage.java
package sample;
public interface PrintoutMessage {
public void printSomeMessage(String message);
}
Dans l'exemple de source ci-dessus PrintoutMessage.java, une méthode appelée printSomeMessage et Seuls le type et le nom de variable de cet argument sont définis. De cette façon, une méthode comme printSomeMessage qui définit uniquement la méthode et son type d'argument et nom de variable Appelée * méthode abstraite . ( 2)
À ce stade, aucun traitement n'est défini dans la méthode appelée printSomeMessage, donc Vous ne pouvez rien faire avec cette méthode seule.
Cependant, en implémentant l'interface dans une classe, vous pouvez écrire le traitement dans cette méthode. Cela ne fonctionne pas non plus, alors vérifiez-le avec l'exemple de code.
ConcretePrintMessage_Hello.java
package sample:ConcretePrintMessage_Hello.java
/* 1.Implémenter l'interface*/
public class ConcretePrintMessage_Hello implements PrintoutMessage {
@Override
/* 2.Représenter la méthode de l'interface implémentée*/
public void printSomeMessage(String message) {
/* do some process */
/* do some process */
/* do some process */
/* do some process */
System.out.println(message + "Hello");
}
public static void main(String[] args) {
/* 3.Instanciation*/
ConcretePrintMessage_Hello p = new ConcretePrintMessage_Hello();
/* 4.Appelez la méthode*/
p.printSomeMessage("Welcome to Qiita,");
}
}
Dans le ConcretePrintMessage_Hello.java ci-dessus, en implémentant l'interface, La méthode printSomeMessage est faite pour afficher "message + Bonjour reçu en argument". Cette fois, je n'ai écrit qu'une seule ligne (System.out.println ();) pour des raisons d'explication, Il est possible d'avoir plusieurs processus comme décrit dans les commentaires sur la source. (* 3)
Jusqu'à présent, il a été constaté que l'interface peut être utilisée en implémentant l'interface dans une classe, en redéfinissant la méthode dans la classe implémentée (* 4) et en décrivant le contenu du traitement.
Cependant, avec cela seul, ce serait "Pourquoi vous embêtez-vous à utiliser l'interface? Vous devriez créer la méthode printSomeMessage avec ConcretePrintMessage_Hello.java sans définir l'interface?"
Jetons un coup d'œil à un autre exemple de code pour résoudre une telle question.
ConcretePrintMessage_Goodbye.java
package sample;
/* 1.Implémenter l'interface*/
public class ConcretePrintMessage_Goodbye implements PrintoutMessage {
@Override
/* 2.Représenter la méthode de l'interface implémentée*/
public void printSomeMessage(String message) {
/* do some process */
/* do some process */
/* do some process */
/* do some process */
System.out.println(message + "Goodbye");
}
public static void main(String[] args) {
/* 3.Instanciation*/
ConcretePrintMessage_Goodbye p = new ConcretePrintMessage_Goodbye();
/* 4.Appelez la méthode*/
p.printSomeMessage("See you again,");
}
}
Cette fois, ConcretePrintMessage_Goodbye.java est utilisé pour afficher "message + Au revoir reçu en argument" dans la méthode printSomeMessage. Il n'y a qu'une seule différence par rapport à la précédente ConcretePrintMessage_Hello.java. Que ce soit pour afficher "message + Bonjour reçu en argument" ou "message + Au revoir reçu en argument".
Les deux ont le même nom de méthode, printSomeMessage (String message);, mais le même type d'argument et le même nom d'argument, mais le contenu du traitement est différent. As-tu entendu parler de ça?
Oui, c'est "* polymorphisme *". Les avantages du polymorphisme ne sont pas décrits ici, mais ce que nous avons appris jusqu'à présent, c'est ce qu'est une interface. C'est un moyen de parvenir au polymorphisme. Vous pouvez facilement réaliser un polymorphisme en définissant une interface et en l'implémentant. C'est la première fonctionnalité et avantage de l'interface.
Vient ensuite le deuxième point, l'encapsulation.
Maintenant, je voudrais ajouter une méthode à ConcretePrintMessage_Goodbye.java.
ConcretePrintMessage_Goodbye.java
package sample;
/* 1.Implémenter l'interface*/
public class ConcretePrintMessage_Goodbye implements PrintoutMessage {
@Override
/* 2.Représenter la méthode de l'interface implémentée*/
public void printSomeMessage(String message) {
/* do some process */
/* do some process */
/* do some process */
/* do some process */
System.out.println(message + "Goodbye");
}
public static void main(String[] args) {
/* 3.Instanciation*/
ConcretePrintMessage_Goodbye p = new ConcretePrintMessage_Goodbye();
/* 4.Appelez la méthode*/
p.printSomeMessage("See you again " + p.getMyName() + ", ");
}
/*Méthode ajoutée*/
private String getMyName() {
return "Tom";
}
}
La méthode ajoutée à ConcretePrintMessage_Goodbye.java est le getMyName () pour obtenir le nom. Le modificateur d'accès pour cette méthode est privé, n'est-ce pas? Les méthodes avec le modificateur privé ne peuvent être référencées qu'à partir de la même classe. Par conséquent, si vous souhaitez traiter uniquement avec cette classe, spécifiez private comme modificateur d'accès. Tout ce que vous avez à faire est de le rendre inaccessible depuis les autres classes. Dans cet exemple, obtenir le nom Tom avec getMyName () est privé car nous ne voulons le faire qu'avec ConcretePrintMessage_Goodbye.java.
Par contre, les modificateurs des méthodes implémentées dans l'interface sont toujours publics, ils sont donc accessibles par toutes les classes. Par conséquent, la méthode abstraite définie dans l'interface peut être utilisée pour implémenter ce que vous souhaitez traiter en commun pour toutes les classes selon cette classe. De plus, le nom de la méthode utilisée pour le processus commun doit être le même que celui défini dans l'interface. Peu importe qui a écrit la source, tant que l'interface est implémentée, la méthode du même nom Étant donné que le traitement courant est effectué, vous pouvez à peu près imaginer ce qu'il fait en un coup d'œil.
Il s'agit de l'encapsulation, et j'ai trouvé que l'interface aide à créer les méthodes auxquelles je souhaite accéder à partir de toutes les classes lors de l'encapsulation.
Ce sont les caractéristiques de l'interface et ses avantages. (* 6)
Jusqu'à présent, on sait que l'interface présente les avantages du polymorphisme et de l'encapsulation, Cela ressemble à ce que l'expression lambda a à voir avec cela. Pour expliquer cela, voyons comment utiliser à nouveau l'interface. La source d'échantillon ci-dessous est la même que la source d'échantillon ci-dessus.
ConcretePrintMessage_Hello.java
package sample;
/* 1.Implémenter l'interface*/
public class ConcretePrintMessage_Hello implements PrintoutMessage {
@Override
/* 2.Représenter la méthode de l'interface implémentée*/
public void printSomeMessage(String message) {
/* do some process */
/* do some process */
/* do some process */
/* do some process */
System.out.println(message + "Hello");
}
public static void main(String[] args) {
/* 3.Instanciation*/
ConcretePrintMessage_Hello p = new ConcretePrintMessage_Hello();
/* 4.Appelez la méthode*/
p.printSomeMessage("Welcome to Qiita,");
}
}
Depuis le début, j'écris des étapes pour utiliser l'interface pour les commentaires sur la source, N'est-ce pas ennuyeux de faire ces quatre étapes à chaque fois? (Lol) Dans un projet réel, j'écris ceci pour environ 100 classes à chaque fois. C'est ennuyeux d'écrire ceci à chaque fois pour 100 classes, même si l'interface a ses avantages.
Par conséquent, le type lambda est né de la pensée "N'est-il pas plus facile d'utiliser l'interface?"
… Pour être franc, c'est tout pour l'expression lambda.
Vérifions l'exemple de code pour voir à quel point il est facile de gérer l'interface!
ConcretePrintMessage_GoodMorning.java
package sample;
public class ConcretePrintMessage_GoodMorning {
public static void main(String[] args) {
PrintoutMessage p = (String message) -> {
/* do some process */
/* do some process */
/* do some process */
/* do some process */
System.out.println(message + "GoodMorning!!");
};
p.printSomeMessage("How's your sleep? ");
}
}
La procédure est considérablement simplifiée par rapport à la source précédente.
Tout ce que vous avez à faire est de décrire le contenu du traitement et d'appeler la méthode. Le reste ne mentionne que les spécifications de la formule lambda qui est courante dans de nombreux endroits. Si vous regardez l'article, l'expression lambda devrait être parfaite. Surtout pour les expressions lambda, pour traiter de "l'interface fonctionnelle" évoquée un peu dans cet article. Il existe de nombreuses spécifications, il est donc recommandé de jeter un œil autour d'elles.
Merci d'avoir lu jusqu'au bout. Si vous avez des suggestions ou des questions, veuillez laisser un commentaire.
1 Tous les champs d'interface sont constants et toutes les méthodes sont publiques.
2 Une interface qui a une seule méthode abstraite, telle que PrintoutMessage.java, est également appelée "interface fonctionnelle".
3 Puisqu'il existe une "interface fonctionnelle", il est bien entendu possible de renvoyer la valeur de retour après traitement. (Généralement, les "fonctions" renvoient généralement une valeur de retour, bien que certaines fonctions ne renvoient pas de valeur de retour ...)
4 Lorsqu'une interface est implémentée, il est nécessaire de définir "* méthode concrète *" qui décrit le contenu de traitement de la méthode abstraite définie dans l'interface sur la classe implémentée.
5 Seuls les qualificatifs d'accès identiques ou plus lâches que la source d'héritage peuvent être ajoutés aux qualificatifs d'accès des méthodes héritées et remplacées.
6 Pour d'autres fonctionnalités détaillées, veuillez consulter chaque site ou livre.
Recommended Posts