Métodos de Clase en Java

Los métodos de una clase son los que dan comportamiento a sus objetos. Los campos almacenan lo que un objeto es; los métodos describen lo que puede hacer. Hasta ahora, los métodos que has escrito han sido static — utilidades que pertenecen a la clase en sí. Este capítulo trata sobre los métodos de instancia, que pertenecen a cada objeto y operan sobre sus campos.

El término "métodos de clase" en Java está un poco sobrecargado. La mayoría de los autores lo usan para referirse a métodos definidos dentro de una clase — lo que incluye ambos tipos. Algunos lo usan estrictamente para referirse a los métodos static (porque esos pertenecen literalmente a la clase). Aquí cubriremos los métodos de instancia, y los métodos static tienen su propio capítulo en Java static.

Un método de instancia

Añade un método al cuerpo de la clase, sin static, y se convierte en parte de cada instancia:

public class Circle {
  double radius;

  double area() {
    return Math.PI * radius * radius;
  }
}

Ahora cada Circle que crees puede responder a area():

Circle c = new Circle();
c.radius = 5;
System.out.println(c.area());   // 78.539...

El cuerpo lee radius sin calificarlo — Java resuelve el nombre sin prefijo como this.radius, el campo del objeto sobre el que se llamó al método.

this — el receptor

Cada método de instancia tiene un parámetro invisible llamado this, que hace referencia al objeto sobre el que se llamó el método:

Circle a = new Circle();   a.radius = 2;
Circle b = new Circle();   b.radius = 5;

a.area();    // inside area(), this == a, so this.radius == 2
b.area();    // inside area(), this == b, so this.radius == 5

El mismo método compilado se ejecuta en ambos casos; lo que cambia es a qué objeto hace referencia this. El capítulo sobre la palabra clave this explica cuándo hay que escribir this. explícitamente y cuándo se puede omitir.

Métodos que cambian el estado

Un método también puede escribir en los campos. Estos métodos suelen llamarse mutadores:

public class Counter {
  int count;

  void increment() {
    count++;            // mutates this.count
  }
  void reset() {
    count = 0;
  }
  int get() {
    return count;
  }
}

Counter c = new Counter();
c.increment(); c.increment(); c.increment();
System.out.println(c.get());   // 3

La mutación a través de métodos es cómo los objetos evolucionan con el tiempo sin que el código externo toque sus campos directamente. Los métodos que solo leen un campo y lo devuelven son la imagen especular — normalmente se llaman accesores o getters (int get() en el ejemplo es uno). Enrutar lecturas y escrituras a través de métodos, en lugar de exponer los campos, es la idea central detrás de la encapsulación: el objeto mantiene el control sobre sus propios datos.

Llamar a otros métodos desde dentro

Los métodos de instancia pueden llamar a otros métodos sobre el mismo objeto, simplemente por nombre:

public class Rectangle {
  double width, height;

  double area()      { return width * height; }
  double perimeter() { return 2 * (width + height); }

  String describe() {
    return "area=" + area() + ", perimeter=" + perimeter();
  }
}

El compilador convierte area() y perimeter() dentro de describe en this.area() y this.perimeter(). Llaman a los métodos sobre el rectángulo sobre el que se llamó a describe.

Estático vs. instancia — cuál usar

La regla general: ¿depende el método del estado por objeto?

• Si sí, es un método de instancia (sin static).
• Si no, es static.

public class Math2 {
  public static int squared(int n) {       // pure calculation — static
    return n * n;
  }
}

public class Counter {
  int count;
  public void increment() {                // reads/writes this.count — instance
    count++;
  }
}

Un indicio común es un método de instancia que ignora this por completo — eso es un método static disfrazado. El capítulo Java static analiza las compensaciones.

Llamar a un método de instancia necesita una instancia

Dado que los métodos de instancia leen this, no se puede llamar a uno sin un objeto:

Counter.increment();      // ERROR — increment is not static
new Counter().increment(); // fine — increment is called on a fresh Counter (which is then thrown away)

Counter c = new Counter();
c.increment();             // fine — increment is called on c

Este es el error de compilación más común que cometen los principiantes: un método no estático referenciado desde un contexto estático (normalmente desde main, que es en sí mismo estático).

Sobrecarga y sobreescritura

Los métodos de instancia soportan ambas:

• Sobrecarga: múltiples métodos con el mismo nombre pero distintas listas de parámetros en la misma clase (cubierto en sobrecarga de métodos).
• Sobreescritura: una subclase reemplaza la versión heredada de un método (cubierto en sobreescritura de métodos).

Ya has visto la sobrecarga en la Parte 5. La sobreescritura es uno de los grandes beneficios de la herencia y aparece pronto.

Los cuerpos de los métodos son bloques

El cuerpo de un método es simplemente un bloque de código ordinario — las variables que declares son locales a la llamada, el flujo de control funciona igual que en cualquier otro lugar, y puedes retornar anticipadamente. Nada del hecho de "estar en una clase" cambia cómo se lee el cuerpo en sí. La única capacidad adicional es que los identificadores simples ahora pueden hacer referencia a los campos y otros métodos del objeto.

Un ejemplo práctico

Este ejemplo reúne accesores (area, perimeter), un mutador (scale) y un método que llama a otros métodos (describe) en una sola clase. Rectangle se declara como static class solo para que toda la demo quepa en un único archivo — esa palabra clave se aplica a la clase anidada, no a sus métodos de instancia, que aún se ejecutan sobre un rectángulo específico. Observa que escalar r deja s sin cambios: cada objeto lleva su propio estado.

¿Qué sigue?

Hasta ahora has creado objetos escribiendo new Dog() y luego rellenando los campos uno a uno. Eso es verboso y propenso a errores — y fácil de olvidar. La solución es un constructor, un método especial que se ejecuta cuando se crea el objeto. Continúa con el capítulo de constructores.

Práctica