B2 · 第3集 · 5:21
Java匿名类与函数式接口
本集讲解Java中匿名类的定义与使用，以及如何通过函数式接口和语法糖简化代码。
来源：Nicolas Hurtubise / classe.iro.umontreal.ca · 许可：CC BY-SA 4.0
字幕
qui porte pas de nom, qui est concrète,
没有名称，且是具体的，
donc toutes les méthodes ont été implantées, on n'a rien d'abstract,
因此所有方法都已实现，没有任何抽象内容，
c'est une classe qui va hériter d'une autre classe,
它是一个将继承另一个类的类，
donc typiquement d'une classe abstraite, ou qui va implanter une interface.
通常继承自一个抽象类，或实现某个接口。
Puis c'est une classe qui est définie pile au moment de l'utiliser.
此外，它是在使用时才正确定义的类。
C'est une méthode qui est définie directement au moment de l'utiliser dans la
这是一种在使用时直接定义的方法，
méthode qui l'utilise.
就在调用它的那个方法内部。
Ça va ressembler à quelque chose comme ça.
它看起来会像这样。
Donc Function qu'on a défini plus haut, c'est une interface.
之前定义的 Function 是一个接口。
Puis dans le fond, c'est une interface avec une seule méthode.
本质上，这是一个只含一个方法的接口。
Bien, on peut se définir une instance d'une classe qui va implanter cette interface-
好，我们可以创建一个实现该接口的类的实例——
là de cette façon- là.
就以这种方式。
On va se définir vraiment un new, même
我们真的会写 new，即使
si Function ici c'est une interface, bien on dit new Function.
这里的 Function 是一个接口，我们仍写作 new Function。
Puis on ouvre tout de suite des brackets pour aller mettre le contenu de
接着立即用花括号展开，填入
la classe concrète, le contenu qu'on aurait dû mettre dans une classe qui hérite ou
具体类的内容，也就是本该写在继承该接口
qui implante cette interface- là.
或实现该接口的类中的内容。
On va aller mettre ça directement là- dedans.
我们将直接把这部分内容放进去。
Donc vraiment aller faire ça comme ça,
所以，真正这样操作，
c'est équivalent à aller faire ce qu'on faisait avec ces classes- là qui implante
等价于之前用那些实现接口的类所做的事情。
interface. Donc vraiment c'est le même concept,
本质上概念完全相同，
à la différence que c'est une classe dont il peut juste exister une seule instance.
区别仅在于：这个类只能存在唯一一个实例。
Dans le fond, ça, ça possède pas de classe explicite.
实际上，它并没有显式的类定义。
ça a pas de nom de classe, c'est vraiment une classe comme le nom le dit,
它没有类名，正如其名所示，
une classe anonyme, une classe qui est pas nommée,
它是一个匿名类，一个未命名的类，
puis qui est instanciée au même moment qu'elle est déclarée.
并且在声明的同时就被实例化。
Fait que, mettons qu'on utilisait le concept de classe anonyme pour se simplifier le
因此，假设我们使用匿名类概念来简化工作，
travail, on pourrait aller réécrire le code qu'on avait ici de cette façon- là.
就可以将此处的代码重写成这种方式。
Encore une fois, on va se définir une variable qui va contenir notre fonction,
再次说明，我们将定义一个变量，用于存储我们的函数，
notre genre de fonction qui est représentée par une classe.
即一种由类表示的函数。
Puis selon mac.
然后根据 mac。
random plus petit que 0.5, on va aller définir notre fonction comme étant une
若 random 小于 0.5，
instance d'une classe qui hérite de fonction qui contient cette méthode- là pour
我们就把函数定义为一个继承自 Function 类的实例，
exécuter. Sinon, on définit f comme étant une instance d'une classe qui implémente
该类包含这个 execute 方法；
fonction ici, mais qui va plutôt faire ça comme méthode exécuter.
否则，就把 f 定义为一个实现 Function 接口的类的实例，
Puis à la fin, on peut l'utiliser.
但其 execute 方法会执行这一操作。
Fait qu'on a ça ici.
最后，我们就能使用它了。
C'est déjà mieux, donc maintenant on a dans le fond,
所以，我们现在有了这个。
si on regarde les fichiers qu'on a au total,
这已经更好了——现在本质上，
on va avoir besoin de function.
如果我们查看所有文件，
Java pour définir notre interface function,
就需要 function.java 来定义 Function 接口，
on va avoir notre fonction principale pour exécuter ce code- là.
还需要主函数文件来运行这段代码。
Donc on a deux fichiers plutôt quatre, on a
因此，我们原本有四个文件，现在减少到两个：
enlevé les classes qui servaient juste à déclarer
我们删去了那些仅用于声明的类，
ceci, ça qui allait être utilisé une seule fois dans tout le programme de toute
而这些类在整个程序中只用一次。
façon. Est- ce qu'on peut faire plus joli que ça ici?
我们还能让这里更简洁美观吗？
Ben. Ça reste visuellement plus lourd qu'en JavaScript.
嗯，视觉上仍比 JavaScript 更繁重。
Dans le fond, en JavaScript, quand on faisait quelque chose dans ce style- là,
实际上，在 JavaScript 中，当我们写这种代码时，
si on remonte encore une fois à notre premier exemple, bien on
如果再回到第一个例子，
allait définir directement une fonction comme étant une valeur qu'on met dans une
我们会直接将函数定义为一个值，
variable de cette façon- là ici.
并以这种方式赋给一个变量。
Notre variable direBonjour va contenir
我们的变量 direBonjour 将保存
la fonction qui fait telle affaire.
执行该操作的函数。
Donc Java est déjà plus verbeux à ce niveau- là,
因此，Java 在这方面本身就更啰嗦，
mais il y a peut- être moyen de faire de quoi pour contourner
但也许有办法绕过
ce problème- là.
这一问题。
Dans le fond, à chaque fois qu'on va vouloir créer une nouvelle fonction avec ce
实际上，每次我们想用这种方式
style- là. à chaque fois qu'on va vouloir aller créer une nouvelle fonction
创建一个新函数时，
avec notre classe anonyme,
每次我们想用匿名类
ben. On n'aura pas le choix d'écrire
创建一个新函数时，
tout ça. Dans le fond, si on veut mettre une instance
我们就不得不写下
de fonction dans notre variable f,
这个实例赋值给变量 f，
Il va falloir qu'on écrive un new function,
就必须写一个 new function，
il va falloir qu'on écrive la signature de la fonction avec les modificateurs,
必须写出带修饰符的函数签名，
avec tout ça, puis à l'intérieur de ça on met le code de la fonction.
并在其中放入函数代码。
Dans le fond, quand on y pense,
实际上，仔细想想，
pour chacune des fonctions possibles qu'on va vouloir définir de cette façon- là,
对于所有可能以这种方式定义的函数，
donc pour chacune des fonctions possibles, ce
也就是说，对每个可能的函数，
code- là va être répété.
这段代码都会被重复。
Toute cette section- là, new function quelque chose quelque chose public void
整个这一段——‘new function’、某些内容、某些内容、‘public void’，
execute string arg.
‘execute(String arg)’，
Tout ça va être répété, ce qui n'est pas super pratique.
都会被重复，这显然不太方便。
Et puis les gens qui développent Java se sont rendu compte de ça.
而开发 Java 的工程师们也意识到了这一点。
Puis on décidé d'arriver avec un mécanisme pour rendre ça un petit peu plus
于是他们决定引入一种机制，让这种写法
gracieux. Pour avoir de quoi un petit peu plus joli que ce que je viens de vous
显得更优雅一些。为了提供比刚才演示的
montrer, on a du sucre syntaxique à partir de Java 8.
更美观的写法，Java 8 起引入了语法糖。
Donc du sucre syntaxique, c'est essentiellement de la syntaxe additionnelle dans le
因此，语法糖本质上是语言中额外的语法，
langage qui est équivalente à autre chose qui existe déjà.
它等价于语言中已有的其他内容。
Puis dans le fond, si on ajoute l'annotation functional interface par- dessus notre
实际上，如果我们在函数式接口声明上
déclaration de notre interface fonction.
添加@FunctionalInterface注解，
Ben, Java va comprendre avec la syntaxe moins lourde quand on essaie de faire ce
那么Java就能借助更简洁的语法，
genre de choses.
理解我们尝试做这类事情时的意图。
Dans le fond, quand on déclare une interface comme étant une interface
实际上，当我们把一个接口声明为函数式接口时，
fonctionnelle, Java va nous permettre de plutôt utiliser cette syntaxe là.
Java就允许我们使用这种更简洁的语法。
Java vraiment Comprendre que plus que fonction, c'est une interface fonctionnelle.
Java真正理解的是：它不只是一个函数，而是一个函数式接口。