Clases y objetos en Java

Una clase define un tipo: los datos que recuerdan sus objetos y las operaciones que ofrecen. Un objeto, también llamado instancia, es un valor de ese tipo creado mientras se ejecuta un programa. Escribir la definición de una clase no crea un objeto.

Estado y comportamiento

El nombre, la especie y la edad de una mascota forman su estado. Esos valores actuales se guardan en variables de instancia, también llamadas campos. Una operación como celebrar un cumpleaños es un comportamiento, escrito como método. El método de cumpleaños está junto a la edad que modifica, por lo que la regla se mantiene en un solo lugar.

Piensa en una clase como el plano de una construcción. Muchas casas pueden seguir un mismo plano, pero cada una tiene su propio contenido. Del mismo modo, dos mascotas pueden seguir la misma definición y tener edades distintas. Escribes los nombres de los campos una sola vez; cada objeto obtiene sus propios valores.

Lee una clase pequeña

public class Pet {
    private String name;
    private String species;
    private int age;

    public Pet(String name, String species, int age) {
        this.name = name;
        this.species = species;
        this.age = age;
    }

    public void celebrateBirthday() {
        this.age++;
    }
}

Lee esto de fuera hacia dentro. public class Pet introduce el tipo y las llaves exteriores contienen su definición. Las tres primeras declaraciones describen el estado. El bloque llamado Pet es un constructor: da a un objeto nuevo sus primeros valores. celebrateBirthday es un método: aumenta la edad del objeto actual. Las palabras private y public controlan el acceso; los ejemplos posteriores las utilizan para proteger el estado.

Los parámetros del constructor son valores que se proporcionan al crear un objeto. En this.age = age;, el lado izquierdo designa el campo del objeto y el derecho designa el parámetro proporcionado. El constructor almacena esa entrada para que el objeto pueda recordarla una vez terminada la construcción.

Pon una clase a trabajar

Ya has utilizado clases de bibliotecas. Scanner describe objetos que leen datos de entrada, ArrayList describe listas y un objeto String ofrece operaciones como length(). Una clase que escribes sigue la misma idea básica: pone un tipo útil a disposición del resto de tu programa.

Sin Pet, un programa podría pasar un nombre, una especie y una edad por separado a muchos métodos. Debe mantener correctamente unido cada grupo. Un objeto Pet lleva los valores relacionados como una sola unidad. Los métodos de ese objeto saben qué edad deben utilizar.

Organiza y nombra el código

En los archivos de código fuente habituales, una clase pública llamada Pet se guarda en Pet.java, con las mismas mayúsculas. Una clase Main separada puede contener el método main del programa, crear mascotas y llamar a sus métodos. Pet no necesita un main propio. Las clases del mismo paquete sin nombre pueden utilizarse entre sí sin importaciones; los ejemplos sencillos mantienen esas clases en una carpeta.

Utiliza sustantivos en UpperCamelCase para las clases, como LibraryBook. Utiliza lowerCamelCase para campos y métodos: pageCount nombra datos; giveBack() nombra una acción. Son convenciones que ayudan a quien lee a reconocer cada parte, aunque el compilador permita muchos otros nombres.

Crear un objeto y declarar una variable son operaciones distintas. Una variable te da un nombre mediante el que acceder a un objeto; new crea el objeto al que hará referencia ese nombre.

Lee una sentencia de creación de objetos

Pet luna = new Pet("Luna", "cat", 3);

Pet es el tipo de la variable y luna es su nombre. new Pet(...) crea un objeto nuevo y llama a un constructor compatible con tres argumentos. El constructor almacena el nombre, la especie y la edad. La referencia resultante se asigna a luna.

Una referencia indica a Java qué objeto debe utilizar. Es útil dibujar una variable como un nombre con una flecha hacia un objeto. La variable no es una segunda copia de todos los campos del objeto.

Llama a un método de un objeto concreto

El punto en luna.celebrateBirthday() conecta una referencia con un método que se ejecuta sobre su objeto. Un método que devuelve un valor puede proporcionarlo a otra expresión:

luna.celebrateBirthday();
int years = luna.getAge();
System.out.println(years); // 4

Aquí getAge() es un método público que devuelve la edad de la mascota. La llamada de cumpleaños cambia el estado; el método de acceso lee ese estado. Pet.celebrateBirthday() falla porque este método de instancia necesita una mascota concreta. El nombre de la clase por sí solo no responde de quién es el cumpleaños.

