TutorJava Nivel Básico: tutorial completo Java 21

La orientación a objetos (OOP) es el paradigma central de Java. Todo el código Java vive dentro de clases. Entender bien los cuatro pilares —encapsulación, herencia, polimorfismo y abstracción— es la base de cualquier programa Java serio.

Clases y objetos

Una clase es el molde o plantilla. Un objeto es una instancia concreta de esa clase. La clase define los atributos (qué datos tiene) y los métodos (qué puede hacer).

public class Coche {
    // Atributos (estado)
    private String marca;
    private int velocidad;

    // Constructor
    public Coche(String marca) {
        this.marca = marca;
        this.velocidad = 0;
    }

    // Métodos (comportamiento)
    public void acelerar(int incremento) {
        velocidad += incremento;
    }

    public int getVelocidad() {
        return velocidad;
    }

    public String getMarca() {
        return marca;
    }
}

// Crear objetos
Coche c1 = new Coche("Toyota");
Coche c2 = new Coche("Ford");
c1.acelerar(50);
System.out.println(c1.getMarca() + " va a " + c1.getVelocidad() + " km/h");

Encapsulación

La encapsulación protege el estado interno del objeto. Los atributos se declaran private y se acceden a través de métodos public (getters/setters). Esto permite cambiar la implementación interna sin afectar al código que usa la clase.

Convenio en Java: getters con prefijo get, setters con set, y getters de boolean con is:

public class Persona {
    private String nombre;
    private int edad;

    public String getNombre() { return nombre; }
    public void setNombre(String nombre) { this.nombre = nombre; }
    public int getEdad() { return edad; }
    public boolean esMayorDeEdad() { return edad >= 18; }
}

Constructores

El constructor inicializa el objeto. Se llama igual que la clase, no tiene tipo de retorno y se invoca con new. Se pueden sobrecargar (tener varios con distintos parámetros):

public class Punto {
    private double x, y;

    public Punto() { this(0.0, 0.0); }  // delega al otro constructor

    public Punto(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double distanciaAlOrigen() {
        return Math.sqrt(x * x + y * y);
    }

    @Override
    public String toString() {
        return "(" + x + ", " + y + ")";
    }
}

La palabra clave this

this referencia al propio objeto. Se usa para distinguir atributos de parámetros con el mismo nombre, para llamar a otro constructor de la misma clase (this(...)), o para pasar el objeto actual como argumento a otro método.

Modificadores de acceso

Regla práctica: los atributos siempre private, los métodos de la API pública public, los métodos internos de ayuda private.

static: miembros de clase vs. de instancia

Los miembros static pertenecen a la clase, no a ninguna instancia concreta. Se acceden con el nombre de la clase:

public class Contador {
    private static int total = 0;  // compartido por todos los objetos
    private int id;

    public Contador() {
        total++;
        this.id = total;
    }

    public static int getTotal() { return total; }
    public int getId() { return id; }
}

Contador a = new Contador();
Contador b = new Contador();
System.out.println(Contador.getTotal()); // 2