Clases

y Objetos en Java

Programació Orientada a Objectes

Elementos de una clase en Java

• Nombre
• Atributos
– Guardan los «datos» que caracterizan el estado de la clase
a lo largo de la ejecución del programa.
• Métodos
– Las «funciones» asociadas a esa clase. Pueden usar y
modificar el estado de los atributos, devolver nuevos
valores calculados, etc…
• Constructores
– Código asociado al proceso de creación del objeto.
– Suele usarse para inicializar valores por defecto, reservar
memoria extra, etc…
 Definición de una Clase
• Se utilizan las palabras clave “public class”
seguidas del nombre de la clase. Los
elementos que la define irán dentro de las dos
llaves que siguen al nombre de la clase { ... }

public class Alumno {

.... //contenido aquí
}
(también hay clases que no llevan el “public” delante,
pero no las estudiaremos en este curso)

Instanciación de una clase

• A diferencia de lenguajes como C, el siguiente código:

Alumno al;

no crea ningún objeto, sino a una referencia a null (es

decir a ninguna parte)

• Forma correcta de instanciar un objeto:

Alumno al = new Alumno();

 Definición de los atributos
• Concepto similar al de “variable” o de “campo” en los
structs de C.
• Se definen mediante el tipo (primitivo u otra clase)
seguido del nombre del atributo y, opcionalmente, un
valor por defecto.
public class Alumno {
String nombre;
int edad;
String email;
}
• Diferentes instancias de la misma clase (objetos) tienen
los mismos atributos (mismo nombre), pero sus valores
pueden ser diferentes para cada objeto.

Acceso a atributos
• Se hace a partir de una referencia a la clase, seguida de un
punto y el nombre del atributo:

Alumno al = new Alumno();

al.nombre = "Juan";
al.edad = 20;
System.out.println( al.nombre +
" tiene " + al.edad + " años.");

• Si se accede a un atributo desde dentro de la propia clase,

se puede omitir la referencia, o usar la referencia especial
"this"
 Definición de los métodos
• Concepto similar al de “función” en C
• Se definen mediante el tipo de retorno (primitivo u otra
clase) seguido del nombre del método y, opcionalmente,
una lista de parámetros.
public class Alumno {
String nombre;
int edad;
String email;
boolean esMayorQue(Alumno otro) {
if(this.edad >= otro.edad) {
return true;
} else {
return false;
}
}
}

Acceso a métodos
• Se hace a partir de una referencia a la clase, seguida de un punto y el
nombre del método, pasando entre paréntesis los parámetros que
requiera (o dejando paréntesis vacíos si no hay parámetros) :

Alumno este = new Alumno();

este.edad = 20;
Alumno aquel = new Alumno();
aquel.edad = 30;
if(este.esMayorQue(aquel)) {
System.out.println("Este es mayor que aquél");
}
if(aquel.esMayorQue(este)) {
System.out.println("Aquél es mayor que este");
}

• Si se accede a un método desde dentro de la propia clase, se puede omitir

la referencia, o usar la referencia especial "this"
 Ejemplo de clase