Objetos separados y referencias compartidas

Pet max = new Pet("Max", "dog", 5);
luna.celebrateBirthday();
System.out.println(luna.getAge()); // 5
System.out.println(max.getAge());  // 5

Luna ya tenía 4 años, así que el siguiente cumpleaños la lleva a 5. Max sigue teniendo 5. Tener la misma edad no hace que sean el mismo objeto: las dos expresiones new crearon mascotas distintas.

Considera ahora una asignación sin new:

Pet other = luna;
other.celebrateBirthday();
System.out.println(luna.getAge()); // 6

La asignación copia la referencia de Luna. Ambos nombres acceden a una sola mascota, por lo que cambiarla mediante other es visible mediante luna. Para crear una segunda mascota, llama de nuevo a new.

Haz coincidir los parámetros del constructor

Los argumentos deben ajustarse al número, orden y tipos de los parámetros de un constructor declarado. Si el único constructor disponible recibe (String, String, int), new Pet() no compila. Java no adivina los valores que faltan. Sin embargo, intercambiar las dos cadenas sí compila: new Pet("cat", "Luna", 3) proporciona los tipos correctos, pero los significados equivocados. Lee los nombres de los parámetros para comprobar ese orden.

Estos dos intentos incompletos fallan por distintas razones:

Pet a;                         // declaration only
// System.out.println(a.getAge()); // a has no assigned value
// Pet b = Pet("Bo", "cat", 2);    // missing new

Una variable local debe tener un valor asignado antes de utilizarse. Sin new, Java busca un método llamado Pet, no una expresión de creación de objetos. Una vez que existe un objeto, al imprimirlo puede mostrarse un texto como Pet@8bcc55f hasta que proporciones un método toString() legible; esa salida no significa que la construcción haya fallado.

Un objeto necesita un campo para cada valor que debe recordar entre llamadas a métodos. Elige esos valores antes de escribir los métodos: forman el estado duradero del objeto.

Declara campos con tipos adecuados

Un campo se encuentra dentro de las llaves de la clase, pero fuera de todos los constructores y métodos. Una declaración necesita un tipo y un nombre; también pueden aparecer un modificador de acceso y un inicializador.

private String title;
private int pageCount;
private boolean lentOut = false;

String es adecuado para texto, int para un recuento de números enteros y boolean para una condición de sí o no. Los campos también pueden utilizar tipos de clase como ArrayList<String>. Estos ejemplos utilizan private; omitir el modificador da acceso de paquete, no acceso privado.

Cada objeto obtiene una copia separada de cada campo de instancia. Dos objetos Rectangle tienen cada uno un width y un height, aunque las declaraciones aparezcan una sola vez en la clase.

Los valores predeterminados no siempre son valores iniciales utilizables

Se asigna un valor predeterminado a un campo cuando se crea el espacio de almacenamiento del objeto. Puede que no se ajuste a la finalidad del objeto. Un campo de tipo lista con el valor null no es una lista vacía: todavía necesitas crear la lista antes de añadir un elemento.

Las variables locales no reciben ese valor predeterminado. Dentro de un método, int total; seguido de System.out.println(total); no compila porque no se ha asignado un valor a total. Distingue la regla de los campos de la de las variables locales.

Decide qué debe perdurar

Un campo permanece con su objeto. Un parámetro está disponible durante su llamada y una variable local está disponible en su bloque mientras se ejecuta esa llamada. Si un contador debe conservar su cuenta de una llamada a la siguiente, la cuenta pertenece a un campo. Un subtotal temporal utilizado para un cálculo puede ser local.

Almacena las entradas; calcula los valores derivados

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

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double area() {
        return this.width * this.height;
    }
}

Las dimensiones están en centímetros, por lo que area() devuelve un área en centímetros cuadrados. Almacenar un campo separado para el área crearía otro valor que habría que actualizar cada vez que cambiara una dimensión. Calcularlo a partir de las dimensiones mantiene la coherencia del resultado.

Utiliza un campo de instancia final para un valor que se asigna una sola vez, como private final String title;. Asígnale un valor en su declaración o en cada constructor. final impide la reasignación. static tiene otro significado: crea un campo de clase compartido. Añadir static al nombre de una mascota haría que distintas mascotas compartieran una sola variable de nombre.

