PDF de programación - Novedades J2SE 5

J2SE 5

Novedades
Novedades

© 2007, Grupo Salenda, S.L.

Introducción
Introducción

bli d

• Publicada en agosto de 2004.
• Lo más destacado:
Lo más destacado:
– Nuevas funcionalidades del lenguaje.
i
C

• Compatible con versiones anteriores.

d

i

tibl

t

2

Métodos con lista variable de
argumentos
• Variación de la sobrecarga: métodos que
aceptan cualquier número de argumentos
del mismo tipo:

ió d l
q

i
p

b

é d
g

public class Statistics {
p
{

public float average(int x1, int x2){}
public float average(int x1, int x2, int x3){}
public float average(int x1 int x2 int x3 int x4){}
public float average(int x1, int x2, int x3, int x4){}

}

• Invocación
• Invocación:

float res1 = stats.average(4, 3, 4);
fl
)
float res2 = stats.average(24, 32, 27, 18);

(

3

Varargs: argumentos variables
Varargs: argumentos variables

• Estos métodos se pueden agrupar:

é d

d

public class Statistics {
public class Statistics {

public float average(int... nums){

int sum = 0;

//nums es un int[]
f
for (int x : nums) {
) {

(i t

sum += x;

}}
return ((float) sum) / nums.length;

}

}

4

Tipos enumerados
Tipos enumerados

p

p

• Son conjuntos

finitos de símbolos que
representan los valores posibles de un
atributo.
– Ej: palos={ OROS , COPAS , ESPADAS , BASTOS }.
Ej: palos={“OROS” “COPAS” “ESPADAS” “BASTOS”}
• Nota: no confundir con la clase
java.util.Enumeration.

5

Tipos enumerados
Tipos enumerados

• Antes de Java 5:

package cards.domain;
public class PlayingCard {

t ti

fi

bli

l i t SUIT SPADES

//pseudo enumerado
public static final int SUIT_SPADES = 0;
0
public static final int SUIT_HEARTS = 1;
public static final int SUIT_CLUBS = 2;
public static final int SUIT DIAMONDS = 3;
public static final int SUIT_DIAMONDS = 3;
private int suit;
private int rank;
private int rank;
public PlayingCard(int suit, int rank) {
this.suit = suit; this.rank = rank;
;
}

;

6

Tipos enumerados
Tipos enumerados

public String getSuitName() {

g

String name = “”;
;
switch(suit) {

case SUIT_SPADES:

name = “Spades”;
break;

case SUIT_HEARTS:

name = “Hearts”;
b
k
break;

case SUIT_CLUBS:

name = “Clubs”;
k
break;
b

case SUIT_DIAMONDS:

name = “Diamonds”;
break
break;

default:

System.err.println(“Invalid suit”);

}
}
return name;

}

7

Tipos enumerados
Tipos enumerados
• Problemas:
• Problemas:

– No es “type-safe”.

• Como suit es entero se puede pasar cualquier otro valor
Como suit es entero, se puede pasar cualquier otro valor
sin significado.
• Alguien podría hacer operaciones aritméticas con suit, lo
cual no tiene sentido.

tid

ti

l

– No hay espacio de nombres.

• Las constantes se deben prefijar con SUIT para evitar
• Las constantes se deben prefijar con SUIT_ para evitar
colisiones con otras constantes.

– Comportamiento frágil.

p

g

• Si se añaden constantes o se modifica el orden, hay que
recompilar los clientes para que se actualicen con los
nuevos valores
nuevos valores.

8

Tipos enumerados
Tipos enumerados

• Problemas:

– Valores no informativos.

• Son enteros. Si se imprimen, aparece un número. Es
necesario escribir un método que ofrezca una
representación textual legible.

q

9

Tipos enumerados
Tipos enumerados

A

ti d J

• A partir de Java 5:
5
package cards.domain;
package cards.domain;
public class Suit{

public enum SuitValue {SPADES,HEARTS,CLUBS,DIAMONDS}

}

10

Tipos enumerados
Tipos enumerados

package cards.domain;
public class PlayingCard {
public class PlayingCard {

private Suit.SuitValue suit;
private int rank;
private int rank;
public PlayingCard(Suit.SuitValue suit,

}}

int rank) {
int rank) {

this.suit = suit;
this.rank = rank;

11

public String getSuitName() {

Tipos enumerados
Tipos enumerados
String name = “”;
switch(suit) {
case SPADES:
name = “Spades”;
break;
break;
case HEARTS:
name = “Hearts”;
break;
case CLUBS:
name = “Clubs”;
break;
name = “Diamonds”;
break;

case DIAMONDS:
case DIAMONDS:

// No hace falta comprobar tipos
// erróneos: Suit es un conjunto
// finito

}
return name;
return name;
}

}

12

Tipos enumerados avanzados
Tipos enumerados avanzados

package cards.domain;
public class PlayingCards{

public enum Suit {(“

d

”)

(“Spades”),
(“Hearts”),
(“Clubs”),

SPADES
HEARTS
CLUBS
DIAMONDS (“Diamonds”);
DIAMONDS (“Diamonds”);
private final String name;
private Suit(String name) {
}}
public String getName() {
}

this.name = name;

return name;
;

}

}

13

Autoboxing de tipos primitivos
Autoboxing de tipos primitivos

l

(

l b

i

b

i

• En J2SE 5, el boxing y el unboxing se
hacen automáticamente (autoboxing).
g)
int pInt = 500;
Integer wInt = pInt; //boxing
i t
int p2 = wInt; //unboxing
– No se debe abusar de esta funcionalidad para

// b

I t

2

i

evitar problemas de rendimiento.

14

Autoboxing de tipos primitivos
Autoboxing de tipos primitivos

• ¡Cuidado!

id d

Integer iObjeto1 = 1000;
Integer iObjeto1 = 1000;
Integer iObjeto1 1000;
Integer iObjeto1 1000;
Integer iObjeto2 = 1000;
Integer iObjeto2 = 1000;

int i1= 1000;
int i1= 1000;
int i1= 1000;
int i1= 1000;
int i2= 1000;
int i2= 1000;

(i2
?
?
(i2 == i1) // resultado = ?
(i2
(i2 == i1) // resultado = ?

i1) // resultado
i1) // resultado

(i2 == iObjeto1) // resultado = ?
(i2 == iObjeto1) // resultado = ?

(iObjeto2 == iObjeto1) // resultado = ?
(iObjeto2 == iObjeto1) // resultado = ?

Integer i= null;
Integer i= null;
Integer i null;
Integer i null;
int i2= i;
int i2= i;

¿Qué ocurre aquí?
¿Qué ocurre aquí?
¿Qué ocurre aquí?
¿Qué ocurre aquí?

15

Static import
Static import

• Para acceder a los miembros estáticos de

á i

d

b

d

i

l
y q

una clase, hay que:
– O bien proporcionar su nombre plenamente

cualificado.
cualificado.

J

– O bien importar la clase.
• En Java 5 existe la posibilidad de importar
E
todos los miembros estáticos de una clase
o incluso los valores de un enumerado.

ibilid d d i

i t

5

t

l

16

Static import
Static import
• Antes:
Antes:
public class Maths {

}

}
}
• Ahora:
import static java.lang.Math.*;
public class Maths {

public static void main(String[] args) {

double r = java.lang.Math.cos(2*java.lang.Math.PI);
System.out.println(r);

public static void main(String[] args) {
public static void main(String[] args) {

double r = cos(2*PI);
System.out.println(r);

}

}

17

Genéricos
Genéricos

• En el API

Collections

j

tradicional,

las
colecciones eran colecciones de Object.
Esto obligaba al programador a hacer un
casting lo cual no es “type-safe”:
casting, lo cual no es type safe :
ArrayList list = new ArrayList();
list.add(0, new Integer(42));
int total = ((Integer)list.get(0)).intValue();
//Lo siguiente compila, pero falla al ejecutar
String total = (String)list.get(0);

18

Genéricos
Genéricos

• En Java 5,

las colecciones pueden ser
lo cual

definidas de un tipo concreto,
,
aporta dos ventajas:
– Evita la necesidad de hacer casting.
Evita la necesidad de hacer casting
– Permite la comprobación de errores en tiempo

p

y

de compilación
de compilación.
ArrayList<Integer> list =
new ArrayList<Integer>();
();
list.add(0, new Integer(42));
//Genéricos & autoboxing
//Genéricos & autoboxing
int total = list.get(0);

g

19

Warnings del compilador
Warnings del compilador

• El compilador de Java 5 lanza warnings

sobre el código 1.4 sin uso de genéricos

g

g

public class GenericsWarning {

public static void main(String[] args) {

Li t li t
Li t()
List list = new ArrayList();
list.add(0, new Integer(42));
int total =((Integer)list.get(0)).intValue();

A

}

}
javac GenericWarnings.java
j
Note: GenericWarnings.java uses unchecked or unsafe
operations.
p
Note: Recompile with -Xlint:unchecked for details.

g

j

20

Warnings del compilador
Warnings del compilador

javac -Xlint:unchecked GenericWarnings.java
GenericWarnings.java:5: warning: [unchecked]
unchecked call to add(int,E) as a member of the
raw type java.util.List

list.add(0, new Integer(42));
));

