Vericode
Entrar

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:

Java
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:

Java
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ños

a1 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—:

Java
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:

Java
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:

Java
Alumno a1 = new Alumno("Antonio", 17, "Master");
a1.presentarse();                         // Soy Antonio, tengo 17 años y estoy en Master
System.out.println(a1.esMayorDeEdad());   // false

Los atributos privados se leen y se cambian con sus métodos:

Java
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 privada

Y como la clase tiene toString, el objeto se puede imprimir tal cual:

Java
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:

Java
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:

Salida
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 Senior

Variables 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:

Java
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 objeto

Alumno 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:

Java
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 mismo

Para 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:

Java
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ía

En Java los objetos no se destruyen a mano: basta con dejar de apuntarles.

Errores frecuentes#

Mensaje o síntomaQué significaCómo se arregla
constructor Alumno in class Alumno cannot be applied to given typesEl new no da los datos que pide el constructornew Alumno("Antonio", 17, "Master"), en el orden del constructor. Si has escrito un constructor con datos, new Alumno() ya no vale
NullPointerExceptionAl ejecutar: usas un objeto que no existe. Pasa con Alumno[] clase = new Alumno[3];, que crea los huecos, pero vacíosCrea cada objeto con new antes de usarlo: clase[0] = new Alumno("Ana", 15, "Master");
variable a1 might not have been initializedHas escrito Alumno a1; sin newAlumno a1 = new Alumno(…);
Se imprime algo como Alumno@6d06d69cLa clase no tiene toStringAñ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 mismoPara tener otro, créalo con new
a == b da false con dos objetos iguales== compara si son el mismo objeto, no sus datosCompáralos por sus datos, con un método equals en la clase