Un constructor inicializa un objeto cuando new lo crea. Su nombre debe coincidir con el de la clase y no tiene tipo de retorno. Incluso void convertiría la declaración en un método.

Transfiere las entradas al estado

public Pet(String name, String species, int age) {
    this.name = name;
    this.species = species;
    this.age = age;
}

Un constructor suele aceptar entradas como parámetros y almacenarlas en campos. Aquí cada parámetro tiene el mismo nombre que su campo. El nombre age por sí solo designa el parámetro; this.age designa el campo del objeto que se está creando. La asignación lee el valor proporcionado a la derecha y escribe el campo de la izquierda.

Para new Pet("Luna", "cat", 3), primero los campos del objeto nuevo reciben valores predeterminados: null, null y 0. Después el constructor recibe los tres argumentos y sustituye esos valores. Cuando termina la construcción, new produce la referencia que almacena quien lo llamó.

Dos errores que compilan

public Pet(String name, String species, int age) {
    name = name;
    this.species = species;
    this.age = age;
}

Ambas apariciones de name hacen referencia al parámetro, por lo que la primera línea asigna ese parámetro a sí mismo. El nombre del objeto permanece en null. El código es válido, por eso es importante comprobar los valores del objeto nuevo.

Una declaración dentro del constructor causa un problema relacionado:

String nick = initialNick;

Si ya existe un campo llamado nick, esta línea crea una variable local con el mismo nombre. La variable local desaparece cuando termina la construcción. Escribe this.nick = initialNick; para almacenar la entrada en el campo; no repitas el tipo.

Identifica cuándo existe un constructor sin argumentos

Si una clase no declara constructores, Java proporciona un constructor predeterminado sin parámetros. En una clase sencilla, sus campos conservan sus inicializadores declarados o valores predeterminados. En cuanto declaras cualquier constructor, Java deja de proporcionar ese constructor predeterminado.

Por tanto, una clase que solo tiene Pet(String name, String species, int age) no puede crearse con new Pet(). Añade un constructor explícito sin argumentos solo cuando exista un estado inicial útil para él. Presta atención también a public void Pet(...): es un método, por lo que no proporciona el constructor previsto.

Establece también los valores iniciales internos

No todos los campos tienen que proceder de un argumento. Un libro nuevo siempre puede empezar con this.lentOut = false;. Una clase que posee una lista puede inicializarla así, con ArrayList importado:

private ArrayList<String> tracks;

public Playlist() {
    this.tracks = new ArrayList<>();
}

La lista vacía está lista para add. Dejar tracks en null hace que una llamada posterior a tracks.add(...) falle con NullPointerException.

Un inicializador de campo se ejecuta antes del cuerpo del constructor. Si private int score = 10; va seguido de this.score = 5; en el constructor, la puntuación del objeto terminado es 5. Prueba los valores después de la construcción, no solo los valores escritos junto a las declaraciones de los campos. Los constructores también necesitan las mismas reglas de validación que los cambios posteriores, para que el primer estado sea válido.

Una clase puede ofrecer varias formas útiles de crear un objeto. La sobrecarga de constructores consiste en declarar constructores con distintas listas de parámetros.

Distingue los constructores por sus parámetros

Java distingue los constructores por el número, los tipos y el orden de sus parámetros. Los nombres de los parámetros no los distinguen. Box(String label) y Box(String name) describen la misma lista de parámetros, por lo que no pueden declararse ambos en una misma clase.

Una mascota puede crearse con una edad o como recién nacida:

public Pet(String name, String species, int age) {
    this.name = name;
    this.species = species;
    this.age = age;
}

public Pet(String name, String species) {
    this(name, species, 0);
}

new Pet("Pip", "rabbit") selecciona el constructor de dos parámetros. Ese constructor proporciona 0 como edad que falta y llama al constructor de tres parámetros. El objeto nuevo termina con el estado "Pip", "rabbit" y 0.

Encadena la inicialización del mismo objeto

Dentro de un constructor, this(...) llama a otro constructor de la misma clase. El constructor más breve elige los valores predeterminados; el más completo realiza la inicialización compartida. Las comprobaciones situadas en esa inicialización se aplican a ambas vías de construcción.

Compara dos líneas que se parecen:

La segunda línea no rellena los campos del objeto actual. Si su resultado nunca se almacena, esa mascota adicional se descarta. La mascota actual puede seguir teniendo campos con null.