( ,

g

(

^

21

Nuevo bucle for
Nuevo bucle for

• Con iteradores (Java 1.4):

public void printAll(Collection c) {
p

p

Iterator it = c.iterator();
while (it.hasNext()) {
g)
(

String element =(String)it.next();
();
System.out.println(element);

g

}

}
}

• Con iteradores y genéricos:

public void printAll(Collection<String> c) {

for (Iterator<String> i=c.iterator(); i.hasNext(); ){

String element = i.next();
S stem o t println(element)
System.out.println(element);

}

}

22

Nuevo bucle for
Nuevo bucle for

• Con el nuevo bucle for:

p

(

public void printAll(Collection<String> c) {
p
) {

g

for (String s : c) {
}
}

System.out.println(s);

}

• Debe ser leído como:
• Debe ser leído como:

– “Para cada elemento 's' de la colección 'c',

hacer ”
hacer...”

23

Salida formateada
Salida formateada

() q

• Java 5 introduce en System.out un método
printf() que funciona como en C/C++. Esta
p
funcionalidad también está en el método
format() de la clase String
format() de la clase String.
System.out.printf(“name count\n”);
String s = String.format(“%s %d%n”, user, total);
);

/

g

g

(

,

,

Código

%s

Descripción

Formatea el argumento como una cadena, usualmente
ll
llamando al toString() de dicho objeto.

() d di h

l t St i

bj

d

t

%d %o %x Formatea un entero como decimal, octal o hexadecimal.
%f %g

Formatea un número en coma flotante. El formato %g usa
notación científica
notación científica.
Inserta un salto de línea
Inserta el carácter %

%n
%%

24

Entrada formateada
Entrada formateada

• La

clase

java.util.Scanner

proporciona

entrada del usuario formateada.
– Obtiene datos en un tipo adecuado y se bloquea

esperando la entrada del usuario
esperando la entrada del usuario.

public class ScannerTest {

public static void main(String[] args) {
Scanner s = new Scanner(System.in);
String param1 = s.next();
p
System.out.println(“Param 1: ” + param1);
y
)
int param2 = s.nextInt();
System.out.println(“Param 2: ” + param2);
s.close();
s.close();

(

p

}

}

25