Java 8 est appelé la version la plus modifiée de l'histoire de Java. Il contient de nombreuses nouvelles fonctionnalités importantes, le plus de noyau est l'ajout d'expressions lambda et de streamapi. Les deux peuvent également être utilisés ensemble. Tout d'abord, jetons un coup d'œil à ce qu'est une expression de lambda.
L'utilisation d'expressions Lambda rend non seulement le code simple, mais également lisible, et surtout, la quantité de code diminue également beaucoup. Cependant, dans une certaine mesure, ces fonctions ont été largement utilisées dans les langages JVM tels que Scala.
Sans surprise, la communauté Scala est incroyable, car beaucoup de contenu Java 8 semble être ému de Scala. Dans une certaine mesure, la syntaxe de Java 8 est plus détaillée mais pas très claire que celle de Scala, mais cela ne dit pas grand-chose, et si cela peut, il pourrait construire des expressions de lambda comme Scala.
D'une part, si Java continue de développer et d'implémenter des fonctions que Scala a déjà implémentées autour de Lambda, alors Scala peut ne pas être nécessaire. D'un autre côté, s'il fournit uniquement des fonctionnalités de base, tels que l'aide aux classes internes anonymes, Scala et d'autres langues continueront de prospérer et pourraient dépasser Java. En fait, c'est le meilleur résultat. Ce n'est qu'avec la concurrence qu'il peut y avoir de progrès. D'autres langues continuent de se développer et de grandir, et il n'est pas nécessaire de se soucier de savoir s'ils seront dépassés.
Expression de Lambda, l'explication sur Wikipedia est un opérateur utilisé pour représenter des fonctions et des fermetures anonymes. Je pense que cette explication est encore très abstraite. Regardons un exemple.
classe publique swingTest {public static void main (string [] args) {jframe jframe = new jframe ("my jframe"); JBUTTON JBUTTON = NOUVEAU JBUTTON ("My Jbutton"); jbutton.addactionListener (new ActionListener () {@Override public void ActionPerformed (actionEvent e) {System.out.println ("Button appuyé!");}}); jframe.add (jbutton); jframe.pack (); jFrame.setVisible (true); jframe.setDefaultCloseOperation (jframe.exit_on_close); }}Il s'agit d'un morceau de code dans la programmation swing qui lie un événement d'écoute au bouton. Lorsque le bouton est cliqué, le contenu "Buttonpressed!" sera sorti sur la console. Ici, nous créons une instance d'une classe intérieure anonyme pour se lier à l'auditeur, qui est également un formulaire d'organisation de code relativement commun dans le passé. Mais si nous regardons de près, nous constaterons qu'en fait, ce sur quoi nous nous concentrons vraiment est un paramètre e de type ActionEvent et le système de déclaration.out.println ("Buttonpregh!"); sortie de la console.
Si le code du programme précédent qui crée une classe interne anonyme est remplacé par une expression de lambda, le code est le suivant
classe publique swingTest {public static void main (string [] args) {jframe jframe = new jframe ("my jframe"); JBUTTON JBUTTON = NOUVEAU JBUTTON ("My Jbutton"); jbutton.addactionListener (e -> System.out.println ("bouton appuyé sur!")); jframe.add (jbutton); jframe.pack (); jFrame.setVisible (true); jframe.setdefaultCloseOperation (jframe.exit_on_close);}} Faites attention aux modifications dans la partie médiane du code, à partir des 6 lignes de code d'origine, maintenant 1 ligne peut être implémentée. Il s'agit d'une forme simple d'expression de lambda.
On peut voir que la syntaxe de l'expression de lambda est
(param1, param2, param3) -> {// todo}Le programme de type du paramètre ici peut être déduit en fonction du contexte, mais tous les types peuvent être déduits. Pour le moment, nous devons afficher le type de paramètre déclaré. Lorsqu'il n'y a qu'un seul paramètre, les supports peuvent être omis. Lorsque la pièce TODO n'a qu'une seule ligne de code, les accolades à l'extérieur peuvent être omises. Comme dans notre exemple ci-dessus
Donc, en plus du code concis, l'expression de Lambda nous apporte-t-elle des changements?
Rappelons que dans Java, nous ne pouvons pas transmettre une fonction de paramètre à une méthode, et nous ne pouvons pas déclarer que la valeur de retour est une méthode d'une fonction. Avant Java 8, la réponse était oui.
Ainsi, dans l'exemple ci-dessus, nous pouvons réellement passer une logique de code en tant que paramètre à l'auditeur, indiquant à l'auditeur que vous pouvez le faire lorsque l'événement est déclenché, sans avoir besoin d'utiliser des classes internes anonymes comme paramètres. Il s'agit également d'une autre nouvelle fonctionnalité apportée par Java 8: Programmation fonctionnelle.
Il existe de nombreux langages qui prennent en charge la programmation fonctionnelle. Dans JavaScript, il est très courant de passer les fonctions comme paramètres ou valeurs de retour en fonction. JavaScript est un langage fonctionnel très commun.
Lambda ajoute des fonctionnalités de programmation fonctionnelle manquantes à Java, nous permettant de traiter les fonctions comme des citoyens de première classe.
Dans les langages de programmation fonctionnelle, le type d'expression de lambda est une fonction. En Java, les expressions lambda sont des objets et ils doivent être attachés à une interface d'objet spéciale - Interface fonctionnelle.
Ensuite, regardons la définition de l'interface fonctionnelle:
S'il existe et une seule méthode abstraite dans une interface (les méthodes de la classe d'objets ne sont pas incluses), cette interface peut être considérée comme une interface fonctionnelle.
@FunctionalInterFacePublic Interface Runnable {/ ** * Lorsqu'un objet implémentant l'interface <code> runnable </code> est utilisé * pour créer un thread, le démarrage du thread provoque la méthode * <code> Exécuter </code> de l'objet. * <p> * Le contrat général de la méthode <Code> Exécuter </code> est qu'il peut * prendre toute action. * * @see java.lang.thread # run () * / public abstract void run ();}Jetons un coup d'œil à l'instruction de l'interface Runnable. Après Java 8, l'interface Runnable a une annotation fonctionnelle supplémentaire, indiquant que l'interface est une interface fonctionnelle. Cependant, si nous n'ajoutons pas l'annotation FunctionalInterface, s'il y a et une seule méthode abstraite dans l'interface, le compilateur considère également l'interface comme une interface fonctionnelle.
@FunctionalInterFacePublic Interface myInterface {void test (); String toString ();}MyInterface est également une interface fonctionnelle, car ToString () est une méthode dans la classe d'objets, mais il est réécrit ici et n'augmentera pas le nombre de méthodes abstraites dans l'interface.
(Pour mentionner ici, dans Java 8, les méthodes de l'interface peuvent non seulement avoir des méthodes abstraites, mais également des méthodes implémentées spécifiques. Ils sont appelés méthodes par défaut, qui seront introduites en détail plus tard)
Depuis à Java, les expressions lambda sont des objets. Alors, quel est le type de cet objet? Passons en revue le programme SwingTest, où une instance d'interface ActionListener est créée dans une classe interne anonyme.
jbutton.addactionListener (new ActionListener () {@Override public void ActionPerformed (actionEvent e) {System.out.println ("Button appuyé!");}});Amélioré avec l'expression de lambda
jbutton.addactionListener (e -> System.out.println ("bouton appuyé sur!"));Autrement dit, nous utilisons l'expression de Lambda pour créer une instance de l'interface ActionListener, puis examinons la définition de l'interface ActionListener.
Interface publique ActionListener étend EventListener {/ ** * invoqué lorsqu'une action se produit. * / public void ActionPerformed (ActionEvent E);} Il n'y a qu'une seule méthode abstraite. Bien que l'annotation FunctionalInterface ne soit pas ajoutée, elle est également conforme à la définition d'une interface fonctionnelle. Le compilateur considérera qu'il s'agit d'une interface fonctionnelle.
Par conséquent, l'utilisation d'expressions de lambda peut créer des instances d'interfaces fonctionnelles. C'est-à-dire que l'expression de lambda renvoie un type d'interface fonctionnel.
En fait, il existe trois façons de créer des instances d'interface fonctionnelle (reportez-vous à l'annotation FunctionalInterface):
1. Expressions de lambda
2. Citation de la méthode
3. Référence de la méthode du constructeur
Résumer
Ce qui précède concerne cet article sur la compréhension simple de Java 8 des expressions de lambda et des interfaces fonctionnelles. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler!