Programación Orientada a Objetos (3er curso, grupo 32) 09.03.

10
3. Clases y objetos en Java

Definición de una clase:

estructura de datos + funciones
class CuentaBancaria {
long numero;
String titular; Variables
long saldo;

Clases y objetos en Java void ingresar (long cantidad) {

saldo += cantidad;
}
void retirar (long cantidad) {
Métodos
if (cantidad > saldo)
System.out.println ("Saldo insuficiente");
else saldo -= cantidad;
}
}
2

Variables
Creación de objetos
ƒ Definen una estructura de datos (como un struct de C)
class CuentaBancaria { struct CuentaBancaria { ƒ Una clase define un tipo de dato que se puede utilizar para declarar variables
long numero; long numero; CuentaBancaria cuenta1, cuenta2;
String titular; char *titular;
long saldo; long saldo; ƒ Declarar un objeto es declarar una referencia a un objeto
CuentaBancaria
} };
ƒ Los objetos se crean con el operador new numero -- sin definir
d f --
ƒ Pueden almacenar objetos titular -- sin definir --
cuenta1 = new CuentaBancaria ();
saldo -- sin definir --
class CuentaBancaria { class Cliente {
long numero; String nombre; ƒ Crear un objeto significa reservar espacio en memoria para sus variables
Cliente titular; long dni; ƒ new reserva memoria para un objeto y devuelve una referencia al objeto
long saldo = 0; }
} Las variables se pueden inicializar directamente
Los objetos siempre utilizan memoria dinámica
en la clase (con una expresión arbitraria que no
ƒ Por defecto se inicializan a 0 ó null
genere checked exceptions)
3 4

Creación de objetos Métodos

y acceso a variables ƒ Los métodos son funciones definidas dentro de una clase
(Similar a puntero a función en un struct de C)
CuentaBancaria cuenta1, cuenta2; ƒ Los métodos pueden referenciar directamente a las variables de la clase
cuenta1 = new CuentaBancaria ();
ƒ Los métodos se invocan sobre un objeto de la clase a la que pertenecen
cuenta2 = cuenta1;
cuenta1 cuenta2 cliente1 ƒ Al ejecutar un método invocado sobre un objeto de clase A, las variables
Cliente cliente1 = new Cliente ();
de la clase A toman el valor que tienen en el objeto
cliente1.nombre = "Luis Gomez"; CuentaBancaria
numero ← cuenta2.numero
cliente1.dni = 25672046; numero 6831531
titular ← cuenta2.titular
cuenta1.numero = 6831531; titular
saldo 200000 saldo ← cuenta2.saldo
cuenta1.titular = cliente1; cuenta2.ingresar(1000);
Cliente void ingresar (long cantidad) {
cuenta1.saldo = 100000;
nombre "Pilar Garcia"
cuenta2.saldo = 200000; saldo += cantidad;
dni 25672046
}
cuenta2.titular.nombre = "Pilar Garcia";
5 cuenta2.saldo 6

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 09.03.10
3. Clases y objetos en Java

Llamadas a métodos desde un método Los métodos se ejecutan

ƒ Los métodos pueden invocar directamente otros métodos de la misma clase en el contexto de un objeto
ƒ Al ejecutar un método invocado sobre un objeto de clase A, las llamadas a
otros métodos de la clase A se ejecutan sobre el mismo objeto a menos que ƒ Objetos a los que puede acceder un método:
se invoquen sobre otro objeto 1. Objeto de la invocación: implícitamente, accediendo directamente
cuenta3 = new CuentaBancaria (); a sus variables y métodos
cuenta2.transferencia (cuenta3, 1000); 2. Objeto definido en una variable local
3. Objeto pasado como argumento
class CuentaBancaria {
... 4. Objeto almacenado en una variable de la clase
void transferencia (CuentaBancaria destino, long cantidad) { ƒ En C, el objeto de la invocación sería un argumento más
if (cantidad <= saldo ) {
ƒ En POO, el objeto de la invocación juega un papel distinto:
retirar (cantidad);
el método invocado pertenece al objeto y no a la inversa
destino.ingresar (cantidad);
} ƒ En el código de un método, el objeto de la invocación no se ve
} cuenta2.retirar (cantidad)
} explícitamente: se accede a sus variables y métodos
7 8

Objetos accedidos desde un método Paso de argumentos: siempre por valor

class ClaseMain {
class X { String nombre; }
public static void main (String args[]) {
class Y { int i; } int n = 5;
class Z { String nombre; } 1. Variable del objeto de la invocación System.out.println ("Antes: " + n);
2. Objeto definido en variable local f (n);
class A {
3. Objeto pasado como argumento System.out.println ("Despues: " + n);
int num; }
4. Objeto almacenado en variable de clase
X obj4; static void f (int i) { System.out.println ("Durante: " + ++i); }
void f (int n, Y obj3) { }
Z obj2 = new Z ();
El objeto de la invocación (1)
4. obj4.nombre = obj2.nombre no se ve como los otros objetos
num = obj3.i + n; (2, 3, 4) pero está implícito: el
método f accede a sus variables
} 2.
}
1. 3.
9 10

Paso de argumentos: referencias (I) Paso de argumentos: referencias (II)

class ClaseMain { class ClaseMain {
public static void main (String args[]) { public static void main (String args[]) {
CuentaBancaria cuenta = new CuentaBancaria (); int a[] = {5, 4, 3, 2, 1};
cuenta.saldo = 100000; System.out.println ("Antes: " + a[3]);
System.out.println ("Saldo antes: " + cuenta.saldo); f (a);
arruinar (cuenta); System.out.println ("Despues: " + a[3]);
System.out.println ("Saldo despues: " + cuenta.saldo); }
} static void f (
(int x[])
[]) {
static void arruinar (CuentaBancaria cnt) { x[3] = 0;
cnt.saldo = 0; x = new int[8];
cnt = null; x[3] = 5;
} }
} }

11 12

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 09.03.10
3. Clases y objetos en Java

Constructores Constructores: ejemplo

class Cliente {
ƒ “Métodos” que se ejecutan automáticamente al crear los objetos de una
String nombre;
clase (i.e. al reservar memoria para los objetos, i.e. al invocar a new) long dni;
Cliente (String str, long num) {
ƒ Finalidad típica
nombre = str; dni = num;
– Valores iniciales para las variables de los objetos }
}
– Otras operaciones de inicialización
class CuentaBancaria {
ƒ Utilidad long numero;
– Simplificación de la sintaxis Cliente titular;
long saldo;
– Encapsulamiento de las variables de los objetos: evitar el acceso externo
CuentaBancaria (long num, Cliente clt, long s) {
numero = num; titular = clt; saldo = s;
}
}
13 14

Creación de objetos con constructores Constructores por defecto

ƒ Si no se definen constructores, Java proporciona uno por defecto
Los constructores se ejecutan automáticamente al crear los objetos class A {
A () { }
Cliente cliente1 = new Cliente ("Luis Gomez", 25672046); }
Cliente ƒ S
Si se de
define
euun co
constructor,
st ucto , e
el co
constructor
st ucto po
por de
defecto
ecto no
o es de
definido
do
nombre "Luis Gomez"
dni 25672046 class Cliente {
CuentaBancaria cuenta1 = ...
new CuentaBancaria (6831531, cliente1, 100000); Cliente (String str, long num) { ... }
}
CuentaBancaria cuenta2 =
new CuentaBancaria (8350284, // Bloque main
new Cliente ("Pilar Garcia", 15165442), Cliente cliente1 = new Cliente ();
200000); // Error: No constructor matching Cliente() found in Cliente
15 16

