B2 · Episode 3 · 5:21
Anonymous Classes and Functional Interfaces in Java
This episode explains anonymous classes in Java—how they are defined inline, inherit from abstract classes or implement interfaces, and exist as single instances. It then introduces functional interfaces and syntactic sugar (introduced in Java 8) that streamline lambda-like behavior.
Source：Nicolas Hurtubise / classe.iro.umontreal.ca · License：CC BY-SA 4.0
Transcript
qui porte pas de nom, qui est concrète,
has no name and is concrete,
donc toutes les méthodes ont été implantées, on n'a rien d'abstract,
so all methods have been implemented—there’s nothing abstract,
c'est une classe qui va hériter d'une autre classe,
it’s a class that inherits from another class,
donc typiquement d'une classe abstraite, ou qui va implanter une interface.
typically an abstract class, or that implements an interface.
Puis c'est une classe qui est définie pile au moment de l'utiliser.
Moreover, it’s a class defined precisely at the moment it’s used.
C'est une méthode qui est définie directement au moment de l'utiliser dans la
It’s a method defined directly at the moment of use,
méthode qui l'utilise.
right inside the method that uses it.
Ça va ressembler à quelque chose comme ça.
It will look something like this.
Donc Function qu'on a défini plus haut, c'est une interface.
The Function we defined earlier is an interface.
Puis dans le fond, c'est une interface avec une seule méthode.
In essence, it’s an interface with just one method.
Bien, on peut se définir une instance d'une classe qui va implanter cette interface-
Good—we can create an instance of a class implementing this interface—
là de cette façon- là.
exactly in this way.
On va se définir vraiment un new, même
We’ll actually write ‘new’, even though
si Function ici c'est une interface, bien on dit new Function.
Function here is an interface—we still write ‘new Function’.
Puis on ouvre tout de suite des brackets pour aller mettre le contenu de
then immediately open braces to insert
la classe concrète, le contenu qu'on aurait dû mettre dans une classe qui hérite ou
the content of the concrete class—the content that would normally go into a class inheriting
qui implante cette interface- là.
or implementing this interface.
On va aller mettre ça directement là- dedans.
We’ll place that content directly inside.
Donc vraiment aller faire ça comme ça,
So doing it this way,
c'est équivalent à aller faire ce qu'on faisait avec ces classes- là qui implante
is equivalent to what we did earlier with those classes implementing the interface.
interface. Donc vraiment c'est le même concept,
It’s truly the same concept,
à la différence que c'est une classe dont il peut juste exister une seule instance.
except that only one instance of this class can ever exist.
Dans le fond, ça, ça possède pas de classe explicite.
In fact, it has no explicit class definition.
ça a pas de nom de classe, c'est vraiment une classe comme le nom le dit,
It has no class name—just as the name suggests,
une classe anonyme, une classe qui est pas nommée,
it’s an anonymous class, a nameless class,
puis qui est instanciée au même moment qu'elle est déclarée.
instantiated at the very moment it’s declared.
Fait que, mettons qu'on utilisait le concept de classe anonyme pour se simplifier le
So, suppose we use the concept of anonymous classes to simplify our work,
travail, on pourrait aller réécrire le code qu'on avait ici de cette façon- là.
we could rewrite the code here in this way.
Encore une fois, on va se définir une variable qui va contenir notre fonction,
Again, we’ll define a variable to hold our function,
notre genre de fonction qui est représentée par une classe.
a kind of function represented by a class.
Puis selon mac.
Then, depending on mac.
random plus petit que 0.5, on va aller définir notre fonction comme étant une
If random is less than 0.5,
instance d'une classe qui hérite de fonction qui contient cette méthode- là pour
we’ll define our function as an instance of a class that inherits from Function,
exécuter. Sinon, on définit f comme étant une instance d'une classe qui implémente
a class that contains this execute method.
fonction ici, mais qui va plutôt faire ça comme méthode exécuter.
Otherwise, we define f as an instance of a class implementing Function,
Puis à la fin, on peut l'utiliser.
but whose execute method does this instead.
Fait qu'on a ça ici.
Then, at the end, we can use it.
C'est déjà mieux, donc maintenant on a dans le fond,
So, we have this here.
si on regarde les fichiers qu'on a au total,
It’s already better—so now, essentially,
on va avoir besoin de function.
if we look at all our files,
Java pour définir notre interface function,
we’ll need function.java to define our Function interface,
on va avoir notre fonction principale pour exécuter ce code- là.
and our main function file to run this code.
Donc on a deux fichiers plutôt quatre, on a
So instead of four files, we now have two:
enlevé les classes qui servaient juste à déclarer
we’ve removed the classes used only for declaration,
ceci, ça qui allait être utilisé une seule fois dans tout le programme de toute
classes that were used just once across the entire program.
façon. Est- ce qu'on peut faire plus joli que ça ici?
Can we make this even cleaner and more elegant?
Ben. Ça reste visuellement plus lourd qu'en JavaScript.
Well, it still looks visually heavier than JavaScript.
Dans le fond, en JavaScript, quand on faisait quelque chose dans ce style- là,
In fact, in JavaScript, when we wrote something like this,
si on remonte encore une fois à notre premier exemple, bien on
if we go back again to our first example,
allait définir directement une fonction comme étant une valeur qu'on met dans une
we’d define a function directly as a value,
variable de cette façon- là ici.
assigning it to a variable like this.
Notre variable direBonjour va contenir
Our variable direBonjour will hold
la fonction qui fait telle affaire.
the function that performs this task.
Donc Java est déjà plus verbeux à ce niveau- là,
So Java is already more verbose at this level,
mais il y a peut- être moyen de faire de quoi pour contourner
but there may be a way to work around
ce problème- là.
this issue.
Dans le fond, à chaque fois qu'on va vouloir créer une nouvelle fonction avec ce
In fact, each time we want to create a new function using this
style- là. à chaque fois qu'on va vouloir aller créer une nouvelle fonction
style,
avec notre classe anonyme,
each time we want to create a new function
ben. On n'aura pas le choix d'écrire
using our anonymous class,
tout ça. Dans le fond, si on veut mettre une instance
well, we’ll have no choice but to write
de fonction dans notre variable f,
all of this. In short, if we want to assign an instance
Il va falloir qu'on écrive un new function,
of a function to our variable f,
il va falloir qu'on écrive la signature de la fonction avec les modificateurs,
we’ll need to write a ‘new function’,
avec tout ça, puis à l'intérieur de ça on met le code de la fonction.
write the function signature with its modifiers, and then place the function’s code inside it.
Dans le fond, quand on y pense,
In fact, when you think about it,
pour chacune des fonctions possibles qu'on va vouloir définir de cette façon- là,
for every possible function we might define this way,
donc pour chacune des fonctions possibles, ce
so for each possible function,
code- là va être répété.
this code will be repeated.
Toute cette section- là, new function quelque chose quelque chose public void
All this section—‘new function’, something, something, ‘public void’,
execute string arg.
‘execute(String arg)’,
Tout ça va être répété, ce qui n'est pas super pratique.
will be repeated—which isn’t very convenient.
Et puis les gens qui développent Java se sont rendu compte de ça.
And Java developers realized this.
Puis on décidé d'arriver avec un mécanisme pour rendre ça un petit peu plus
So they decided to introduce a mechanism to make this slightly
gracieux. Pour avoir de quoi un petit peu plus joli que ce que je viens de vous
more elegant. To offer something slightly prettier than what I just showed you,
montrer, on a du sucre syntaxique à partir de Java 8.
we’ve had syntactic sugar since Java 8.
Donc du sucre syntaxique, c'est essentiellement de la syntaxe additionnelle dans le
So, syntactic sugar is essentially additional syntax in the
langage qui est équivalente à autre chose qui existe déjà.
language that is equivalent to something already existing.
Puis dans le fond, si on ajoute l'annotation functional interface par- dessus notre
In fact, if we add the @FunctionalInterface annotation over our
déclaration de notre interface fonction.
declaration of a functional interface.
Ben, Java va comprendre avec la syntaxe moins lourde quand on essaie de faire ce
Well, Java will understand—using lighter syntax—when we try to do
genre de choses.
this kind of thing.
Dans le fond, quand on déclare une interface comme étant une interface
In fact, when we declare an interface as a functional interface,
fonctionnelle, Java va nous permettre de plutôt utiliser cette syntaxe là.
Java lets us use this more concise syntax instead.
Java vraiment Comprendre que plus que fonction, c'est une interface fonctionnelle.
Java truly understands that it’s not just a function—it’s a functional interface.