pdf/4

Quelques notions de Java supplémentaires
Le mot-clé final
Première utilisation : interdire l’extension d’une classe
Programmation et Conception Orientées Objet
final public class Integer {
}
Bertrand Estellon
Deuxième utilisation : interdire la redéfinition d’une méthode
Département Informatique et Interactions
Aix-Marseille Université
public class VariadicOperator {
/* ... */
final public double value() { /* ... */ }
/* ... */
}
17 novembre 2016
Bertrand Estellon (DII – AMU)
Prog. et Conception Orientées Objet
17 novembre 2016
1 / 466
Quelques notions de Java supplémentaires
Bertrand Estellon (DII – AMU)
Prog. et Conception Orientées Objet
17 novembre 2016
Le mot-clé final
Le mot-clé final
Troisième utilisation : interdire la modification d’un attribut
Quatrième utilisation : interdire la modification d’une variable
public class Stack<T> {
/* ... */
public T pop() {
final T top = array[size-1];
array[size-1] = null; size--;
return top;
}
/* ... */
}
final public class Integer {
private final int value;
public Integer(int value) { this.value = value; }
}
▶
L’attribut doit être initialisé après la construction de l’instance ;
▶
La valeur de l’attribut ne peut plus être modifiée ensuite.
Bertrand Estellon (DII – AMU)
Prog. et Conception Orientées Objet
225 / 466
Quelques notions de Java supplémentaires
17 novembre 2016
226 / 466
Bertrand Estellon (DII – AMU)
Prog. et Conception Orientées Objet
17 novembre 2016
227 / 466
Quelques notions de Java supplémentaires
Quelques notions de Java supplémentaires
Les classes anonymes
Les classes anonymes
Supposons que nous ayons l’interface suivante :
public class Window {
private int counter;
public interface ActionListener {
public void actionPerformed(ActionEvent event);
}
public Window() {
Button button = new Button("count");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
counter++;
}
});
}
Il est possible de :
▶
définir une classe anonyme qui implémente cette interface ;
▶
d’obtenir immédiatement une instance de cette classe
ActionListener listener = new ActionListener() {
public void actionPerformed(ActionEvent event) {
counter++;
}
});
Bertrand Estellon (DII – AMU)
Prog. et Conception Orientées Objet
17 novembre 2016
}
228 / 466
Bertrand Estellon (DII – AMU)
Quelques notions de Java supplémentaires
Prog. et Conception Orientées Objet
17 novembre 2016
Les classes anonymes
Les classes anonymes
Il est possible d’utiliser des attributs de la classe “externe” :
Il est possible d’utiliser des variables finales de la méthode :
public class Window {
private Counter counter = new Counter();
public class Window {
public Window() {
final Counter counter = new Counter();
Button button = new Button("count");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
counter.count();
}
});
}
public Window() {
Button button = new Button("count");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
counter.count();
}
});
}
}
Bertrand Estellon (DII – AMU)
229 / 466
Quelques notions de Java supplémentaires
}
Prog. et Conception Orientées Objet
17 novembre 2016
230 / 466
Bertrand Estellon (DII – AMU)
Prog. et Conception Orientées Objet
17 novembre 2016
231 / 466
Quelques notions de Java supplémentaires
Quelques notions de Java supplémentaires
Java 8 : Lambda expressions
Java 8 : Lambda expressions
public interface ActionListener {
public void actionPerformed(ActionEvent event);
}
Les trois interfaces suivantes sont définies :
public interface Predicate<T> {
public boolean test(T t);
}
Avec Java 8, il est possible d’écrire directement :
public class Window {
public Window() {
Button button = new Button("button");
button.addActionListener(
event -> System.out.println(event)
);
}
}
public interface Function<T,R> {
public R apply(T t);
}
public interface Consumer<T> {
void accept(T t);
}
Explication : ActionListener possède une seule méthode donc on peut
affecter une lambda expression à une variable de type ActionListener.
Bertrand Estellon (DII – AMU)
Prog. et Conception Orientées Objet
17 novembre 2016
232 / 466
Bertrand Estellon (DII – AMU)
Quelques notions de Java supplémentaires
Java 8 : Lambda expressions
persons
.stream()
.map(Person::getName) /* person->person.getName() */
.forEach(name -> System.out.println(name));
Un autre exemple :
String[] strings = { "Truc", "Machin", "Bidule" };
Arrays.sort(strings, String::compareToIgnoreCase);
/* (s1,s2)->s1.compareToIgnoreCase(s2)); */
Types des paramètres et retours des méthodes :
▶
▶
stream() → Stream<Person>
filter(Predicate<Person>) → Stream<Person>
map(Function<Person, String>) → Stream<String>
Il est également possible de (Java Tutorials) :
forEach(Consumer<String>)
Bertrand Estellon (DII – AMU)
Prog. et Conception Orientées Objet
233 / 466
On peut faire référence à une méthode :
persons
.stream()
.filter(person -> person.getAge() >= 18)
.map(person -> person.getName())
.forEach(name -> System.out.println(name));
▶
17 novembre 2016
Java 8 : Faire référence à une méthode
On peut écrire directement :
▶
Prog. et Conception Orientées Objet
Quelques notions de Java supplémentaires
17 novembre 2016
234 / 466
▶
faire référence à une méthode d’une instance ;
▶
faire référence à un construction.
Bertrand Estellon (DII – AMU)
Prog. et Conception Orientées Objet
17 novembre 2016
235 / 466