La variable this
La variable this: relaciones inversas
ƒ Definida implícitamente en el cuerpo de los métodos
ƒ Referencia al objeto sobre el que se invoca el método
class Nodo {
class Vector3D { Nodo anterior;
double x, y, z; Nodo siguiente;
... void conectar (Nodo z) {
double productoEscalar (Vector3D u) { siguiente = z;
return x * u.x + y * u.y + z * u.z; z.anterior = this;
// return this.x * u.x + this.y * u.y + this.z * u.z; }
} }
double modulo () {
return (double) Math.sqrt (productoEscalar (this)); Nodo Nodo
siguiente siguiente Nodo
} siguiente siguiente
}
// Bloque main anterior anterior anterior anterior
Vector3D v = new Vector3D (2, -2, 1);
v.modulo ();

17 18

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 09.03.10
3. Clases y objetos en Java

this en constructores
Sobrecarga de métodos
class Cliente {
String nombre; long dni;
Cliente (String str, long num) { nombre = str; dni = num; } class Plano3D {
CuentaBancaria cuentas[] = new CuentaBancaria [20]; double a, b, c, d;
int ncuentas = 0; Plano3D (double aa, double bb, double cc, double dd) {
CuentaBancaria
void nuevaCuenta (CuentaBancaria cuenta) { a = aa; b = bb; c = cc; d = dd;
cuentas[ncuentas++] = cuenta; }
} boolean paralelo (Plano3D p) {
} Cliente
CuentaBancaria Vector3D u = new Vector3D (a, b, c);
Vector3D v = new Vector3D (p.a, p.b, p.c);
class CuentaBancaria { return u.paralelo (v);
long numero; }
Cliente titular; CuentaBancaria
boolean paralelo (Recta3D r) {
long saldo;
Vector3D u = new Vector3D (a, b, c);
CuentaBancaria (long num, Cliente clt, long s) {
numero = num; titular = clt; saldo = s; return u.perpendicular (r.vector);
clt.nuevaCuenta (this); }
} }
}
19 20

Sobrecarga de constructores Llamada a métodos sobrecargados

class Punto3D {
double x, y, z;
Punto3D (double xx, double yy, double zz) { class Recta3D {
x = xx; y = yy; z = zz; Punto3D punto;
} Vector3D vector;
}
Recta3D (Punto3D p, Vector3D v) {
class Vector3D { punto = p; vector = v;
double x, y, z;
Vector3D (double xx
xx, double yy
yy, double zz) { }
x = xx; y = yy; z = zz; }
}
Vector3D (Punto3D p, Punto3D q) { // Bloque main
x = q.x - p.x; y = q.y - p.y; z = q.z - p.z; Plano3D p1 = new Plano3D (2, 4, 3, 1);
}
Plano3D p2 = new Plano3D (1, 0, -2, 1);
boolean paralelo (Vector3D u) {
return (x * u.y == y * u.x) && (x * u.z == z * u.x); Recta3D r = new Recta3D (new Punto3D (1, 0, 1),
} new Vector3D (1, 1, -1));
boolean perpendicular (Vector3D u) { p1.paralelo (p2);
return productoEscalar (u) == 0; p1.paralelo (r);
}
}
21 22

Sobrecarga de métodos: ambigüedad Destrucción de objetos (I)

class A { ƒ La memoria reservada para los objetos se libera por garbage collection (GC)
void f (int n) { ƒ GC libera la memoria de los objetos no referenciados en ninguna parte
System.out.println ("Tipo int");
CuentaBancaria cuenta1 =
}
void f (float x) { new CuentaBancaria (8350284,
System.out.println ("Tipo float"); new Cliente ("Luis Perez", 15165442),
} 200000);
);
} cuenta1.titular = new Cliente ("Pilar Gomez", 25672046);
// Bloque main
A a = new A(); Cliente

Se ejecuta la definición byte b = 3; CuentaBancaria nombre "Luis Perez"

long l = 3; numero 8350284 dni 15165442
compatible más específica cuenta1
double d = 3; titular cuentas
a.f(l); saldo 200000
a.f(b); Cliente
a.f(d); // ERROR: necesita cast nombre "Pilar Garcia"
// explícito dni 25672046
cuentas
GC
23 24

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 09.03.10
3. Clases y objetos en Java

Control de acceso
Destrucción de objetos (II) Miembros públicos vs. privados
ƒ Soltar expresamente una referencia:
class A { class B {
cuenta1 = null; GC public int x; void h () {
private int y; A a = new A ();
CuentaBancaria public void f () { ... } a.x = 2;
numero 8350284 private void g () { ... } a.y = 6; // Error
cuenta1
titular
void h () { a.f ();
Cliente x = 2; a.g (); // Error
saldo 200000
nombre "Pilar Garcia" y = 6; }
dni 25672046 f (); }
null
cuentas g ();
A a = new A ();
a.x = 2;
ƒ Un objeto se libera sólo cuando se sueltan todas las referencias a él a.y = 6;
a.f ();
CuentaBancaria cuenta2 = cuenta1;
a.g ();
cuenta1 = null; // El objeto no se libera aún }
}
ƒ Es posible solicitar garbage collection: System.gc ();
25 26

Control de acceso: otras modalidades Ocultación de variables y métodos

dentro de clases
Modalidades de ocultación de variables, métodos y constructores
de una clase class A { class B {
int w; // package void h () {
Clase Package Subclase Cualquiera private int x; A a = new A ();
protected int y;
p a.w = 2;
private X public int z; a.x = 6; // Error
private void f () { ... } a.y = 8;
(por defecto) package X X void h () { a.z = 3;
protected X X X w = 2; a.f (); // Error
x = 6; }
public X X X X y = 8; }
z = 3;
f ();
Modalidades de ocultación de clases: public ó package }
}