Sigue una cadena antes de recorrer el código posterior

Un reloj puede ofrecer la medianoche como valor predeterminado:

public Clock() {
    this(0, 0);
}

public Clock(int hours, int minutes) {
    this.hours = hours;
    this.minutes = minutes;
}

Para new Clock(), entra en el constructor sin argumentos, sigue this(0, 0) y asigna ambos campos en el constructor de dos argumentos. Después el control regresa al constructor sin argumentos. Esto crea un reloj, no dos. Una llamada a new Clock(9, 5) comienza directamente en el constructor más completo.

Mantén la cadena válida y clara

Un constructor puede contener como máximo una llamada a this(...). La cadena debe llegar finalmente a una inicialización que no vuelva a llamar a la cadena: dos constructores que delegan el uno en el otro producen un error de compilación por constructor recursivo.

Poner this(...) primero es un estilo claro que funciona en todas las versiones de Java. En Java 24 y versiones anteriores sin características preliminares, debe ir primero. Java 25 permite sentencias anteriores para tareas como calcular o comprobar argumentos. Esas sentencias no pueden leer los campos de instancia del objeto actual ni llamar a sus métodos de instancia; se permiten asignaciones a campos declarados en la clase sin inicializadores en su declaración.

Ofrece sobrecargas porque quienes llaman disponen de distintas entradas útiles. Un reloj que empieza a medianoche tiene sentido; un libro sin título puede que no. La existencia de un constructor completo no crea automáticamente sobrecargas más breves.

Un método de instancia se ejecuta para un objeto concreto. Decláralo sin static y utiliza los campos de ese objeto mediante nombres como this.width. Decide qué necesita quien lo llama: un cambio de estado, un resultado devuelto o ambas cosas.

Devuelve cálculos; haz explícitos los cambios de estado

Para un rectángulo cuyas dimensiones se almacenan en centímetros:

public double area() {
    return this.width * this.height;
}

public double perimeter() {
    return 2 * (this.width + this.height);
}

public void scale(double factor) {
    this.width = this.width * factor;
    this.height = this.height * factor;
}

Un rectángulo con lados de 3,0 y 4,0 tiene un área de 12,0 centímetros cuadrados y un perímetro de 14,0 centímetros. scale(2) cambia los lados a 6,0 y 8,0. Las siguientes llamadas devuelven un área de 48,0 y un perímetro de 28,0. Cada método lee los campos actuales, por lo que no es necesario actualizar un área almacenada.

area() devuelve un número que puede almacenarse o utilizarse en un cálculo. Si solo imprimiera el número y tuviera el tipo de retorno void, quien lo llama no podría escribir double twice = r.area() * 2;. Deja la impresión a quien llama al método cuando la función de este sea calcular un valor.

Actualiza los campos relacionados en orden

El método advance() de un reloj debe gestionar tanto el cambio de minuto como el de hora:

public void advance() {
    this.minutes++;
    if (this.minutes == 60) {
        this.minutes = 0;
        this.hours++;
        if (this.hours == 24) {
            this.hours = 0;
        }
    }
}

A las 23:58, la primera llamada llega a 23:59 y omite ambos bloques de reinicio. La siguiente llamada llega brevemente al minuto 60, lo reinicia a 0, aumenta la hora a 24 y la reinicia a 0. El estado final es 00:00. Una llamada más da 00:01.

Sigue los objetos por separado

Escribe una fila después de cada sentencia y una columna para los campos de cada objeto. Cambia solo el objeto indicado por el receptor de la llamada. Para mascotas de 2 y 7 años, dos cumpleaños de la primera y setAge(1) en la segunda dejan las edades en 4 y 1. No ejecutes el cuerpo de un método para cada instancia solo porque comparten una clase.

Una declaración local puede ocultar el campo que querías actualizar. public void reset() { int count = 0; } solo crea una variable temporal. this.count = 0; reinicia el contador duradero.

Reutiliza métodos y completa las rutas de retorno

Dentro de un método de instancia, area() y this.area() llaman al método de área del mismo objeto. Un método de descripción puede reutilizar ese cálculo en lugar de copiar su expresión. Un método también puede cambiar el estado y devolver si tuvo éxito, como hace lend() cuando marca un libro como prestado e indica true.

