Programación orientada a objetos Tema 2
Instanciar objetos
Funciona en el IDE online. Todo lo de esta sección funciona en el IDE online: pulsa Pruébalo en cualquier ejemplo, o abre el IDE y escribe el tuyo. Sin instalar nada.
Una clase es solo el molde: para usarla hay que crear objetos con ella. Este tema parte de la clase Alumno que se construye en el tema anterior, primero en su versión más sencilla y después completa.
Crear objetos: new#
Con la clase más sencilla, que solo tiene atributos:
public class Alumno {
// Atributos: los datos de cada alumno
String nombre;
int edad;
String nivel;
}Desde el programa principal, cada alumno se crea con new, y a sus atributos se llega con un punto:
Alumno a1 = new Alumno();
a1.nombre = "Antonio";
a1.edad = 17;
a1.nivel = "Master";
Alumno a2 = new Alumno();
a2.nombre = "María";
a2.edad = 16;
a2.nivel = "Master";
System.out.println(a1.nombre + " tiene " + a1.edad + " años"); // Antonio tiene 17 añosa1 y a2 son dos objetos distintos hechos con el mismo molde: cada uno tiene sus propios datos.
Con constructor#
Con la clase completa del tema anterior —constructor, métodos, atributos privados con sus get y set, y toString—:
public class Alumno {
private String nombre;
private int edad;
private String nivel;
public Alumno(String nombre, int edad, String nivel) {
this.nombre = nombre;
this.edad = edad;
this.nivel = nivel;
}
public void presentarse() {
System.out.println("Soy " + nombre + ", tengo " + edad + " años y estoy en " + nivel);
}
public boolean esMayorDeEdad() {
return edad >= 18;
}
public String getNombre() {
return nombre;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
if (edad > 0) {
this.edad = edad;
}
}
@Override
public String toString() {
return nombre + " (" + nivel + ")";
}
}Con el constructor, cada alumno se crea en una sola línea:
Alumno a1 = new Alumno("Antonio", 17, "Master");
Alumno a2 = new Alumno("María", 16, "Master");Usar sus métodos#
Los métodos se llaman con el punto, sobre un objeto concreto:
Alumno a1 = new Alumno("Antonio", 17, "Master");
a1.presentarse(); // Soy Antonio, tengo 17 años y estoy en Master
System.out.println(a1.esMayorDeEdad()); // falseLos atributos privados se leen y se cambian con sus métodos:
Alumno a1 = new Alumno("Antonio", 17, "Master");
a1.setEdad(-5); // no hace nada: la edad no puede ser negativa
a1.setEdad(18);
System.out.println(a1.getEdad()); // 18
// a1.edad = 20; ← error: edad es privadaY como la clase tiene toString, el objeto se puede imprimir tal cual:
Alumno a1 = new Alumno("Antonio", 17, "Master");
System.out.println(a1); // Antonio (Master)Arrays de objetos#
Un array puede guardar objetos igual que guarda números. Así se maneja una clase entera:
Alumno[] clase = {
new Alumno("Antonio", 17, "Master"),
new Alumno("María", 16, "Master"),
new Alumno("Juan", 14, "Senior")
};
for (int i = 0; i < clase.length; i++) {
clase[i].presentarse();
}Imprime:
Soy Antonio, tengo 17 años y estoy en Master
Soy María, tengo 16 años y estoy en Master
Soy Juan, tengo 14 años y estoy en SeniorVariables que apuntan a objetos: referencias#
Una variable de un tipo básico, como int, guarda el número. Una variable de una clase no guarda el objeto: guarda dónde está, una referencia. Se nota al copiarla:
Alumno a1 = new Alumno("Antonio", 17, "Master");
Alumno a2 = a1; // no crea otro alumno: a2 apunta al mismo que a1
a2.setEdad(18);
System.out.println(a1.getEdad()); // 18: los dos son el mismo objetoAlumno a2 = a1; copia la flecha, no el alumno. Por eso cambiar algo con a2 se ve también con a1. Para tener dos alumnos distintos hay que hacer dos new.
Lo mismo pasa al comparar: == mira si dos variables apuntan al mismo objeto, no si tienen los mismos datos:
Alumno a1 = new Alumno("Antonio", 17, "Master");
Alumno a2 = new Alumno("Antonio", 17, "Master");
Alumno a3 = a1;
System.out.println(a1 == a2); // false: son dos objetos, aunque iguales
System.out.println(a1 == a3); // true: es el mismoPara comparar por los datos, la clase tiene que tener un método equals que lo haga (como el de String, que por eso se compara con equals y no con ==).
null y el recolector de basura#
Una referencia puede no apuntar a nada: vale null. Es lo que tiene cada hueco de new Alumno[3] antes de crear sus alumnos, y usarla da NullPointerException.
¿Y qué pasa con un objeto al que ya no apunta ninguna variable? Que no hay forma de volver a usarlo, y Java lo borra solo para recuperar su memoria. Lo hace el recolector de basura (garbage collector), que funciona por su cuenta mientras el programa se ejecuta:
Alumno a1 = new Alumno("Antonio", 17, "Master");
a1 = new Alumno("María", 16, "Master"); // a Antonio ya no le apunta nadie: es basura
a1 = null; // y ahora, tampoco a MaríaEn Java los objetos no se destruyen a mano: basta con dejar de apuntarles.
Errores frecuentes#
| Mensaje o síntoma | Qué significa | Cómo se arregla |
|---|---|---|
constructor Alumno in class Alumno cannot be applied to given types | El new no da los datos que pide el constructor | new Alumno("Antonio", 17, "Master"), en el orden del constructor. Si has escrito un constructor con datos, new Alumno() ya no vale |
NullPointerException | Al ejecutar: usas un objeto que no existe. Pasa con Alumno[] clase = new Alumno[3];, que crea los huecos, pero vacíos | Crea cada objeto con new antes de usarlo: clase[0] = new Alumno("Ana", 15, "Master"); |
variable a1 might not have been initialized | Has escrito Alumno a1; sin new | Alumno a1 = new Alumno(…); |
Se imprime algo como Alumno@6d06d69c | La clase no tiene toString | Añade el método toString a la clase |
| Cambias un objeto y cambia también «el otro» | b = a no copia el objeto: las dos variables apuntan al mismo | Para tener otro, créalo con new |
a == b da false con dos objetos iguales | == compara si son el mismo objeto, no sus datos | Compáralos por sus datos, con un método equals en la clase |