27 28

Ocultación de clases
dentro de packages Packages
A.java ƒ Conjunto de clases definidas en un directorio
package p1; package p2;
ƒ Evitar conflictos de símbolos
// Clase pública class C {
public
bli class
l A { void
id f () { ƒ Cada clase pertenece a un package
... p1.A a;
} p1.B b; // Error
} ƒ Si no se define ningún package para una clase, java la incluye
// Clase del package
class B { en el package DefaultPackage
...
}

29 30

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 09.03.10
3. Clases y objetos en Java

Utilizar clases de otro package

Definir packages
...
graphics.Circle c = new graphics.Circle ();
c.paint ();
graphics\Circle.java graphics\Rectangle.java ...

package graphics; package graphics;

public class Circle { public class Rectangle {

import graphics.Circle; import graphics.*;
public void paint () { public void paint () { ... ...
... ... Circle c = new Circle (); Circle c = new Circle ();
} } c.paint (); Rectangle r = new Rectangle ();
... ... ... c.paint (); r.paint ();
} } ...

Importar clase Importar todas las clases del package

31 32

Packages y directorios Packages predefinidos

ƒ Nombre del package → estructura de directorios
ƒ CLASSPATH: lista de directorios donde java busca packages java.applet java.rmi
java.awt java.rmi.dgc
directorio incluido en variable de entorno CLASSPATH
java.awt.datatransfer java.rmi.registry
java.awt.event java.rmi.server
java.awt.image java.security
package tool
tool.browser.graphics
browser graphics
java.beans java.security.acl
package tool.browser.interaction
java.io java.security.interfaces
package tool.editor
java.lang java.sql
package tool.editor; java.lang.reflect java.text
public class WorkArea { java.math java.util
ƒ Packages importados automáticamente:
... java.net java.util.zip
– java.lang
} … (actualmente cerca de 200)
– DefaultPackage
– Package actual
33 34

package p2;

Ocultación dentro de class C {

Variables estáticas (I)
void h () {
clases y packages p1.A a = new p1.A ();
a.w = 2; // Error
a.x = 6; // Error class CuentaCorriente {
a.y = 8; // Error static double interes;
package p1; a.z = 3;
} }
public class A { }
i t w; // package
int k class D extends p1
p1.A
A { ƒ Similares a variables globales
void h () {
private int x; ƒ Variables de clase (i.e. estáticas) vs. variables de instancia (por defecto)
p1.A a = new p1.A ();
protected int y;
w = 2; a.w = 2; // Error ƒ Las variables estáticas pertenecen a la clase, no a los objetos
public int z; x = 2; a.x = 6; // Error
} z = 3; a.z = 3;
ƒ Acceso a variables estáticas: desde la clase o desde los objetos
a.y = 8; // Error CuentaCorriente cuenta = new CuentaCorriente ();
y = 8;
D d = new D (); cuenta.interes = 0.3;
d.y = 8; CuentaCorriente.interes = 0.2;
}
}
35 36

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 09.03.10
3. Clases y objetos en Java

Variables estáticas (II) Métodos estáticos

class CuentaCorriente {
ƒ Las variables estáticas son compartidas por todos los objetos de la clase long numero;
(no se crea una copia por objeto como con las variables de instancia) static long ncuentas;
static long generarNumero () {
CuentaCorriente cuenta1 = new CuentaCorriente (); return ncuentas++;
CuentaCorriente cuenta2 = new CuentaCorriente (); }
}
cuenta1.interes = 0.3;
cuenta2.interes = 0.4; ƒ Similares a funciones globales
System.out.println (cuenta1.interes); 0.4 ƒ Pueden ser invocados desde la clase o desde los objetos

ƒ La memoria de las variables estáticas se reserva al cargar la clase en el CuentaCorriente cuenta = new CuentaCorriente ();
cuenta.numero = cuenta.generarNumero ();
intérprete Java
cuenta.numero = CuentaCorriente.generarNumero ();
37 38

