Java 1.5

Des nouveaut´ es de java 1.5
Java 1.5
USTL http://www.lifl.fr/∼routier 1
Des nouveaut´ es de java 1.5
Nouveaut´ es
types ´ enum´ er´ es,
“autoboxing”,
forme syntaxique du for type for-each,
m´ ethodes d’arit´ e variable,
entr´ ees-sorties,
type g´ en´ erique
USTL http://www.lifl.fr/∼routier 2
Types ´ enum´ er´ es
enum
permet de d´ efinir des (vrais) types ´ enum´ er´ es,
les constantes sont des instances du type d´ efini,
possibilit´ e d’utiliser la structure switch sur les valeurs du type,
ce qui est mis en place correspond ` a ce qui a ´ et´ e vu en cours, mais toute la
“logistique” est faite automatiquement...
public enum Saison {hiver, printemps, ete, automne }
Saison s = Saison.hiver;
USTL http://www.lifl.fr/∼routier 3
Types ´ enum´ er´ es
Ce qui est fourni...
m´ ethode name() et ordinal(),
factory valueOf(String),
tableaux des valeurs values(),
compareTo (un type ´ enum´ er´ eimplements Comparable)
֒→ordre de d´ eclaration des constantes (nb : la m´ ethode est final)
s´ erialisation/d´ es´ erialisation (un type ´ enum´ er´ eimplements Serializable)
USTL http://www.lifl.fr/∼routier 4
Types ´ enum´ er´ es
Premier exemple
package saison;
public enum Saison {
hiver, printemps, ete, automne;
//================================================================
public static void main (String[] args) {
Saison value = Saison.valueOf(args[0]);
switch(value){
case hiver : System.out.println(" hiver "+ete.compareTo(value)); break;
case printemps : System.out.println(+" printemps "+ete.compareTo(value)); break;
case ete : System.out.println(" ete "+ete.compareTo(value)); break;
case automne : System.out.println(" automne "+ete.compareTo(value));break;
}
Comparable c = Saison.ete;
System.out.println(c.getClass());
for (int i = 0; i< Saison.values().length; i++ ) {
Saison v = Saison.values()[i];
System.out.println( " -> "+ v.name()+" : "+ v.ordinal());
}
}
----------------------------------------------------------------------
javac -d ../classes saison.Saison.java
java saison.Saison hiver java saison.Saison ete
hiver 2 ete 0
class saison.Saison ...
-> hiver :0
-> printemps : 1
-> ete : 2
-> automne : 3
USTL http://www.lifl.fr/∼routier 5
Types ´ enum´ er´ es
Ajouter des attributs et des m´ ethodes
package coin;
public enum Coin {
penny(1,CoinColor.copper),
nickel(5,CoinColor.nickel),
dime(10,CoinColor.silver),
quarter(25,CoinColor.silver);
private Coin(int value, CoinColor color) {
this.value = value;
this.color = color;
}
private final int value;
private final CoinColor color;
public int getValue() {return this.value; }
public CoinColor getColor() {return this.color; }
private enum CoinColor {copper, nickel, silver }
}
USTL http://www.lifl.fr/∼routier 6

Types ´ enum´ er´ es
M´ ethodes diff´ erenci´ ees pour chaque constante
package operation;
import java.util.*;
public enum Operation {
plus {
public double eval(double x, double y) {return x + y; }
},
minus {
public double eval(double x, double y) {return x - y; }
},
times {
public double eval(double x, double y) {return x *y; }
},
divided by {
public double eval(double x, double y) {return x / y; }
};
public abstract double eval(double x, double y);
//----------------------------------------------------------------------
public static void main(String args[]) {
double x = Double.parseDouble(args[0]);
double y = Double.parseDouble(args[1]);
for (int i = 0; i < Operation.values().length; i++) {
System.out.println(x + " " + op + " " + y + " = " + Operation.values()[i].eval(x, y));
}
}
}
java operation.Operation 6 3
6.0 plus 3.0 = 9.0
6.0 minus 3.0 = 3.0
6.0 times 3.0 = 18.0
6.0 divided by 3.0 = 2.0
USTL http://www.lifl.fr/∼routier 7
Autoboxing
AutoBoxing
Faciliter les conversions d’un type primitif vers le type objet associ´ e (et
respectivement)
All´ eger la syntaxe (appel de constructeurs/m´ ethodes (xxxValue()))
Integer i = new Integer(10);
int j = i;
Integer k = 12;
USTL http://www.lifl.fr/∼routier 8
Un for-each
for ` a la for-each
Pour parcourir une collection ou un tableau.
for (Type id : Expression)
Statement
Expression est un tableau ou une instance de java.lang.Iterable
Exemples :
int[] tabInt = ...;
int somme = 0;
for(int e : tabInt) {
somme = somme+e;
}
Collection c = ...;
for(Object o : c) {
System.out.println(o);
}
USTL http://www.lifl.fr/∼routier 9
Arit´ e variable
Arit´ e variable
method(Type ... id): 0 ` anarguments de type T
revient (sf syntaxe appel) ` amethod(T[] id)
public class TestVarArgs {
public void ms(String ... args){
for(String s : args)
System.out.print(s+".");
System.out.println("+");
}
public void mi(String a, int ... args){
for(int i : args)
System.out.print(i+".");
System.out.println("+");
}
//----------------------------------------------------------------------
public static void main(String[] args) {
TestVarArgs t = new TestVarArgs(); +=================================
t.ms("tim","oleon"); | tim.oleon.+
t.mi("a",1,2,3); | 1.2.3.+
t.ms("ti","mo","leon"); | ti.mo.leon.+
t.mi("a",1,2,3,4,5); | 1.2.3.4.5.+
t.ms(); | +
}
}// TestVarArgs
USTL http://www.lifl.fr/∼routier 10
Entr´ ees-sorties
printf()
voir javadoc...
java.util.Scanner
Permet de r´ ecup´ erer des chaˆ ıne de caract` eres ou types primitifs.
D´ ecomposition en token ` a l’aide d’un motif (par d´ efaut espace), comportement “` a la
it´ erateur”
// lecture sur entr´ ee standard
Scanner sc = Scanner(System.in); // bloquant
int i = sc.nextInt();
// lecture de type primitif dans un fichier
Scanner sc = Scanner(new File("myNumbers"));
while (sc.hasNextLong()) {
long aLong = sc.nextLong();
}
// utilisation de d´ elim d´ ef par une exp r´ eguli` ere java.util.regex.Pattern
String input = "1 fish 2 fish red fish blue fish";
Scanner s = Scanner(input).useDelimiter("\\s*fish\\s*"); +---------
System.out.printf("%d %d\n",s.nextInt(), s.nextInt()); | 1 2
System.out.println(s.next()); | red
System.out.println(s.next()); | blue
s.close();
USTL http://www.lifl.fr/∼routier 11
Types g´ en´ eriques
Types g´ en´ eriques
Types “param´ etr´ es” / templates.
permettre de d´ efinir des types param´ etr´ es par d’autres types
Avantage : renforcer le typage (d` es la compilation)
USTL http://www.lifl.fr/∼routier 12

Types g´ en´ eriques
Exemples : les collections dans java 1.5
Possibilit´ e de d´ efinir des collections typ´ ees
List<String> l = new ArrayList<String>();
l.add("timoleon");
l.add("bilbo");
l.add("Smaug");
// l.add(new Integer(1)); // ne compile pas
Iterator<String> i = l.iterator();
while(i.hasNext()) {
String s = i.next(); // pas de cast n´ ecessaire
System.out.println("> "+s);
}
String value = l.remove(0); // pas de cast n´ ecessaire
System.out.println(value+" removed");
for(String s : l) {// pas de cast n´ ecessaire
System.out.println("> "+s);
}
USTL http://www.lifl.fr/∼routier 13
Types g´ en´ eriques
Sous-types et g´ en´ eriques
Collection<String> n’est pas un sous-type de Collection<Object>
ArrayList<String> est un sous-type de Collection<String>
Cons´ equence, soit :
public void dump(Collection<Object> c) {
for (Object o : c) {
System.out.println(o);
}
}
ne peut pas prendre pour param` etre autre chose qu’une Collection<Object>
xxx.dump(new ArrayList<Hobbit>()) ne compile pas !
Collection<Object> ne signifie pas
“n’importe quelle collection pourvue qu’elle contienne des objets”
mais bien “collection d’Objects”
USTL http://www.lifl.fr/∼routier 14
Types g´ en´ eriques
Jokers
Comment exprimer “n’importe quelle collection” ?
c` ad le supertype de toutes les collections
Collection<?> (collection d’inconnus)
La seule garantie sur les ´ el´ ements c’est que ce sont des Objects
public void dump(Collection<?> c) {
for (Object o : c) {
System.out.println(o);
}
}
xxx.dump(new ArrayList<Hobbit>()) est l´ egal.
Mais :
Collection<?> c = new ArrayList<Hobbit>();
c.add(new Hobbit(...)); // ne compile pas, mauvais typage de add
(inf´ erence de type)
USTL http://www.lifl.fr/∼routier 15
Types g´ en´ eriques
Joker born´ e
public abstract class Shape {public abstract void draw(Canvas c); }
public class Circle extends Shape {
public void draw(Canvas c) {... }
}
public class Rectangle extends Shape {
public void draw(Canvas c) {... }
}
public class Canvas {
public void draw(Shape s) {s.draw(this); }
}
Quelle signature pour une m´ ethode drawAll qui dessine toutes les Shapes :
public void drawAll(???? shapes){
for (Shape s : shapes) {s.draw(this); }
}
drawAll(List<Shape> shapes) est trop pr´ ecis : car refuse List<Circle>
drawAll(List<?> shapes) est trop vague, car accepte List<String>
Ce que l’on veut : “Collection de n’importe quoi de type Shape”
drawAll(List<? extends Shape> shapes)
NB : extends mˆ eme pour interfaces, super existe aussi
USTL http://www.lifl.fr/∼routier 16
Types g´ en´ eriques
Cr´ eer un type g´ en´ erique
package value;
public class Value<T> {
private Tv;
public Value (Tv){
this.v = v;
}
public TgetValue() {
return this.v;
}
}// Value
package value;
public class Context {
private Map<String,Value> lesVariables;
public Context() {
lesVariables = new HashMap<String,Value>();
}
public void addVariable(String id, Value var) {
lesVariables.put(id, var);
}
public Value getVariable(String id) {
return lesVariables.get(id);
}
//=================================================
public static void main(String[] args) {
Context c = new Context();
c.addVariable("v1", new Value<Integer>(12));
c.addVariable("v2", new Value<Boolean>(true));
S.o.p("v1: "+c.getVariable("v1").getClass());
S.o.p("v2: "+c.getVariable("v2").getValue().getClass());
}
}// Context
Trace :
v1: class value.Value
v2: class java.lang.Boolean
USTL http://www.lifl.fr/∼routier 17
Types g´ en´ eriques
M´ ethode g´ en´ erique
m´ ethode param´ etr´ ee par un type
Dans la classe Context ajouter une m´ ethode addValue qui prend l’identifiant et
une valeur du type qui param` etre Value<T> :
public <T> void addValue(String id,Tvalue) {
Value<T> v = new Value<T>(value);
this.addVariable(id, v);
}
//------------------------------------------
Context c = new Context();
c.addValue("var3",10);
c.addValue("var4",true);
USTL http://www.lifl.fr/∼routier 18

Types g´ en´ eriques
Attention
Rappel : Le polymorphisme existe toujours !!!
Ne pas utiliser les g´ en´ eriques quand le polymorphisme convient.
public void recycle(<? extends Recyclable> r)
revient ` a (mais est moins clair que) :
public void recycle(Recyclable r)
Utiliser les g´ en´ eriques pour renforcer le typage quand le besoin existe.
USTL http://www.lifl.fr/∼routier 19