Un método que no es void no puede simplemente llegar al final sin devolver un valor compatible. Si get() solo devuelve un valor dentro de if (count > 0), ¿qué ocurre cuando el contador es 0? Añade la ruta de retorno necesaria o lanza una excepción para un valor que el método rechace. Una ruta que lanza una excepción no regresa a quien llamó al método y no necesita un valor de retorno.

Pregúntate a quién pertenece un valor o una operación antes de decidir si utilizas static. La edad de una mascota pertenece a una mascota. Un recuento de todas las mascotas creadas pertenece a la clase en su conjunto.

El objeto actual es this

Dentro de un constructor o método de instancia, this hace referencia al objeto que se está construyendo o que recibe la llamada. En this.age++, identifica qué edad cambia. En this.name = name, distingue el campo de un parámetro con el mismo nombre. this(...) es la forma de encadenar constructores.

Un método estático no tiene un objeto actual, por lo que this no puede utilizarse allí. Aun así puede crear un objeto o recibir una referencia y utilizarla para llamar a métodos de instancia.

Campos compartidos y campos de cada objeto

public class Counter {
    private int count;
    private static int created = 0;

    public Counter() {
        this.count = 0;
        created++;
    }

    public void increment() {
        this.count++;
    }

    public int getCount() {
        return this.count;
    }

    public static int getCreated() {
        return created;
    }
}

Después de dos llamadas a new Counter(), hay dos campos count separados, ambos inicialmente en 0, y un campo created igual a 2. Incrementar el primer contador cambia su cuenta a 1; el segundo permanece en 0. Counter.getCreated() sigue devolviendo 2 porque no se ha construido ningún objeto nuevo.

Trabaja a través de un objeto desde main

public static void main(String[] args) {
    Counter c = new Counter();
    c.increment();
    System.out.println(c.getCount());
}

El método main clásico es estático. Una llamada a increment() por sí sola allí no tendría un objeto de destino y no compilaría. La variable c proporciona ese destino. Hacer que count sea estático para eliminar el error cambiaría el diseño: todos los contadores compartirían entonces una sola cuenta.

Java 25 también admite formas de instancia de main, pero la cabecera estática clásica sigue siendo válida. Estos ejemplos la utilizan de forma coherente.

Elige métodos y constantes de forma deliberada

Una operación que necesita los campos de un objeto debería ser un método de instancia. Una operación que solo depende de sus parámetros puede ser estática, como un método auxiliar que convierte un número total de minutos en horas. Las llamadas estáticas suelen utilizar el nombre de la clase: Math.sqrt(16) o Counter.getCreated().

Un valor fijo compartido suele declararse como constante:

public static final int MAX_CELSIUS = 30;

public lo pone a disposición de quienes llaman, static da a la clase un campo compartido y final impide la reasignación. UPPER_SNAKE_CASE indica una constante por convención. Esta es una excepción habitual a la regla de hacer privados los campos. No utilices static para nombres, dimensiones u otros datos de estado que deban ser distintos entre objetos.

La encapsulación mantiene el estado de un objeto junto al código que lo controla. Los campos suelen ser privados, mientras que quienes utilizan el objeto recurren a operaciones públicas. Esto oculta los detalles de almacenamiento y da a la clase un lugar donde aplicar sus reglas.

Elige un nivel de acceso

Un paquete agrupa clases. Los ejemplos sencillos sitúan clases habituales juntas sin una declaración package, en un mismo paquete sin nombre. El acceso de paquete se obtiene al omitir el modificador; no hay ninguna palabra clave de acceso package que añadir a un campo.

Empieza con el acceso útil más restringido. Haz que los campos sean privados, que los constructores y operaciones que necesitan otras clases sean públicos y que los métodos auxiliares internos sean privados. Las constantes públicas son una excepción habitual para los campos.

Deja que la clase controle los cambios

Si Pet declara private int age;, una clase Main independiente no puede asignar luna.age = -5;. El compilador rechaza el acceso. Una llamada como luna.setAge(-5) puede permitirse, porque el método público pertenece a Pet y puede decidir si almacena el argumento.

Un campo público permitiría a cualquiera que lo utilice eludir ese método. Cuando todos los cambios pasan por el código de la clase, las comprobaciones pueden estar en un solo lugar. El acceso privado por sí solo no valida una edad; los métodos también deben realizar las comprobaciones.

Mantén estable la interfaz pública