Métodos estáticos: restricciones

ƒ Pueden acceder a variables y métodos estáticos de la misma clase
Variables y métodos estáticos típicos
ƒ No pueden acceder a this
ƒ No pueden acceder a variables ni métodos de instancia de la clase
static long generarNumero () {
numero = numcuentas++; // Error ƒ Variables estáticas: System.in, System.out, Math.PI,
return ncuentas;
} Integer MAX VALUE etc.
Integer.MAX_VALUE, etc
ƒ Los métodos de instancia sí pueden acceder a variables y métodos estáticos
void cobrarIntereses () { ƒ Métodos estáticos: System.exit(int), Math.sqrt(double),
saldo += saldo * interes / 100;
} Math.cos(double), Integer.valueOf(String), main, etc.
CuentaBancaria () { // Constructor
numero = generarNumero ();
}
ƒ Un constructor no puede ser estático
39 40

Bloques de inicialización estática Variables final

class A { class A {
static double num; static double num = 5.2; ƒ Similar a constantes, no se puede modificar su valor,
String x; String x = "Hola";
inicialización obligatoria
static { }
num = 5.2; class Circle {
x = "Hola";
Hola ; // Error final double PI = 3.141592653589793;
} void f () {
} PI = 3.0; // Error
}
ƒ Se ejecutan sólo una vez: al cargar la clase
}
ƒ Se permite un número arbitrario de bloques en una clase
ƒ Más eficiente: static final
ƒ No pueden referenciar variables de instancia ni métodos de instancia
ƒ Utiles para inicializar variables estáticas con tratamiento de errores ƒ Un constructor no puede ser final

ƒ Cuando es posible, mejor inicializar en la declaración o en constructores

41 42

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 09.03.10
3. Clases y objetos en Java

Cadenas de caracteres:
La clase java.lang.String
ƒ String encapsula cadenas de caracteres y su manipulación
ƒ String ≠ char[ ]
ƒ Los caracteres de un String no se pueden modificar

Librerías de clases ƒ Constructores

String (char[])
fundamentales String (String)
ƒ Creación de strings
char[] chars = {'a','b','c'};
String s = new String (chars);
String s1 = "Hello";
String s2 = new String (s1);
ƒ Literales: Java crea objetos de tipo String para los literales
44

Métodos de la clase String (I) Métodos de la clase String (II)

ƒ Acceso (la notación str[n] no existe para String)
ƒ Conversión a String: static String valueOf (<cualquier tipo>)
String str = "abcdabc";
String.valueOf (2.34567); // → "2.34567"
str.length (); // → 7
String.valueOf (34); // → "34"
str.charAt (4); // → 'a'
g (
str.substring (3,
, 5);
); // → "da" String.valueOf (new Plano3D ()); // → "Plano3D@1d07be"
str.indexOf ("bc"); // → 1 ƒ Comparación
str.lastIndexOf ("bc"); // → 5
String s1 = "abc", s2 = new String ("abc"), s3 = "abx";
ƒ Manipulación (se devuelve un String) s1 == s2; // → false
str.concat ("xyz"); // → "abcdabcxyz" s1.equals (s2); // → true
str.toUpperCase (); // → "ABCDABC" s1.compareTo (s3); // → -21 < 0
str.replace ('b', 'x'); // → "axcdaxc"
" Hola que tal ".trim (); // → "Hola que tal"

45 46

Cadenas de caracteres:
La clase java.lang.StringBuilder Métodos de StringBuilder (I)
ƒ Acceso (igual que para String): length(), charAt(int), ...
ƒ Desde Java 1.5, recomendado en lugar de StringBuffer (equivalente)
ƒ Conversión a String: toString()
ƒ Los caracteres de un StringBuilder sí se pueden modificar
ƒ Modificación de la cadena
ƒ Los objetos de tipo StringBuilder gestionan automáticamente su capacidad StringBuilder str = new StringBuilder ("abcdef");
– Toman
T una capacidad
id d inicial
i i i l str.setCharAt (2, 'q'); // str = "abqdef"
– La incrementan cuando es necesario str.append ("ghi"); // str = "abqdefghi"
ƒ Constructores str.insert (3, "xyz"); // str = "abqxyzdefghi"
StringBuilder() // Capacidad inicial: 16 caracteres str.insert (6, 1.23); // str = "abqxyz1.23defghi"
StringBuilder(int c) // Capacidad inicial: c caracteres str.delete (2, 10); // str = "abdefghi" (versión 1.2)
StringBuilder(String s)// Capacidad inicial: str.reverse (); // str = "ihgfedba"
// s.length() + 16 caracteres
47 48

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 09.03.10
3. Clases y objetos en Java

