1.13. Programación Orientada a Objetos en Java

La programación orientada a objetos (POO) es una metodología que permite modelar conceptos del mundo real como objetos en un programa. Java es un lenguaje de programación orientado a objetos muy popular y versátil. En este artículo veremos algunos conceptos fundamentales de POO en Java.

Clases y objetos

En POO, una clase es un molde o plantilla que define la estructura y comportamiento de un objeto. Un objeto es una instancia de una clase, es decir, un objeto es una entidad real basada en una clase.

Para definir una clase en Java, podemos empezar con la siguiente sintaxis:

public class MyClass {
    // propiedades y métodos
}

Por convención, los nombres de las clases en Java deben empezar en mayúscula.

Para crear un objeto a partir de una clase, usamos la siguiente sintaxis:

MyClass myObject = new MyClass();

En este ejemplo, myObject es una instancia de la clase MyClass. Podemos acceder a las propiedades y métodos de myObject usando el operador .:

myObject.property = "value";
myObject.method();

Propiedades y métodos

Las propiedades y métodos son los componentes básicos de una clase. Las propiedades son las características de un objeto, mientras que los métodos son las acciones que un objeto puede realizar.

Las propiedades se definen en una clase mediante variables:

public class Person {
    String name;
    int age;
}

En este ejemplo, Person es una clase que tiene dos propiedades: name y age.

Los métodos se definen en una clase mediante funciones:

public class Person {
    String name;
    int age;

    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }

    public void haveBirthday() {
        age++;
    }
}

En este ejemplo, Person tiene dos métodos: sayHello() y haveBirthday(). El método sayHello() imprime el nombre de la persona en la consola, mientras que el método haveBirthday() incrementa la edad de la persona en uno.

Encapsulamiento

El encapsulamiento es un principio de POO que consiste en ocultar la complejidad interna de una clase y exponer solo una interfaz pública. En Java, esto se logra mediante el uso de modificadores de acceso.

Por defecto, las propiedades y métodos de una clase son públicos, lo que significa que pueden ser accedidos desde cualquier parte del programa. Un ejemplo de clase con propiedades y métodos públicos es el siguiente:

public class BankAccount {
    public String owner;
    public int balance;

    public void deposit(int amount) {
        balance += amount;
    }

    public void withdraw(int amount) {
        if (balance >= amount) {
            balance -= amount;
        } else {
            System.out.println("Insufficient funds");
        }
    }
}

En este ejemplo, BankAccount es una clase que tiene dos propiedades públicas (owner y balance) y dos métodos públicos (deposit() y withdraw()).

Sin embargo, exponer las propiedades y métodos de una clase de forma pública puede llevar a problemas de seguridad y mantenimiento. Para solucionar esto, Java proporciona modificadores de acceso para limitar el alcance de las propiedades y métodos.

El modificador private indica que la propiedad o método solo puede ser accedido desde dentro de la clase:

public class BankAccount {
    private String owner;
    private int balance;

    public void deposit(int amount) {
        balance += amount;
    }

    public void withdraw(int amount) {
        if (balance >= amount) {
            balance -= amount;
        } else {
            System.out.println("Insufficient funds");
        }
    }
}

En este ejemplo, owner y balance son propiedades privadas, lo que significa que solo pueden ser accedidas desde dentro de la clase BankAccount.

Para acceder a las propiedades privadas desde fuera de la clase, podemos usar métodos públicos llamados getters y setters:

public class BankAccount {
    private String owner;
    private int balance;

    public String getOwner() {
        return owner;
    }

    public void setOwner(String owner) {
        this.owner = owner;
    }

    public int getBalance() {
        return balance;
    }

    public void deposit(int amount) {
        balance += amount;
    }

    public void withdraw(int amount) {
        if (balance >= amount) {
            balance -= amount;
        } else {
            System.out.println("Insufficient funds");
        }
    }
}

En este ejemplo, getOwner() y setOwner() son métodos públicos que permiten acceder y actualizar la propiedad privada owner. De la misma forma, getBalance() y deposit() permiten acceder al balance y realizar un depósito, respectivamente.

Herencia

La herencia es un principio de POO que permite crear una clase nueva a partir de una clase existente. La clase nueva hereda las propiedades y métodos de la clase existente, y puede añadir nuevas propiedades y métodos propios. Las clases nuevas se llaman subclases, mientras que las clases existentes se llaman superclases o base classes.

En Java, la sintaxis para crear una subclase es la siguiente:

public class SubClass extends SuperClass {
    // propiedades y métodos
}

En este ejemplo, SubClass es una subclase que hereda las propiedades y métodos de SuperClass.

Un ejemplo concreto de herencia en Java es el siguiente:

public class Vehicle {
    private String brand;
    private int year;

    public Vehicle(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

    public String getBrand() {
        return brand;
    }

    public int getYear() {
        return year;
    }

    public void accelerate() {
        System.out.println("Vehicle accelerating");
    }
}

public class Car extends Vehicle {
    private int horsepower;

    public Car(String brand, int year, int horsepower) {
        super(brand, year);
        this.horsepower = horsepower;
    }

    public int getHorsepower() {
        return horsepower;
    }

    public void start() {
        System.out.println("Car starting");
    }
}

En este ejemplo, Vehicle es una superclase que tiene dos propiedades (brand y year) y un método (accelerate()). Car es una subclase que hereda las propiedades y métodos de Vehicle y añade una propiedad (horsepower) y un método (start()).

Podemos crear un objeto de la subclase Car de la misma forma que un objeto de la superclase Vehicle:

Vehicle myVehicle = new Vehicle("Toyota", 2020);
Car myCar = new Car("Ford", 2018, 250);

System.out.println("Vehicle brand: " + myVehicle.getBrand());
System.out.println("Car brand: " + myCar.getBrand());
System.out.println("Car horsepower: " + myCar.getHorsepower());

myVehicle.accelerate();
myCar.accelerate();
myCar.start();

En este ejemplo, creamos un objeto myVehicle de la superclase Vehicle y un objeto myCar de la subclase Car. Podemos acceder a las propiedades y métodos de ambos objetos, y en el caso de myCar, podemos acceder a las propiedades y métodos heredados de Vehicle y los propios de Car.