Hallo. Diesmal handelt es sich um einen Artikel über den in Java 8 neu hinzugefügten Lambda-Ausdruck.
Neulich habe ich übrigens die Oracle-Zertifizierung Java SE8 Silver erhalten. Unter ihnen gab es eine Zeit, in der ich den aus Java 8 hinzugefügten Lambda-Ausdruck erwähnte. Ich hatte den Eindruck, dass ich es nicht verstehen konnte, wenn ich es nur in einem Buch las.
Und selbst wenn ich einen Artikel über den Lambda-Ausdruck auf Qiita gesucht und gelesen habe, das einzige, was schließlich geschrieben wurde Weil der Inhalt des Nachschlagewerks, der schwer zu verstehen ist und was in der Java-API geschrieben ist, so ist, wie er ist Ich dachte, dass nur wenige Menschen die Vorteile des Lambda-Stils wirklich verstanden haben.
Also, diesmal, anstatt was der Lambda-Ausdruck ist, wie man den Lambda-Ausdruck verwendet Ich wollte einen Artikel über seine Vorteile schreiben.
Ab dem nächsten Kapitel werde ich den Lambda-Ausdruck erläutern. Vorher müssen Sie die Benutzeroberfläche und ihre Funktionen einmal verstehen, um den Lambda-Ausdruck zu verstehen.
Der Grund, warum viele Artikel über Lambda-Ausdrücke nicht klar sind, ist, dass der Autor des Artikels
Ich denke, es liegt daran, dass jemand in eines der oben genannten passt. In diesem Artikel werde ich zunächst zwei Punkte zu den Funktionen der Benutzeroberfläche und ihren Vorteilen beschreiben. Es geht um Polymorphismus und Einkapselung.
Dann der erste Punkt. Über Polymorphismus.
Was ist übrigens eine Schnittstelle in Java? "* Es werden nur die Arten von Variablen und Methoden definiert, ohne den spezifischen Verarbeitungsinhalt der in der Klasse enthaltenen Methoden zu beschreiben. * * 1" nicht wahr.
Dies allein kommt nicht zu einem Stift, also werde ich eine Beispielquelle setzen.
PrintoutMessage.java
package sample;
public interface PrintoutMessage {
public void printSomeMessage(String message);
}
In der obigen Beispielquelle PrintoutMessage.java wurde eine Methode namens printSomeMessage und Es werden nur der Typ und der Variablenname dieses Arguments definiert. Auf diese Weise eine Methode wie printSomeMessage, die nur die Methode und ihren Argumenttyp und Variablennamen definiert Wird als * abstrakte Methode * bezeichnet. (* 2)
Zu diesem Zeitpunkt ist in der Methode printSomeMessage keine Verarbeitung definiert Mit dieser Methode können Sie nichts alleine machen.
Durch Implementieren der Schnittstelle in einer Klasse können Sie jedoch die Verarbeitung in dieser Methode schreiben. Dies funktioniert auch nicht, überprüfen Sie es daher mit dem Beispielcode.
ConcretePrintMessage_Hello.java
package sample:ConcretePrintMessage_Hello.java
/* 1.Implementieren Sie die Schnittstelle*/
public class ConcretePrintMessage_Hello implements PrintoutMessage {
@Override
/* 2.Stellen Sie die Methode der implementierten Schnittstelle dar*/
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.Instanziierung*/
ConcretePrintMessage_Hello p = new ConcretePrintMessage_Hello();
/* 4.Rufen Sie die Methode auf*/
p.printSomeMessage("Welcome to Qiita,");
}
}
In der obigen Datei ConcretePrintMessage_Hello.java können Sie die Schnittstelle implementieren. Die printSomeMessage-Methode zeigt "Nachricht + Hallo als Argument empfangen" an. Dieses Mal habe ich nur eine Zeile (System.out.println ();) geschrieben, um dies zu erklären. Es ist möglich, mehrere Prozesse durchzuführen, wie in den Kommentaren zur Quelle beschrieben. (* 3)
Bis zu diesem Punkt wurde festgestellt, dass die Schnittstelle verwendet werden kann, indem die Schnittstelle in einer Klasse implementiert, die Methode in der implementierten Klasse (* 4) neu definiert und der Verarbeitungsinhalt beschrieben wird.
Dies allein würde jedoch lauten: "Warum verwenden Sie die Schnittstelle? Sie sollten die printSomeMessage-Methode mit ConcretePrintMessage_Hello.java erstellen, ohne die Schnittstelle zu definieren."
Schauen wir uns einen anderen Beispielcode an, um eine solche Frage zu lösen.
ConcretePrintMessage_Goodbye.java
package sample;
/* 1.Implementieren Sie die Schnittstelle*/
public class ConcretePrintMessage_Goodbye implements PrintoutMessage {
@Override
/* 2.Stellen Sie die Methode der implementierten Schnittstelle dar*/
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.Instanziierung*/
ConcretePrintMessage_Goodbye p = new ConcretePrintMessage_Goodbye();
/* 4.Rufen Sie die Methode auf*/
p.printSomeMessage("See you again,");
}
}
Dieses Mal wird ConcretePrintMessage_Goodbye.java verwendet, um "Nachricht + Auf Wiedersehen als Argument erhalten" in der printSomeMessage-Methode anzuzeigen. Es gibt nur einen Unterschied zum vorherigen ConcretePrintMessage_Hello.java. Gibt an, ob "Nachricht + Hallo als Argument empfangen" oder "Nachricht + Auf Wiedersehen als Argument empfangen" angezeigt werden soll.
Beide haben denselben Methodennamen, printSomeMessage (String message), aber denselben Argumenttyp und Argumentnamen, aber der Verarbeitungsinhalt ist unterschiedlich. Hast du davon gehört?
Ja, das ist "* Polymorphismus *". Die Vorteile des Polymorphismus werden hier nicht beschrieben, aber wir haben bisher gelernt, was eine Schnittstelle ist. Es ist ein Weg, um Polymorphismus zu erreichen. Sie können Polymorphismus leicht erreichen, indem Sie eine Schnittstelle definieren und implementieren. Dies ist das erste Merkmal und der erste Vorteil der Schnittstelle.
Als nächstes kommt der zweite Punkt, die Kapselung.
Jetzt möchte ich ConcretePrintMessage_Goodbye.java eine Methode hinzufügen.
ConcretePrintMessage_Goodbye.java
package sample;
/* 1.Implementieren Sie die Schnittstelle*/
public class ConcretePrintMessage_Goodbye implements PrintoutMessage {
@Override
/* 2.Stellen Sie die Methode der implementierten Schnittstelle dar*/
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.Instanziierung*/
ConcretePrintMessage_Goodbye p = new ConcretePrintMessage_Goodbye();
/* 4.Rufen Sie die Methode auf*/
p.printSomeMessage("See you again " + p.getMyName() + ", ");
}
/*Methode hinzugefügt*/
private String getMyName() {
return "Tom";
}
}
Die zu ConcretePrintMessage_Goodbye.java hinzugefügte Methode ist der Getter getMyName (), um den Namen abzurufen. Der Zugriffsmodifikator für diese Methode ist privat, nicht wahr? Methoden mit dem privaten Modifikator können nur von derselben Klasse referenziert werden. Wenn Sie nur mit dieser Klasse verarbeiten möchten, geben Sie daher private als Zugriffsmodifikator an. Alles, was Sie tun müssen, ist, es für andere Klassen unzugänglich zu machen. In diesem Beispiel ist das Abrufen des Namens Tom mit getMyName () privat, da dies nur mit ConcretePrintMessage_Goodbye.java erfolgen soll.
Andererseits sind die Modifikatoren der in der Schnittstelle implementierten Methoden immer öffentlich, sodass alle Klassen auf sie zugreifen können. Daher kann die in der Schnittstelle definierte abstrakte Methode verwendet werden, um zu implementieren, was Sie für alle Klassen gemäß dieser Klasse gemeinsam verarbeiten möchten. Darüber hinaus muss der für den allgemeinen Prozess verwendete Methodenname mit dem in der Schnittstelle definierten übereinstimmen. Egal wer die Quelle geschrieben hat, solange die Schnittstelle implementiert ist, die Methode mit dem gleichen Namen Da die allgemeine Verarbeitung durchgeführt wird, können Sie sich auf einen Blick grob vorstellen, was sie tut.
Dies ist die Kapselung, und ich habe festgestellt, dass die Schnittstelle beim Erstellen der Methoden hilft, auf die ich bei der Kapselung von allen Klassen zugreifen möchte.
Dies sind die Merkmale der Schnittstelle und ihre Vorteile. (* 6)
Bisher wissen wir, dass die Schnittstelle die Vorteile von Polymorphismus und Einkapselung hat. Es fühlt sich an wie das, was der Lambda-Ausdruck damit zu tun hat. Um dies zu erklären, schauen wir uns an, wie Sie die Schnittstelle erneut verwenden. Die unten stehende Beispielquelle ist dieselbe wie die oben angegebene Beispielquelle.
ConcretePrintMessage_Hello.java
package sample;
/* 1.Implementieren Sie die Schnittstelle*/
public class ConcretePrintMessage_Hello implements PrintoutMessage {
@Override
/* 2.Stellen Sie die Methode der implementierten Schnittstelle dar*/
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.Instanziierung*/
ConcretePrintMessage_Hello p = new ConcretePrintMessage_Hello();
/* 4.Rufen Sie die Methode auf*/
p.printSomeMessage("Welcome to Qiita,");
}
}
Von Anfang an habe ich Schritte geschrieben, um die Benutzeroberfläche für Kommentare zur Quelle zu verwenden. Ist es nicht ärgerlich, diese vier Schritte jedes Mal zu machen? (Lol) In einem tatsächlichen Projekt schreibe ich dies jedes Mal für ungefähr 100 Klassen. Es ist ärgerlich, dies jedes Mal für 100 Klassen zu schreiben, obwohl die Benutzeroberfläche ihre Vorteile hat.
Daher wurde der Lambda-Typ als Ergebnis des Denkens "Ist es nicht einfacher, die Schnittstelle zu verwenden?" Geboren.
… Um es ganz klar auszudrücken, das ist alles für den Lambda-Ausdruck.
Lassen Sie uns den Beispielcode überprüfen, um zu sehen, wie einfach es ist, mit der Schnittstelle umzugehen!
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? ");
}
}
Das Verfahren ist im Vergleich zur vorherigen Quelle erheblich vereinfacht.
Sie müssen lediglich den Verarbeitungsinhalt beschreiben und die Methode aufrufen. Danach werden nur die Spezifikationen für den Lambda-Ausdruck erwähnt, die an verschiedenen Stellen üblich sind. Wenn Sie sich den Artikel ansehen, sollte der Lambda-Ausdruck perfekt sein. Speziell für Lambda-Ausdrücke, um sich mit der in diesem Artikel ein wenig erwähnten "funktionalen Schnittstelle" zu befassen. Es gibt viele Spezifikationen, daher wird empfohlen, sich umzuschauen.
Vielen Dank für das Lesen bis zum Ende. Wenn Sie Vorschläge oder Fragen haben, hinterlassen Sie bitte einen Kommentar.
1 Alle Schnittstellenfelder sind konstant und alle Methoden sind öffentlich.
2 Eine Schnittstelle mit einer einzelnen abstrakten Methode, z. B. PrintoutMessage.java, wird auch als "funktionale Schnittstelle" bezeichnet.
3 Da es eine "Funktionsschnittstelle" gibt, ist es natürlich möglich, den Rückgabewert nach der Verarbeitung zurückzugeben. (Im Allgemeinen geben "Funktionen" normalerweise einen Rückgabewert zurück, obwohl einige Funktionen keinen Rückgabewert zurückgeben ...)
4 Wenn eine Schnittstelle implementiert ist, muss "* konkrete Methode *" definiert werden, die den Verarbeitungsinhalt der abstrakten Methode beschreibt, die in der Schnittstelle der implementierten Klasse definiert ist.
5 Zu den Zugriffsqualifizierern geerbter und überschriebener Methoden können nur Zugriffsqualifizierer hinzugefügt werden, die mit der Vererbungsquelle identisch oder lockerer sind.
6 Weitere detaillierte Funktionen finden Sie auf jeder Website oder in jedem Buch.
Recommended Posts