Introducción a la Programación Orientada a Objetos (POO)

La Programación Orientada a Objetos (POO) es un paradigma de programación que utiliza «objetos» para diseñar aplicaciones y programas. Se basa en varios principios clave, como encapsulamiento, herencia, polimorfismo y abstracción. Este artículo explora estos principios y proporciona ejercicios prácticos para reforzar su comprensión.

Teoría

1. Conceptos Básicos de la POO

1.1. Clases y Objetos

• Clase: Es una plantilla o molde que define propiedades (atributos) y comportamientos (métodos) de los objetos. Por ejemplo, una clase Coche puede tener atributos como color y marca, y métodos como acelerar() y frenar().
• Objeto: Es una instancia de una clase. Por ejemplo, miCoche puede ser un objeto de la clase Coche.

Ejemplo:

public class Coche {
    String color;
    String marca;

    void acelerar() {
        System.out.println("El coche está acelerando");
    }

    void frenar() {
        System.out.println("El coche está frenando");
    }
}

public class Main {
    public static void main(String[] args) {
        Coche miCoche = new Coche();
        miCoche.color = "Rojo";
        miCoche.marca = "Toyota";
        miCoche.acelerar();
    }
}

1.2. Encapsulamiento

El encapsulamiento es el principio que restringe el acceso directo a algunos componentes de un objeto. Esto se logra utilizando modificadores de acceso como private, protected y public.

Ejemplo:

public class Coche {
    private String color;
    private String marca;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getMarca() {
        return marca;
    }

    public void setMarca(String marca) {
        this.marca = marca;
    }
}

1.3. Herencia

La herencia permite crear nuevas clases basadas en clases existentes. La clase derivada hereda atributos y métodos de la clase base.

Ejemplo:

public class Vehiculo {
    public void mover() {
        System.out.println("El vehículo se está moviendo");
    }
}

public class Coche extends Vehiculo {
    public void acelerar() {
        System.out.println("El coche está acelerando");
    }
}

public class Main {
    public static void main(String[] args) {
        Coche miCoche = new Coche();
        miCoche.mover();
        miCoche.acelerar();
    }
}

1.4. Polimorfismo

El polimorfismo permite que un objeto tome muchas formas. Un mismo método puede comportarse de diferentes maneras según el objeto que lo invoque.

Ejemplo:

public class Animal {
    public void hacerSonido() {
        System.out.println("El animal hace un sonido");
    }
}

public class Perro extends Animal {
    public void hacerSonido() {
        System.out.println("El perro ladra");
    }
}

public class Gato extends Animal {
    public void hacerSonido() {
        System.out.println("El gato maúlla");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal miAnimal = new Perro();
        miAnimal.hacerSonido(); // Salida: El perro ladra

        miAnimal = new Gato();
        miAnimal.hacerSonido(); // Salida: El gato maúlla
    }
}

1.5. Abstracción

La abstracción consiste en ocultar los detalles de implementación y mostrar solo la funcionalidad al usuario.

Ejemplo:

abstract class Animal {
    abstract void hacerSonido();
}

class Perro extends Animal {
    void hacerSonido() {
        System.out.println("El perro ladra");
    }
}

class Gato extends Animal {
    void hacerSonido() {
        System.out.println("El gato maúlla");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal miAnimal = new Perro();
        miAnimal.hacerSonido();

        miAnimal = new Gato();
        miAnimal.hacerSonido();
    }
}

Ejercicios Prácticos

Ejercicio 1: Crear una Clase Persona

1. Crea una clase Persona con atributos nombre, edad y métodos caminar() y hablar().
2. Instancia un objeto de Persona y usa sus métodos.

Solución:

public class Persona {
    String nombre;
    int edad;

    void caminar() {
        System.out.println(nombre + " está caminando");
    }

    void hablar() {
        System.out.println(nombre + " está hablando");
    }

    public static void main(String[] args) {
        Persona persona = new Persona();
        persona.nombre = "Juan";
        persona.edad = 30;
        persona.caminar();
        persona.hablar();
    }
}

Ejercicio 2: Implementar Encapsulamiento

1. Modifica la clase Persona para encapsular los atributos y proporciona métodos getter y setter.

Solución:

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 void setEdad(int edad) {
        this.edad = edad;
    }

    void caminar() {
        System.out.println(nombre + " está caminando");
    }

    void hablar() {
        System.out.println(nombre + " está hablando");
    }

    public static void main(String[] args) {
        Persona persona = new Persona();
        persona.setNombre("Juan");
        persona.setEdad(30);
        persona.caminar();
        persona.hablar();
    }
}

Ejercicio 3: Herencia

1. Crea una clase Estudiante que herede de Persona y añade un atributo matricula y un método estudiar().

Solución:

public class Estudiante extends Persona {
    private String matricula;

    public String getMatricula() {
        return matricula;
    }

    public void setMatricula(String matricula) {
        this.matricula = matricula;
    }

    void estudiar() {
        System.out.println(getNombre() + " está estudiando");
    }

    public static void main(String[] args) {
        Estudiante estudiante = new Estudiante();
        estudiante.setNombre("Ana");
        estudiante.setEdad(20);
        estudiante.setMatricula("20210001");
        estudiante.caminar();
        estudiante.hablar();
        estudiante.estudiar();
    }
}

Ejercicio 4: Polimorfismo

1. Crea una clase Profesor que herede de Persona y sobrescribe el método hablar().

Solución:

public class Profesor extends Persona {
    @Override
    void hablar() {
        System.out.println(getNombre() + " está dando una clase");
    }

    public static void main(String[] args) {
        Persona persona1 = new Estudiante();
        persona1.setNombre("Carlos");
        persona1.hablar();

        Persona persona2 = new Profesor();
        persona2.setNombre("Laura");
        persona2.hablar();
    }
}

Ejercicio 5: Abstracción

1. Crea una clase abstracta Animal con un método abstracto hacerSonido().
2. Crea las clases Perro y Gato que extiendan de Animal e implementen hacerSonido().

Solución:

abstract class Animal {
    abstract void hacerSonido();
}

class Perro extends Animal {
    void hacerSonido() {
        System.out.println("El perro ladra");
    }
}

class Gato extends Animal {
    void hacerSonido() {
        System.out.println("El gato maúlla");
    }

    public static void main(String[] args) {
        Animal miAnimal1 = new Perro();
        miAnimal1.hacerSonido();

        Animal miAnimal2 = new Gato();
        miAnimal2.hacerSonido();
    }
}

Conclusión

La Programación Orientada a Objetos es un paradigma poderoso y flexible que permite desarrollar software robusto, escalable y mantenible. Los conceptos de clases, objetos, encapsulamiento, herencia, polimorfismo y abstracción son fundamentales para aprovechar al máximo las ventajas de este enfoque. Practicar estos conceptos mediante ejercicios es crucial para dominar la POO y aplicarla eficazmente en proyectos de desarrollo de software.

Para más información y ejemplos, puedes consultar los siguientes recursos:

• Java Documentation
• W3Schools Java OOP
• Geeks for Geeks: Object-Oriented Programming in Java