Supón que un reloj almacena inicialmente los campos hours y minutes por separado. Quienes lo utilizan llaman a getHours() y getMinutes(). Más tarde sustituyes los campos por un único valor minutesSinceMidnight:

public int getHours() {
    return this.minutesSinceMidnight / 60;
}

public int getMinutes() {
    return this.minutesSinceMidnight % 60;
}

Con 615 minutos almacenados, la división devuelve 10 y el resto devuelve 15. El reloj indica 10:15 mediante los mismos métodos. No es necesario reescribir el código que los llama porque dependía de las operaciones públicas, no de cómo se almacenaba el estado. Esta libertad para cambiar los detalles internos es la ocultación de información.

El acceso pertenece a las clases, no a los objetos individuales

El código dentro de Pet puede leer un campo privado de otro objeto Pet. El permiso de acceso procede de estar dentro de la clase. Una clase de nivel superior distinta no obtiene permiso por tener una referencia a una mascota o por estar en la misma carpeta.

Para las declaraciones habituales de clases de nivel superior, las opciones de acceso son public o ningún modificador. Un private class Pet de nivel superior no está permitido. Una clase pública de nivel superior va en el archivo de código fuente correspondiente, y un archivo de código fuente habitual contiene como máximo una clase pública de nivel superior.

Los campos privados son un límite de diseño del programa. Impiden que otro código ordinario dependa directamente de los campos internos, pero no son una forma de mantener un valor en secreto frente a una persona que pueda inspeccionar el programa. Utilízalos para controlar la interfaz de tu clase y proteger su estado.

Una clase puede permitir que quienes la utilizan lean o cambien determinadas partes de su estado mediante métodos. Decide qué operaciones debería ofrecer la clase antes de crear métodos de acceso y modificadores para cada campo.

Devuelve valores con métodos de acceso

Un método de acceso, también llamado método de consulta, devuelve información sin modificar el objeto. Un método de acceso habitual lee un campo:

public String getName() {
    return this.name;
}

public int getAge() {
    return this.age;
}

El tipo devuelto coincide con la información proporcionada. Un método de acceso que imprime y devuelve void no puede proporcionar un valor a una expresión como pet.getAge() + 1. Quien lo llama debería recibir el valor y decidir cómo utilizarlo.

Cambia determinados valores con métodos modificadores

Un método modificador, también llamado método de mutación, recibe un valor nuevo y actualiza el estado:

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

this.name es el campo. name es el parámetro. Escribir name = name; compila, pero no cambia ningún campo. Aquí no hay valor de retorno porque la función de este método modificador es realizar un cambio.

Para una mascota de 3 años:

luna.setName("Lulu");
System.out.println(luna.getName() + " is " + luna.getAge());
// Lulu is 3

Quien llama a los métodos nunca toca un campo directamente. El método modificador cambia el nombre y los métodos de acceso devuelven los valores actuales para que quien los llama los combine.

Sigue los nombres que espera otro código Java

Escribe en mayúscula la primera letra del nombre del campo después de get, set o el prefijo booleano habitual is. Un nombre como getname() puede compilar, pero no sigue la convención que esperan las herramientas y otros programadores.

Expón solo operaciones útiles

El título de un libro puede tener un método de acceso y ningún método modificador porque quienes lo utilizan deberían poder leerlo, pero no sustituirlo. Un campo privado final puede garantizar que se asigne una sola vez. Un contador interno puede no necesitar ninguno de los dos métodos si solo lo utiliza la clase.

Un método modificador sin comprobaciones puede aceptar el mismo valor perjudicial que un campo público. Añade comprobaciones cuando un cambio tenga restricciones. Considera también un método de acción: celebrateBirthday() expresa el aumento de la edad en uno y lend() expresa un intento de préstamo. lend() puede inspeccionar el estado actual y rechazar un segundo préstamo. Un método modificador también puede realizar esa comprobación; el nombre de la acción hace que la operación resulte más clara para quien la llama.

Un método de acceso puede calcular una respuesta. getArea() puede devolver el producto de la anchura y la altura sin ningún campo area.

Una invariante es una regla sobre el estado de un objeto que se cumple después de la construcción y después de cada operación pública. Un termostato podría permitir temperaturas objetivo de 5 °C a 30 °C. Todas las formas de establecer su temperatura objetivo deben conservar ese rango.

Decide qué significa una entrada no válida