public class Pato {
//atributos
float peso;
char género; // ’m’ pato, ‘h’ pata
String color;
/* Métodos */
void engordar(float gramos) {
peso = peso + gramos;
}
void saludar() {
System.out.print("Cuak!! Soy ");
if(género == ‘m’) {
System.out.print("una pata ");
} else if(género == ‘h’) {
System.out.print(”un pato ");
}
System.out.println(color + " y peso " + peso + "gramos");
}
}

Acceso a atributos y métodos de un

objeto
Pato daisy;
daisy.color = "blanco";
// ERROR!! “daisy” apunta a null y
saltaría un error de NullPointerException
Pato lucas = new Pato(); //instanciación
lucas.peso = 400;
lucas.hembra = false;
lucas.color = "negro";
lucas.saludar();

Pato donald = new Alumno();

// ERROR!! 'donald' es una referencia a
Pato y no puede apuntar a un objeto del tipo
'Alumno'
 Ejercicio
class Inmueble { class Zona {
double m2; double precioMedioM2;
Zona zona; }
double calculaPrecio() {
//....
}
}

1. Escribir el código del método "calculaPrecio" que

retorna el precio orientativo del inmueble según su
tamaño en m2 y el precio medio del m2 de la zona al
que pertenece.

2. Escribir unas líneas de código donde se crea una

Zona cuyo precio medio es 2000€/m2 y se crea un
inmueble de 60m2 en esta zona. Después, en una
variable de nombre "r" se almacenará el precio
calculado del inmueble.

Constructores (I)
• Son un código que se ejecuta cada vez que se instancia un nuevo objeto,
sobre los atributos de este mismo objeto.
• Se definen mediante el nombre de la clase, seguida de paréntesis y,
opcionalmente, una lista de parámetros.
– Un constructor sin parámetros suele usarse para dar unos valores por defecto
a sus atributos.
public class Alumno {
String nombre, email;
int edad;
Alumno() {
nombre = “no especificado”;
edad = -1;
email = “no especificado”;
}

• Si creáramos un objeto Alumno con el constructor anterior,

Alumno al = new Alumno();
el alumno al tendría edad -1, y sus atributos nombre y email valdrían
“no especificado”.
 Constructores (II)
• Iniciar “a mano” cada uno de los atributos de un objeto puede
ser tedioso, sobretodo si tratamos muchos objetos con
muchos atributos.

Alumno a = new Alumno();

a.nombre = “Jose García”;
a.edad = 19;
a.email = “jose@hotmail.com”;

Alumno b = new Alumno();

b.nombre = “Pedro López”;
b.edad = 20;
b.email = “pedro@gmail.com”;

Alumno c = new Alumno();

c.nombre = “Juan Pérez”;
c.edad = 18;
//etc etc etc...

Constructores (III)
• Los Constructores con parámetros nos permiten
ahorrar espacio y evitan que tengamos que repetir
ciertas operaciones asociadas al proceso de creación
del objeto.

Alumno a = new Alumno(“Jose García”, 19,

“jose@hotmail.com”);

Alumno b = new Alumno(“Pedro López”, 20,

“pedro@gmail.com”);

Alumno c = new Alumno(“Juan Pérez”, 18,

“juan@upc.edu”);
 Definición de constructores
• Se define mediante el nombre de la clase, y una lista de
parámetros (o dos paréntesis vacíos, si no lleva parámetros).
• Una clase puede tener muchos constructores con parámetros
diferentes.
class Alumno {
String nombre, email;
int edad;

Alumno(String nombre, int edad) {

this.nombre = nombre;
this.edad = edad;
}
Alumno(String nombre, int edad, String email) {
this.nombre = nombre;
this.edad = edad;
this.email = email;
}
Alumno a;
a = new Alumno(“pepe”,15);
a = new Alumno(“pepe”,15,”p@px.es”);

Referencia “this”
• Todos los objetos tienen una referencia llamada “this”, que apunta
al propio objeto.
• Esta referencia solo se puede usar en el código que hay dentro del
mismo objeto (visibilidad privada).
• Entre otras cosas, se usa para distinguir los atributos de los
parámetros o las variables locales.
class Alumno {
String nombre;

Alumno(String nombre) {
// Asigna al atributo nombre (referenciado
// mediante this) el valor del parámetro
// nombre
this.nombre = nombre;
}
• El uso de this no es obligatorio cuando no hay conflicto de nombres.
 Ejemplo: clase Complex
public class Complex {
float r,i;
// Constructor por defecto.
// Uso: new Complex();
Complex() {
r = 0; i = 0;
}
// Constructor por parámetros.
// Uso: new Complex(1.0,2.5);
Complex(float r, float i) {
/* con «this» diferenciamos el atributo r de cualquier
atributo o variable local con el mismo nombre */
this.r = r;
this.i = i;
}

Ejemplo: clase Complex (continuación)

Complex add(Complex otro) {
Complex ret = new Complex();
ret.r = this.r + otro.r; /* en realidad, el
«this» no es necesario aquí */
ret.i = i + otro.i;
return ret;
}
Complex sub(Complex otro) {
/* podemos hacerlo «abreviando» mediante el
constructor por parámetros*/
return new Complex(r - otro.r, i - otro.i);
}
String toString() {
String s = r + " + " + i + "i";
return s;
}
}
 Ejemplo de uso de la clase Complex
public class TestComplex {
//punto de entrada al programa.
//Debe definirse exactamente así
public static void main(String args[]) {

Complex c1 = new Complex(1.0,2.0);

//Salida por pantalla estándar
System.out.println("c1: " + c1.toString());
Complex c2 = new Complex(2.0,3.0);
Complex c3 = c1.add(c2);
System.out.println("c1 + c2 = " + c3.toString());

//Lo que retorna una función se puede usar

//como una referencia en si y "empalmar" llamadas
Complex c4 = c3.sub(c2).add(c1);
System.out.println("c3 - c2 + c1 = " +c4.toString());
}
}

Errores comunes
Complex a,b,c;
c = a.add(b);
ERROR: las referencias a y b están definidas, pero no apuntan a ningún objeto.

a = new Complex(1,1);
b = new Complex(1,2);
c = a + b;
ERROR: Java solo "entiende" qué hacer con el operador suma para los tipos
básicos y las Strings (concatenación).

a = b;
ALERTA! a no copia el valor de b, sino que apunta al mismo complex.

if(a == b) { ... }
ALERTA! la condición no será cierta si a y b tienen los mismos valores.
Solamente será cierta cuando la referencia a y b apunten al mismo objeto.
 Ejercicios
1. Crear una clase llamada EcuacionLineal, que
permita especificar y resolver ecuaciones del
tipo Ax+B=0
– Qué atributos debe definir?
– Qué métodos?
– Algún constructor?
– Si queremos mostrarla por pantalla
(System.out.println()), qué debemos hacer?

Ejercicios
2. Diseñar un reloj despertador.
– En todo momento guarda la hora, minuto y
segundo actual, como la hora, minuto y segundo
en que debe “sonar” la alarma.
– La alarma puede activarse o desactivarse.
– Hay un método llamado “tickSegundo” que
“alguien” llamará (no debemos preocuparnos de
qué clase lo hace).
• Actualiza los segundos, minutos y hora.
• Comprueba si la hora coincide con la hora de la
alarma. Y, si la alarma está activada, saca por pantalla
el mensaje “Riiing!” (System.out.println)