B2 · 第4集 · 4:59
Java函数式接口
本集讲解Java中函数式接口的概念与应用，以及如何用Lambda简化匿名类的编写。
来源：Nicolas Hurtubise / classe.iro.umontreal.ca · 许可：CC BY-SA 4.0
字幕
Cette interface- là a été définie pour avoir une seule méthode,
这个接口被定义为只包含一个方法，
avec une seule signature possible, avec un seul type de retour,
且该方法只有一种可能的签名、一种返回类型，
avec une seule sorte d'argument.
以及一种参数类型。
fait qu'avec un petit peu d'analyse de code si on regarde cette déclaration là ici
这意味着，只要稍作代码分析，
ben on est capable de se rendre compte automatiquement que la seule chose qui peut
当我们查看此处这一声明时，
venir après la seule chose qui peut venir ici c'est un
就能自动意识到：唯一能出现在此处的，
new function qui est déclarée anonymement avec un public void execute string arg
就是一个用 public void execute(String arg) 声明的匿名函数。
comme ceci. fait qu'à partir du moment où on déclare une interface comme étant une
因此，一旦我们将某个接口声明为这样的函数式接口，
interface fonctionnelle comme ça,
我们就告诉 Java：这个接口可以像 JavaScript 中的匿名函数一样使用。
On dit à Java que c'est possible d'utiliser cette interface là comme si c'était une
也就是说，我们可以实例化一个实现该接口的匿名类，
fonction anonyme en JavaScript.
而无需额外开销。
Donc, on peut instancier une classe anonyme
因此，我们能以更少的代码量，
qui implémente cette interface- là
创建一个实现该接口的匿名类，
avec beaucoup moins d'overhead,
大幅减少冗余，
avec beaucoup moins de choses à taper avant d'y arriver.
也省去了大量前期输入工作。
Ça nous permet de simplifier l'écriture des classes anonymes,
这使我们能简化匿名类的编写，
ça nous permet de rendre ça un petit peu plus lisible.
也让代码变得更易读。
Si on essayait encore d'écrire le code du début.
如果我们尝试用最初的方式重写那段代码，
Avec cette nouvelle syntaxe- là, on arriverait à quelque chose qui a l'air de ça.
采用这种新语法，结果会像这样。
On arriverait encore à déclarer une variable pour contenir notre genre de fonction
我们仍可声明一个变量 f 来保存这类函数，
f. Selon math.
其类型为 Math。
random plus petit que 0.5, on va soit aller mettre cette fonction anonyme- là,
若 Math.random() 小于 0.5，
ce genre de fonction anonyme- là,
就放入这个匿名函数，
sinon on va plutôt mettre celle- là.
否则就放入另一个。
Donc encore une fois, ces trucs- là ici,
所以，这些结构本质上是：
concrètement ce que c'est, c'est que c'est des instances de classes qui sont
在运行时动态声明的类的实例，
déclarées sur le coup, qui contiennent une seule méthode.
每个类仅含一个方法。
Mais en utilisant cette syntaxe- là, ça a un peu plus l'air de ce
但使用这种语法时，它看起来
qu'on essaie de faire.
更像我们想实现的功能。
Dans le fond, ici on a nos arguments,
本质上，这里包含了我们的参数、
flèche, le corps de la fonction.
箭头，以及函数体。
Ça a vraiment plus l'air d'être une fonction toute seule qui est déclarée comme ça,
这确实更像一个独立定义的函数，
qu'on assigne à une variable qui peut contenir ce type de fonction- là.
然后被赋值给一个能存储此类函数的变量。
Ok, petite question pour vous.
好，这里有个小问题考考大家。
On a enlevé le type dans cette nouvelle déclaration,
我们在这种新声明方式中移除了类型，
donc dans cette nouvelle façon de déclarer des
也就是在声明这类匿名类时，
classes anonymes.
采用了这种新写法。
On a enlevé le type du paramètre ici.
这里，我们还删去了参数的类型。
Donc, sachant ça, est- ce que la variable nom peut contenir n'importe quoi?
那么，既然如此，变量‘nom’是否能存入任意内容？
Dans le fond, est- ce qu'on pourrait assigner à f une
本质上说，我们能否将变量‘f’赋值为一个‘Function’实例，
instance de Function qui correspond à cette fonction- là ici,
而该实例正对应此处这个函数，
qui correspond à une fonction qui prend en paramètre un nom qui est une variable de
即一个接收名为‘nom’的参数的函数，
type quelconque?
且该参数可为任意类型？
puis qui exécute le code suivant,
接着执行如下代码，
par exemple comme ça, ben
比如这样——
non. Non, on peut pas faire ça.
不，不行，这是不允许的。
On vient pas de changer la sémantique du langage Java.
我们并没有改变 Java 语言本身的语义。
Je vous disais tantôt qu'on
我之前提到过，
parlait de sucre syntaxique ici.
这里讲的是‘语法糖’。
Dans le fond du sucre syntaxique, c'est quelque chose qui affecte
所谓语法糖，本质上是仅影响
la syntaxe du langage seulement.
语言的语法层面。
Comme je l'expliquais, ce qui se passe ici vraiment,
正如我所解释的，实际情况是：
c'est que quand Java lit une affaire de même, quelque chose
当 Java 解析这类结构时，
comme ça, qui est assigné à une variable de type Function,
比如这样一个被赋值给 Function 类型变量的表达式，
donc vraiment si on revient ici, on sait que f est de type Function,
回到前面，我们知道变量‘f’的类型是 Function，
donc f doit absolument contenir quelque chose de type Function,
因此‘f’必须严格包含一个 Function 类型的对象，
doit absolument contenir une instance d'une classe compatible avec Function,
即必须是一个与 Function 兼容的类的实例，
ben avec un petit peu d'analyse,
通过稍加分析，
on est capable de se rendre compte que ce truc- là peut pas être n'importe quoi.
我们就能意识到：这个东西绝不能是任意内容。
Ce truc- là peut juste être une instance d'une classe anonyme de Function.
这个东西只是Function类的一个匿名实例。
Puis Function ça contient une seule affaire, ça contient
而Function类只包含一个成员，即
une fonction publique void Execute qui a
一个public void Execute方法，它接受
exactement ce paramètre- là, donc il y a ce type de paramètre- là,
恰好这个参数，因此参数类型就是这样的，
puis qui retourne exactement ce type de retour- là.
并且返回值类型也恰好是这样的。
c'est qu'on vient pas de changer le sens de Java,
这并不是说我们改变了Java的本意，
on vient pas de rajouter la possibilité de faire n'importe quoi avec ça.
也不是说我们突然赋予了它随意操作的能力。
Dans le fond, quand on écrit quelque chose qui ressemble à ça,
实际上，当我们写下类似这样的代码时，
il y a de l'analyse qui se fait automatiquement du côté de Java pour transformer ça
Java会在后台自动进行分析，并将它
automatiquement en ça.
自动转换成这样。
Fait que vraiment, le but est d'écrire exactement la même chose que ça,
所以，真正的目标就是写出和这个完全一样的逻辑，
mais avec moins de code.
但用更少的代码。
Donc, avec moins d'overhead, avec moins de mots qui veulent un peu rien dire dans le
也就是说，减少冗余开销，减少那些在当前语境中
contexte, pour que ce soit plus facile à lire ici.
几乎毫无意义的词语，从而让这里更易读。
Quand vous écrivez ce code- là,
当你写下这段代码时，
se transforme automatiquement en ce grâce à l'annotation d'interface fonctionnelle.
借助函数式接口注解，它会自动转换成这样。
Ok, donc c'est tout pour ce chapitre- ci.
好的，本章内容就到这里。
Je vous invite à réécouter ça tranquillement,
我建议你静下心来重新听一遍，
ça fait peut- être beaucoup de choses à
因为一下子可能要消化的内容有点多。
assimiler d'un coup.
（内容量较大）
Si jamais ça vous paraît pas tout de suite clair à quoi ça sert tout ça,
如果这些内容的作用你一时还不太清楚，
gardez ça dans un coin de votre tête puis
先把它记在脑海一角，
on va réutiliser ça dans le contexte des interfaces graphiques,
我们之后会在图形界面的上下文中再次用到它，
puis vous devriez voir assez rapidement qu'est- ce qu'on fait avec tout ça.
到时你应该很快就能明白我们究竟要用它做什么了。
Donc voilà.
好了，就是这样。