Tres respuestas útiles son conservar el valor anterior, limitar el valor a un extremo permitido o lanzar una excepción. Tienen efectos distintos, así que elige una respuesta clara para cada operación.

Para una edad no negativa de una mascota, un método modificador que ignora valores no válidos puede asignar solo dentro de if (age >= 0). Si la edad almacenada es 4, setAge(-2) la mantiene en 4. No convierte la edad en 0.

Pon las comprobaciones del rango dentro de la clase

public static final int MIN_CELSIUS = 5;
public static final int MAX_CELSIUS = 30;
private int target;

public void setTarget(int celsius) {
    if (celsius < MIN_CELSIUS) {
        this.target = MIN_CELSIUS;
    } else if (celsius > MAX_CELSIUS) {
        this.target = MAX_CELSIUS;
    } else {
        this.target = celsius;
    }
}

public void raise() {
    setTarget(this.target + 1);
}

Partiendo de 20 °C, setTarget(35) almacena 30. setTarget(-3) almacena 5. Después de setTarget(29), una llamada a raise() almacena 30; otra llamada sigue almacenando 30. Reutilizar el método modificador impide que raise() sobrepase el límite superior.

Las comprobaciones solo en Main no pueden proteger el termostato. Otro código que lo llame podría olvidarlas. La clase debe comprobar la entrada en el lugar donde controla el almacenamiento.

Valida también el primer estado

public Thermostat(int target) {
    setTarget(target);
}

Con este constructor que limita al rango permitido, new Thermostat(50) termina en 30 °C. Asignar directamente this.target = target; permitiría el estado inicial no válido de 50. Un método privado de comprobación compartido es otra forma de reutilizar la validación en constructores y métodos posteriores.

Lanzar una excepción es útil cuando un argumento no válido señala un error de programación. Por ejemplo, un constructor puede rechazar un recuento negativo con throw new IllegalArgumentException("count must not be negative");. El objeto no se construye correctamente, por lo que no se entrega a quien lo llamó ningún objeto terminado en un estado no válido. Ignorar la entrada es más sencillo, pero silencioso; quien llama al método puede necesitar otra forma de advertir que nada ha cambiado.

Mantén los datos internos mutables dentro de la clase

Una lista privada puede seguir expuesta si un método de acceso devuelve la lista original. Quien lo llama podría entonces añadir o eliminar entradas sin utilizar los métodos de la clase, eludiendo una regla de tamaño máximo.

Para un campo ArrayList<String> llamado tracks, return new ArrayList<>(this.tracks); proporciona una lista independiente que contiene las mismas cadenas. Cambiar esa lista devuelta no modifica la lista interna. Operaciones como addTrack(String title) pueden mantener los cambios de la lista dentro de la clase y comprobar sus reglas antes de aceptarlos.

Un objeto útil debería ser fácil de inspeccionar como texto. El método incorporado toString() de Java devuelve un nombre de clase, un signo @ y un código hash hexadecimal, como Pet@8bcc55f. Un paquete con nombre pasa a formar parte del nombre de la clase. El texto del hash varía y suele decir poco sobre el estado del objeto.

Devuelve una descripción legible

@Override
public String toString() {
    return this.name + " (" + this.species + ", "
        + this.age + " years)";
}

Para Luna, una gata de 3 años, la cadena devuelta es "Luna (cat, 3 years)". El método lee los campos y construye una cadena. No modifica la mascota ni envía salida a la pantalla.

@Override pide al compilador que compruebe que la declaración realmente sustituye un método existente. Eso detecta errores como escribir tostring con una s minúscula. No da formato al resultado por ti; la expresión de retorno determina el texto.

Reconoce las llamadas automáticas

System.out.println(luna);
String label = "Pet: " + luna;
String details = luna.toString();

La primera línea imprime la descripción legible de la mascota. La segunda construye "Pet: Luna (cat, 3 years)". La tercera solicita explícitamente la misma descripción y la almacena sin imprimirla. Cuando se imprime un ArrayList de mascotas, su presentación utiliza el toString() de cada mascota dentro de los corchetes de la lista.

La conversión automática explica por qué es importante devolver texto. Quien llama al método puede estar imprimiendo, almacenando o uniendo el resultado. Un método que solo imprime no puede proporcionar la cadena que necesitan todos esos usos.

Haz coincidir la cabecera del método

