Getters y setters: sintaxis y buenas prácticas

1. ¿Qué son los getters y setters?

Si imaginamos un objeto como una caja fuerte, sus campos privados —es decir, el contenido de la caja—, y los getters y setters —las llaves de compartimentos individuales—. Los getters permiten saber qué hay dentro, y los setters permiten colocar con cuidado algo nuevo allí (pero solo si no pones, por ejemplo, un erizo en lugar de documentos).

Getter

Un getter es un método público (public) que devuelve el valor de un campo privado (private). Su nombre suele empezar por get + el nombre del campo con la primera letra en mayúscula.

public class Person {
    private String name; // Campo privado

    // Getter para el campo name
    public String getName() {
        return name;
    }
}

Setter

Un setter es un método público (public) que permite cambiar el valor de un campo privado. Su nombre empieza por set + el nombre del campo con la primera letra en mayúscula.

public class Person {
    private String name;

    // Setter para el campo name
    public void setName(String name) {
        this.name = name;
    }
}

Para campos boolean

Para los campos de tipo boolean es habitual usar el prefijo is en los getters:

private boolean active;

public boolean isActive() {
    return active;
}

public void setActive(boolean active) {
    this.active = active;
}

2. Sintaxis y convenciones de nomenclatura

Java es un lenguaje estricto, pero no un pelmazo. Hay convenciones consolidadas que hacen que tu código sea comprensible para otros desarrolladores (y para ti mismo dentro de un mes).

• Getter: public Type getNombreDelCampo()
• Setter: public void setNombreDelCampo(Type value)
• Getter para boolean: public boolean isNombreDelCampo()

El nombre del campo en el método se escribe con mayúscula inicial: si el campo es age, los métodos serán getAge() y setAge().

Esta convención sigue el estilo JavaBeans, gracias al cual las IDE, bibliotecas y frameworks pueden encontrar automáticamente tus getters y setters. Por ejemplo, si usas Spring o JavaFX, estos métodos se invocarán «mágicamente» cuando sea necesario.

3. Ejemplos de código

Tomemos un proyecto de aprendizaje: una aplicación sencilla de «contactos» (un análogo de la agenda telefónica) y añadamos getters y setters adecuados.

Ejemplo: clase Contact con campos privados y getters/setters

public class Contact {
    private String name;
    private String phone;
    private int age;
    private boolean favorite;

    // Getters
    public String getName() {
        return name;
    }

    public String getPhone() {
        return phone;
    }

    public int getAge() {
        return age;
    }

    public boolean isFavorite() {
        return favorite;
    }

    // Setters
    public void setName(String name) {
        this.name = name;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public void setAge(int age) {
        // Ejemplo de validación: la edad no debe ser negativa
        if (age < 0) {
            System.out.println("¡La edad no puede ser negativa!");
            return;
        }
        this.age = age;
    }

    public void setFavorite(boolean favorite) {
        this.favorite = favorite;
    }
}

Uso en la aplicación

Contact friend = new Contact();
friend.setName("Ivan Ivanov");
friend.setPhone("+1-999-123-45-67");
friend.setAge(25);
friend.setFavorite(true);

System.out.println("Nombre: " + friend.getName());
System.out.println("Teléfono: " + friend.getPhone());
System.out.println("Edad: " + friend.getAge());
System.out.println("Favorito: " + (friend.isFavorite() ? "Sí" : "No"));

Ejemplo de validación en el setter

Ten en cuenta que en el setter setAge añadimos una comprobación sencilla: si la edad es negativa, no cambiamos el campo y mostramos una advertencia. Es una forma simple de proteger el objeto de datos no válidos.

4. Buenas prácticas: cómo hacerlo bien

No todos los campos deben tener setters públicos

A veces un campo debe ser de solo lectura —por ejemplo, un identificador único que se establece al crear el objeto y no cambia—. En ese caso, simplemente no se escribe el setter:

public class Contact {
    private final int id; // final — no se puede cambiar después de la inicialización

