Artículo

this en Java: para qué sirve y sus 4 usos con ejemplos

Qué es this en Java y sus cuatro usos: distinguir campos de parámetros, llamar a otro constructor, encadenar métodos y pasar el objeto actual, con ejemplo.

En resumen: this es una referencia al objeto actual, el que está ejecutando el método. Se usa para cuatro cosas: distinguir un campo de un parámetro con el mismo nombre (this.nombre = nombre), llamar a otro constructor de la misma clase (this(...)), devolver el propio objeto para encadenar llamadas (return this) y pasarlo como argumento (catalogo.anadir(this)). No existe en métodos static. Probado con Java 25, compatible desde Java 17.

Vídeo explicativo

Los cuatro usos en un ejemplo

class Producto {
    private final String nombre;
    private double precio;

    Producto(String nombre, double precio) {
        this.nombre = nombre;       // this distingue el campo del parámetro
        this.precio = precio;
    }

    Producto(String nombre) {
        this(nombre, 0.0);          // llama al otro constructor
    }

    Producto conDescuento(double porcentaje) {
        this.precio = precio * (1 - porcentaje / 100);
        return this;                // permite encadenar llamadas
    }

    void registrarEn(Catalogo catalogo) {
        catalogo.anadir(this);      // pasa el objeto actual como argumento
    }

    @Override
    public String toString() {
        return nombre + " (" + precio + " €)";
    }
}

class Catalogo {
    void anadir(Producto p) {
        System.out.println("Añadido al catálogo: " + p);
    }
}

public class Main {
    private int valor = 10;

    void mostrar() {
        int valor = 99;
        System.out.println("variable local = " + valor + ", this.valor = " + this.valor);
    }

    public static void main(String[] args) {
        Producto curso = new Producto("Curso de Java", 100).conDescuento(20).conDescuento(10);
        System.out.println(curso);
        System.out.println(new Producto("Ebook gratis"));
        curso.registrarEn(new Catalogo());
        new Main().mostrar();
    }
}

Salida:

Curso de Java (72.0 €)
Ebook gratis (0.0 €)
Añadido al catálogo: Curso de Java (72.0 €)
variable local = 99, this.valor = 10

Cada uso, explicado

UsoSintaxisPara qué
Campo frente a parámetrothis.nombre = nombreEl parámetro oculta al campo; this. señala el campo
Llamar a otro constructorthis(nombre, 0.0)Evita duplicar la lógica de inicialización
Encadenar llamadasreturn thisAPIs fluidas como los builders
Pasar el objeto actualcatalogo.anadir(this)Registrarse en otro objeto, listeners

Ocultación de variables

En mostrar(), la variable local valor oculta al campo valor. Sin this, Java usa siempre la más cercana (la local). El error clásico es escribir nombre = nombre; en un constructor: asigna el parámetro a sí mismo y el campo se queda en null. El compilador no da error; muchos IDE sí avisan.

this(...) debe ir primero… casi siempre

Hasta Java 24, this(...) y super(...) tenían que ser la primera sentencia del constructor. Desde Java 25 puedes poner validaciones antes, siempre que no uses el objeto todavía. Lo vemos en las novedades de Java 25.

return this y la mutabilidad

Encadenar llamadas con return this es cómodo, pero en el ejemplo conDescuento modifica el producto. En objetos inmutables, el patrón equivalente devuelve un objeto nuevo (return new Producto(nombre, nuevoPrecio)), como hacen String o LocalDate.

this y super

  • this se refiere al objeto actual con el tipo de la clase que estás escribiendo.
  • super accede a la versión de la clase padre: super.toString() o super(...) para llamar a su constructor. Lo vemos en herencia en Java.

Preguntas frecuentes

¿Por qué no puedo usar this en un método static?

Porque un método static pertenece a la clase, no a un objeto: no hay «objeto actual» al que referirse.

¿Es obligatorio escribir this?

Solo cuando hay ambigüedad (un parámetro con el mismo nombre que el campo) o en los usos this(...), return this y pasar el objeto. En el resto de casos es opcional y cuestión de estilo.

¿Qué es Clase.this?

Desde una clase interna, Externa.this accede a la instancia de la clase que la contiene, porque this a secas se refiere al objeto interno.

Sigue aprendiendo

this, constructores y encapsulación son parte del bloque de POO del curso de Java desde cero. Sigue con programación orientada a objetos en Java.

this java palabra clave this constructores programación orientada a objetos

Newsletter Semanal de Java

Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.

Sin spam. Cancela cuando quieras.

Compartir artículo