Utiliza la cabecera exacta sin argumentos e incluye la anotación. Un método sobrecargado con parámetros puede ser un método independiente válido, pero imprimir un objeto no proporciona esos parámetros.

Da formato a los valores sin cambiarlos

Un reloj necesita horas y minutos de dos dígitos. Dentro de su método toString():

return String.format(java.util.Locale.US,
    "%02d:%02d", this.hours, this.minutes);

Para 9 horas y 5 minutos, la cadena es "09:05". Cada %02d da formato a un entero en al menos dos posiciones, utilizando un cero inicial cuando es necesario. String.format(java.util.Locale.US, "%.2f", 7.5) devuelve "7.50". Proporcionar la configuración regional hace que la salida con punto decimal sea independiente de la configuración regional de formato predeterminada del equipo.

Mantén la descripción lo bastante breve para leerla durante la depuración. Puede revelar un estado sin inicializar: unir un campo de nombre null a una cadena produce el texto "null", lo que te lleva de vuelta a la inicialización. La descripción debería informar del estado actual, por lo que imprimir el objeto dos veces no debería hacer avanzar un reloj ni celebrar un cumpleaños.

Empieza por lo que debe recordar un objeto, lo que quienes lo utilizan pueden pedirle que haga y qué estados deben permitirse. Después convierte cada parte en campos, constructores y métodos.

Extrae el diseño de una descripción

«Un libro de biblioteca tiene un título, un autor y un número de páginas. Se puede prestar y devolver. No se puede volver a prestar mientras ya esté prestado».

Utiliza LibraryBook como nombre de la clase. Almacena los tres valores descriptivos y un estado de préstamo booleano. El título, el autor y el número de páginas permanecen fijos, así que hazlos final. El estado de préstamo cambia mediante acciones con una función clara. No es necesario un método modificador para cada campo.

Construye la clase completa

public class LibraryBook {
    private final String title;
    private final String author;
    private final int pages;
    private boolean lentOut;

    public LibraryBook(String title, String author, int pages) {
        this.title = title;
        this.author = author;
        this.pages = pages;
        this.lentOut = false;
    }

    public boolean isLentOut() {
        return this.lentOut;
    }

    public boolean lend() {
        if (this.lentOut) {
            return false;
        }
        this.lentOut = true;
        return true;
    }

    public void giveBack() {
        this.lentOut = false;
    }

    @Override
    public String toString() {
        String status = this.lentOut ? "lent out" : "available";
        return this.title + " by " + this.author + ", "
            + this.pages + " pages, " + status;
    }
}

El constructor establece que el libro está disponible. lend() comprueba el estado existente antes de cambiarlo; devolver false en un segundo préstamo mantiene la regla. giveBack() hace que el libro esté disponible. El método de acceso informa del estado y toString() describe todo el libro sin modificarlo.

Escribe los resultados esperados antes de ejecutar las llamadas

En el método main clásico de una clase Main independiente:

LibraryBook b = new LibraryBook("Night Train", "A. Rivera", 320);
System.out.println(b);        // Night Train by A. Rivera, 320 pages, available
System.out.println(b.lend()); // true
System.out.println(b.lend()); // false
b.giveBack();
System.out.println(b.lend()); // true

El segundo intento de préstamo es esencial: un método que siempre active el indicador y devuelva true superaría la primera llamada, pero fallaría esta comprobación. Prueba el estado y los valores de retorno con isLentOut(). Prueba también un segundo libro para comprobar que un préstamo de un libro deja disponible al otro.

Prueba los puntos donde cambia el comportamiento

Cubre todos los constructores y métodos públicos. Para las comprobaciones de rango, prueba ambos extremos y valores justo fuera de ellos. Para un reloj, comprueba el cambio de minuto y el paso a medianoche. Para un método modificador que rechaza o ignora valores, comprueba que la entrada no válida tiene el efecto previsto sobre el estado anterior. Escribe primero el resultado esperado para que una salida inesperada no se convierta silenciosamente en tu nueva expectativa.

Construye en pequeños incrementos: primero los campos y el constructor, después una descripción legible y luego una operación y sus comprobaciones cada vez. Guarda las clases públicas habituales en los archivos correspondientes, compílalas juntas y ejecuta la clase que contiene main. Mantener las operaciones del modelo separadas de la salida en pantalla permite que la misma clase sirva para distintos programas.