Entrada y salida estándar:

Métodos de StringBuilder (II) La clase java.lang.System
System.out, System.err
ƒ Manipulación de longitud y capacidad ƒ Objeto de la clase java.io.PrintStream

length(), capacity() ƒ Métodos: print(<cualquier tipo>), println(<cualquier tipo>), flush(),

setLength(int), ensureCapacity(int)
ƒ Operador de concatenación: internamente se utiliza un StringBuilder
"DNI de " + cliente.nombre + ": " + cliente.dni
new StringBuilder().append("DNI de ")
format(<String>,<cualquier tipo>,...), printf(...)
ƒ format y printf emiten java.util.IllegalFormatException
System.in
ƒ Objeto de la clase java.io.InputStream
ƒ Métodos: read(), read(byte[]), read(byte[],int,int)

.append(cliente.nombre).append(": ") ƒ Emiten java.io.IOException

.append(cliente.dni).toString() Redireccionamiento de la E/S estándar:

ƒ System.setOut(PrintStream), System.setErr(PrintStream)
ƒ System.setIn(InputStream)
49 50

Alternativa: E/S estándar

Entrada estándar
con java.io.Console
con java.io.BufferedReader
ƒ Se obtiene con System.console()
ƒ Métodos como readLine(), format(...), printf(...), readPassword ()
InputStream → InputStreamReader → BufferedReader → String
(System.in) public static void main (String args[]) throws IOException {
Console c = System.console ();
if (c == null) {
import java.io.*;
System.err.println ("No console.");
public static void main (String args[]) throws IOException { System.exit (1);
BufferedReader reader = }
new BufferedReader (new InputStreamReader (System.in)); String str = c.readLine ("Introduzca su nombre: ");
...
String str = reader.readLine ();
}
}
ƒ Excepciones java.io.IOException, java.util.IllegalFormatException

51 52

Escritura en fichero en modo texto Lectura de fichero en modo texto

con java.io.PrintStream con java.io.BufferedReader
ƒ Permite escribir en modo texto (como con System.out) ƒ Permite leer en modo texto (como con System.in)
PrintStream printer = BufferedReader reader =
new PrintStream (new FileOutputStream ("abc
("abc.txt"));
txt")); new BufferedReader (new FileReader ("abc
("abc.txt"));
txt"));
printer.print ("Dos + " + 2); String str = reader.readLine ();
printer.println (" = " + (2+2)); ...
... reader.close ();
printer.close (); ƒ Emite java.io.IOException
ƒ Emite java.io.IOException

53 54

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 09.03.10
3. Clases y objetos en Java

Entrada y salida en fichero binario:

Funciones matemáticas:
La clase java.io.RandomAccessFile
La clase java.lang.Math
ƒ Permite leer y escribir tipos primitivos (no objetos) en forma binaria
ƒ Abrir un fichero ƒ Constantes: Math.PI, Math.E
// Modalidades: "r", "rw" ƒ Métodos: sqrt(double), pow(double,double), random(),
RandomAccessFile f = new RandomAccessFile (
("abc.txt","r");
, );
abs(double),
b (d bl ) max(double,double),
(d bl d bl ) round(double),
d(d bl )
f.close ();
cos(double), sin(double), tan(double), acos(double),
ƒ Métodos:
exp(double), log(double), etc.
readInt() → int, readBoolean() → boolean, etc.
(Existen versiones float, long, int para abs, max, min, round)
writeInt(int), writeBoolean(boolean), etc.
getFilePointer(), seek(long), length(), setLength()
ƒ Emiten java.io.IOException

55 56

Clases para tipos numéricos (I)

(package java.lang) Clases para tipos numéricos (II)
ƒ Byte, Short, Integer, Long, Float, Double
ƒ Constantes (variables de clase)
ƒ Encapsulamiento (wrapping) de valores para manejo genérico de tipos
Integer n = new Integer (54); // n es un objeto Integer.MIN_VALUE → -2147483648

// 54 es un dato primitivo Integer.MAX_VALUE → 2147483647