    public Contact(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    // ¡No hay setId!
}

Usa getters/setters para control de acceso y validación

public void setName(String name) {
    if (name == null || name.trim().isEmpty()) {
        System.out.println("¡El nombre no puede estar vacío!");
        return;
    }
    this.name = name;
}

No expongas directamente objetos internos mutables

Si tienes un campo —por ejemplo, una lista de teléfonos:

private String[] phones;

No deberías devolverlo directamente mediante el getter:

public String[] getPhones() {
    return phones; // Malo!
}

Ese código permite que el código externo cambie la lista a su antojo —violando la encapsulación—.

Mejor: devolver una copia del array:

public String[] getPhones() {
    return Arrays.copyOf(phones, phones.length); // Devolvemos una copia
}

O simplemente clonarlo:

public String[] getPhones() {
    return phones.clone(); 
}

Haz que los getters y setters sean claros y simples

• No pongas lógica de negocio compleja en getters/setters: su misión es simple, control de acceso y, si es necesario, validación.
• Si un campo no debe cambiar, no escribas el setter.
• Si un campo no debe ser accesible desde fuera, no escribas el getter.

5. Generación automática de getters/setters en el IDE

Escribir accesores a mano no es precisamente un placer, especialmente si la clase tiene una decena de campos. Por suerte, las IDE modernas (por ejemplo, IntelliJ IDEA, Eclipse, VS Code con plugins) pueden generarlos automáticamente.

En IntelliJ IDEA

1. Abre la clase y coloca el cursor dentro del cuerpo de la clase.
2. Pulsa Alt + Insert (o Code -> Generate...).
3. Elige Getter and Setter.
4. Marca los campos necesarios y pulsa OK.

¡Voilà! Tus getters y setters aparecerán como por arte de magia.

En Eclipse

1. Abre la clase.
2. Botón derecho — Source — Generate Getters and Setters...
3. Selecciona los campos y pulsa OK.

En VS Code (con Java Extension Pack)

1. Abre el archivo de la clase.
2. En la paleta de comandos (Ctrl+Shift+P), escribe Generate getters and setters.
3. Sigue las indicaciones.

6. Evoluciona tu aplicación: encapsulación en acción

En lecciones anteriores construiste una aplicación sencilla para almacenar contactos. Ahora podemos mejorarla haciendo los campos privados y proporcionando acceso solo mediante getters/setters.

Antes (mal ejemplo):

public class Contact {
    public String name;
    public String phone;
    public int age;
}

Problema: cualquier código puede hacer lo siguiente:

Contact c = new Contact();
c.age = -1000; // ¡Ahora tenemos un vampiro en la agenda!

Después (buen ejemplo):

public class Contact {
    private String name;
    private String phone;
    private int age;

    public void setAge(int age) {
        if (age < 0) {
            System.out.println("¡La edad no puede ser negativa!");
            return;
        }
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    // El resto de getters/setters...
}

Ahora es imposible romper el objeto desde fuera por accidente (o a propósito).

7. Getters/setters para propiedades calculadas e inmutables

A veces el valor no se guarda en un campo, sino que se calcula al vuelo:

public class Rectangle {
    private int width;
    private int height;

    public int getArea() {
        return width * height;
    }
}

No se necesita un setter para el área — no se puede establecer directamente, solo cambiar el ancho o la altura.

8. Getters y setters: errores típicos

Error n.º 1: el getter/setter rompe la encapsulación.
Si un getter devuelve una referencia a un objeto interno mutable (por ejemplo, a una lista), el código externo puede modificarlo, saltándose todas las comprobaciones. Esto socava la idea de la encapsulación.

Error n.º 2: el setter no valida los datos.
Si un setter simplemente asigna el valor sin comprobarlo, puedes acabar con un estado incorrecto del objeto (por ejemplo, edad negativa o nombre vacío).

Error n.º 3: generación automática de setters para todos los campos.
Una IDE puede generar setters para todos los campos, ¡pero no siempre es lo correcto! Por ejemplo, para el identificador (id) no hace falta un setter.

Error n.º 4: lógica compleja en getters/setters.
Los getters y setters deben ser simples. Si aparece lógica de negocio compleja, conviene extraerla a métodos separados.

Error n.º 5: incumplir las convenciones de nombres.
Si llamas a un getter fetchName() en lugar de getName(), algunos frameworks y bibliotecas no podrán reconocerlo.