Programación orientada a objetos en Java

Programación orientada a objetos en Java: guía completa para principiantes

La programación orientada a objetos (POO) es un paradigma fundamental en Java que permite modelar programas como objetos que interactúan entre sí. Este enfoque facilita la creación de programas más organizados, reutilizables y fáciles de mantener.

En este artículo se explican los conceptos clave de POO en Java, incluyendo:

  • clases y objetos
  • atributos y métodos
  • constructores
  • encapsulación
  • herencia
  • polimorfismo
  • interfaces

Clases y objetos

Una clase es una plantilla o modelo que define cómo será un objeto, incluyendo sus atributos (características) y métodos (comportamientos).

Un objeto es una instancia de una clase; representa un elemento concreto del programa que posee las propiedades y comportamientos definidos en la clase.

Ejemplo:

public class Persona {
    String nombre;
    int edad;

    void saludar() {
        System.out.println("Hola, mi nombre es " + nombre);
    }
}

Crear un objeto:

Persona persona1 = new Persona();
persona1.nombre = "Ana";
persona1.edad = 25;
persona1.saludar();

Salida:

Hola, mi nombre es Ana

Atributos y métodos

  • Atributos: son variables que representan el estado o las propiedades del objeto.
  • Métodos: son funciones que representan el comportamiento o las acciones que un objeto puede realizar.

Ejemplo:

public class Coche {
    String marca;   // atributo
    int velocidad;  // atributo

    void acelerar() {   // método
        velocidad += 10;
        System.out.println("Velocidad: " + velocidad);
    }
}

Crear objeto y usar sus métodos:

Coche miCoche = new Coche();
miCoche.marca = "Toyota";
miCoche.velocidad = 0;
miCoche.acelerar(); // Velocidad: 10

Constructores

Un constructor es un método especial que se utiliza para inicializar los objetos al momento de crearlos.

  • Tiene el mismo nombre que la clase
  • No tiene tipo de retorno (ni siquiera void)

Ejemplo:

public class Persona {
    String nombre;
    int edad;

    // Constructor
    public Persona(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }

    void saludar() {
        System.out.println("Hola, soy " + nombre);
    }
}

Crear un objeto usando el constructor:

Persona persona1 = new Persona("Luis", 30);
persona1.saludar(); // Hola, soy Luis

Encapsulación

La encapsulación consiste en proteger los datos de un objeto y controlar cómo se accede a ellos mediante modificadores de acceso (private, public, protected) y métodos get y set.

Ejemplo:

public class CuentaBancaria {
    private double saldo; // atributo privado

    // Método getter
    public double getSaldo() {
        return saldo;
    }

    // Método setter
    public void depositar(double cantidad) {
        if (cantidad > 0) {
            saldo += cantidad;
        }
    }
}

Uso:

CuentaBancaria cuenta = new CuentaBancaria();
cuenta.depositar(500);
System.out.println(cuenta.getSaldo()); // 500.0

La encapsulación protege los datos de cambios indebidos y mantiene la integridad del objeto.

Herencia

La herencia permite que una clase herede atributos y métodos de otra clase, promoviendo la reutilización de código.

  • La clase que hereda se llama subclase
  • La clase que es heredada se llama superclase
  • Se utiliza la palabra clave extends

Ejemplo:

public class Animal {
    void comer() {
        System.out.println("Este animal come");
    }
}

public class Perro extends Animal {
    void ladrar() {
        System.out.println("Guau!");
    }
}

Uso:

Perro miPerro = new Perro();
miPerro.comer();  // heredado de Animal
miPerro.ladrar(); // propio de Perro

Polimorfismo

El polimorfismo permite que un mismo método tenga diferentes comportamientos según el objeto que lo utiliza o según los parámetros que recibe.

Existen dos tipos principales:

  1. Polimorfismo de sobrecarga (overloading): un mismo método con diferentes parámetros
  2. Polimorfismo de sobrescritura (overriding): un método de la subclase reemplaza al de la superclase

Ejemplo de sobrecarga:

public class Calculadora {
    int sumar(int a, int b) {
        return a + b;
    }

    double sumar(double a, double b) {
        return a + b;
    }
}

Ejemplo de sobrescritura:

class Animal {
    void sonido() {
        System.out.println("Sonido genérico");
    }
}

class Gato extends Animal {
    @Override
    void sonido() {
        System.out.println("Miau");
    }
}

Interfaces

Una interface define un contrato que una clase debe cumplir, es decir, los métodos que debe implementar.
Se utiliza para desacoplar código y permitir que diferentes clases compartan comportamientos comunes.

  • Se declara con la palabra clave interface
  • Solo define métodos sin implementación

Ejemplo:

interface Volador {
    void volar();
}

class Pajaro implements Volador {
    @Override
    public void volar() {
        System.out.println("El pájaro está volando");
    }
}

Uso:

Pajaro p = new Pajaro();
p.volar(); // El pájaro está volando

Ejemplo completo

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

    // Constructor
    public Persona(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }

    // Método
    public void saludar() {
        System.out.println("Hola, soy " + nombre);
    }

    // Getter
    public int getEdad() {
        return edad;
    }
}

class Empleado extends Persona {
    private double salario;

    public Empleado(String nombre, int edad, double salario) {
        super(nombre, edad);
        this.salario = salario;
    }

    @Override
    public void saludar() {
        System.out.println("Hola, soy " + super.getEdad() + " años y trabajo aquí");
    }
}

public class Main {
    public static void main(String[] args) {
        Persona persona = new Persona("Ana", 25);
        persona.saludar();

        Empleado empleado = new Empleado("Luis", 30, 1500);
        empleado.saludar();
    }
}

Salida:

Hola, soy Ana
Hola, soy 30 años y trabajo aquí

Que aprendimos en esta seccion

La programación orientada a objetos en Java es clave para construir programas grandes, organizados y reutilizables.

Los conceptos esenciales son:

  • Clases y objetos: representan modelos y elementos concretos
  • Atributos y métodos: definen estado y comportamiento
  • Constructores: inicializan objetos
  • Encapsulación: protege los datos y controla el acceso
  • Herencia: permite reutilizar código entre clases
  • Polimorfismo: un mismo método puede comportarse de distintas formas
  • Interfaces: definen contratos que las clases deben implementar

Dominar estos conceptos es fundamental para desarrollar aplicaciones robustas y bien estructuradas en Java.

Volver al indice de Programación en Java.

Scroll to Top