ƒ Conversión automática tipo

p pprimitivo ↔ objeto
j por el compilador
p p Float.MIN_VALUE
_ → 1.4E-45
public
n = 27; // n es un objeto, 27 es un dato primitivo Float.MAX_VALUE → 3.4028235E38
static
int i = n; // i es un dato primitivo, n es un objeto // etc. final
ƒ Conversión a String y viceversa Float.NEGATIVE_INFINITY
n = Integer.valueOf ("91"); // String → Integer Float.POSITIVE_INFINITY
String s1 = m.toString (); // Integer → String Float.NaN
String s2 = String.valueOf (27.5); // int → String
// etc.
57 58

Clases para otros tipos primitivos

ƒ Clase java.lang.Character
La clase java.util.ArrayList
Character c = 'a'; // char → Character
char ch = c; // Character → char ƒ Lista de longitud variable de cualquier tipo de objetos
Character.isDigit ('2'); // → true
ƒ Similar a array, pero su capacidad aumenta o disminuye dinámicamente
Character.isLetter ('a'); // → true
Character.isLowerCase ('a'); // → true ƒ Longitud, capacidad, incremento

ch = Character.toUpperCase ('a'); // ch = 'A' ƒ Constructores

ƒ Clase java.lang.Boolean ArrayList lista = new ArrayList (); // Capacidad inicial: 10
Boolean b1 = true; // boolean → Boolean ArrayList lista = new ArrayList (100); // Capacidad inicial: 100
boolean b = b1; // Boolean → boolean
ƒ Ajustar la capacidad: ensureCapacity(int), )
Boolean b2 = Boolean.valueOf ("true");// String → Boolean
String s1 = b1.toString (); // Boolean → String
String s1 = String.valueOf (true); // boolean → String
59 60

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 09.03.10
3. Clases y objetos en Java

Métodos de ArrayList (I) Métodos de ArrayList (II)

ArrayList lista = new ArrayList (); // lista = { }
ƒ Acceso
ƒ Inserción
// Suponiendo que lista = { 'b', "Hola", 4.5 }
lista.add (2); // Warning (antes error)
lista.get (1); // → "Hola"
lista.add (new Integer (2)); // lista = { 2 }
lista.add (new Float (4.5)); // lista = { 2, 4.5 } li
lista.indexOf
i d (" l ") // → 1 (
f ("Hola"); (-1
1 si
i no encontrado)
d )

lista.add (1, "Hola"); // lista = { 2, "Hola", 4.5 } ƒ Longitud y capacidad: size(), isEmpty(), ensureCapacity(int), trimToSize()
lista.set (0, new Character ('b')); // lista = { 'b', "Hola", 4.5 }
ƒ Conversión a array: toArray()
ƒ Eliminar elementos:
ƒ ArrayList tipado: ArrayList<Double> lista = new ArrayList<Double> ();
lista.remove (new Float (4.5)); // lista = { 'b', "Hola" }
ƒ Iteración: iterator() → Iterator
lista.remove (0); // lista = { "Hola" }

61 62

Iteración sobre un ArrayList

hasNext() → boolean
ƒ Métodos de la interfaz Iterator
next() → Object (o tipo especificado)
Otras clases
ƒ Ejemplo (suponiendo que la clase Punto2D tiene un método print())
ƒ Package java.util: LinkedList, HashMap, Set, Collections, Date,
ArrayList<Punto2D> lista = new ArrayList<Punto2D> ();
lista.add (new Punto2D (0, 1)); StringTokenizer...
lista.add (new Punto2D (2, -3));
ƒ Package java.text: DateFormat, DecimalFormat
li t
lista.add
dd (
(new P
Punto2D
t 2D (
(-1,
1 1))
1));
System.out.println ("Los elementos de la lista son: "); ƒ Package java.math: BigDecimal, BigInteger (precisión y capacidad

Iterator<Punto2D> iter = lista.iterator (); arbitrarias)

Con iterador
while (iter.hasNext()) iter.next () .print ();
ƒ La clase java.lang.System: in, out, exit(int)
for (int i = 0; i < lista.size (); i++)
Sin iterador ƒ La clase java.lang.Runtime: getRuntime(), exec(String), exit(int)
lista.get (i) .print ();

for (Punto2D p : lista) p.print (); Enhanced for

63 64

Enumeraciones (I) Enumeraciones (II)

ƒ Enumeración simple
– Definición: public enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
FRIDAY, SATURDAY, SUNDAY }
...
– Utilización: Day d = Day.SATURDAY;
public static void main (String[] args) {
ƒ Una enumeración es una subclase de java.lang.Enum
double earthWeight = Double.valueOf (args[0]);
– El método Enum.values() devuelve un array con los valores de la enumeración
double mass = earthWeight/EARTH.gravity ();
ƒ Clases de enumeración for (Planet p : Planet.values ())
public enum Planet {
System out println ("Your
System.out.println ( Your weight on " + p +
MERCURY (3.303e+23, 2.4397e6), VENUS (4.869e+24, 6.0518e6),
" is " + p.weight (mass));
EARTH (5.976e+24, 6.37814e6), MARS (6.421e+23, 3.3972e6),
}
JUPITER (1.9e+27, 7.1492e7), SATURN (5.688e+26, 6.0268e7),
}
URANUS (8.686e+25, 2.5559e7), NEPTUNE (1.024e+26, 2.4746e7);
private final double mass, radius;
Planet (double m, double r) { mass = m; radius = r; }
public static final double G = 6.67300E-11; // gravit. constant
double gravity () { return G * mass / (radius * radius); }
double weight (double m) { return m * gravity(); }
...
65 66

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid
Programación Orientada a Objetos (3er curso, grupo 32) 09.03.10
3. Clases y objetos en Java

Ejemplo (I)
Tipos genéricos abstract class Figura {
abstract double area ();
}

ƒ Permiten definir clases parametrizadas por un tipo class Circulo extends Figura {
Punto2D centro;
ƒ El compilador se encarga de hacer los castings double radio;
Circulo (
(Punto2D p, double r)
) { centro = p; radio = r;
; }
ƒ Los errores se detectan en tiempo de compilación, no de ejecución double area () { return Math.PI * radio * radio; }
}
ƒ Tipos restringidos, wildcards, métodos genéricos
class Rectangulo extends Figura {
double left, top, width, height;
Rectangulo (double l, double t, double w, double h) {
left = l; top = t; width = w; height = h;
}
double area () { return width * height; }
}
67 68

Ejemplo (II) Tipo restringido

class Box<T> {
class Box<T extends Figura> {
T t;
T t;
void set (T elem) { t = elem; }
void set (T elem) { t = elem; }
T get () { return t; }
T get () { return t; }
}
double area () { return t.area (); }
}
// Bl i
Bloque main
...
// Bloque main
Box<Circulo> bCirc = new Box<Circulo> (); ¿Compilación
...
Box<Rectangulo> bRect = new Box<Rectangulo> (); o ejecución?
Box<Circulo> bCirc = new Box<Circulo> ();
bCirc.set (new Circulo (new Punto2D (2, 1), 3)); ¿Compilación
o ejecución?
Box<Rectangulo> bRect = new Box<Rectangulo> ();
Circulo c = bCirc.get (); // no cast!
Box<Punto2D> bPunto = new Box<Punto2D> (); // Error
bRect.set (new Rectangulo (2, 1, 5, 4));
...
bCirc.set (new Rectangulo (2, 1, 5, 4)); // Error
...
69 70

Jerarquías de tipos genéricos ¿Compilación

o ejecución?
ƒ Box<Circulo> no es subtipo de Box<Figura> ¿Por qué?
– Box<Figura> b = new Box<Circulo> (); // Error
– ArrayList<Object> a = new ArrayList<String> (); // Error
ƒ Box<Circulo> sí es subtipo de Box<? extends Figura>
– Box<? extends Figura> b = new Box<Circulo> ();
– b.set (new Rectangulo (2, 1, 5, 4)); // Error
– ArrayList<? extends Object> a1 = new ArrayList<String> ();
– ArrayList<?> a2 = new ArrayList<String> ();
ƒ Box<Figura> es subtipo de Box<? super Circulo>
– Box<? super Circulo> b1 = new Box<Figura> ();
– Box<? super Circulo> b2 = new Box<Rectangulo> (); // Error
ƒ Restricciones de los tipos wildcard
– b.set (new Circulo (...)); // Error
– a1.set (new Object ()); // Error
– a2.set (new Object ()); // Error
71

Escuela Politécnica Superior

Pablo Castells Universidad Autónoma de Madrid