¿Qué es la Programación Orientada a Objetos?

La programación orientada a objetos (P.O.O.) es un paradigma de programación que usa objetos para la creación de las aplicaciones. 

Además, nos ofrece una serie de ventajas, entre las que destacan:

• Permitir la reutilización y ampliación del código. 
• Facilitar el trabajo en equipo. 
• Agilizar el desarrollo de software. 
• Una programación parecida al mundo real, basada en "objetos".

Se basa en tres partes principales:

• Encapsulación: Variables privadas con métodos que nos permiten usar las variables.
• Herencia: Podemos hacer que una clase herede atributos y métodos de otra clase.
• Polimorfismo: Funciones, métodos, variables u objetos que pueden tener varias formas distintas.

A continuación, veremos diferentes ejemplos para cada uno de ellos.

Encapsulación

En la encapsulación utilizamos variables privadas y permitimos el acceso a ellas mediante métodos que nos permitirán iniciar las variables. A estos métodos se les conoce como getter y setter. De esta manera, podemos controlar que los métodos internos del objeto sean los que pueden acceder y que los otros objetos no cambien el estado interno de un objeto de una manera inesperada.

La estructura sería la siguiente:

class Encapsulacion{    
    private int value;
    public int getValue(){
        return value;  
    }

    public void setValue(int value){
        this.value = value;  
    }
}

Herencia

Mediante la herencia podemos hacer que una clase herede las variables y los métodos de otra clase. 

La clase que de la que heredamos se le llama superclase o clase padre. Una subclase, tiene los atributos y métodos propios añadidos a los atributos y métodos de la superclase. Para crear herencia se usa la palabra reservada extends.

Por ejemplo, todos los vehículos necesitan arrancar. Por lo que podemos definir una clase que defina que se el método start para cualquier vehículo, y después definir vehículos más concretos con sus características y su forma de arrancar.

abstract class Vehiculo{
    abstract public void start();
}

Una clase abstracta nos permite definir la estructura sin la implementación. Después podemos definir nuestras clases que heredan:

class Coche extends Vehiculo {    
    Coche(){}        
    @Override public void start(){
        System.out.println("Soy un coche");    
    }
}

Polimorfismo

El polimorfismo es la habilidad de una función, método, variable u objeto de poseer varias formas distintas. Para simplificarlo, podríamos decir que un mismo identificador comparte varios significados diferentes.

En general, se habla de: 

• Polimorfismo de asignación 
• Polimorfismo puro 
• Sobrecarga 
• Polimorfismo de inclusión

Polimorfismo de asignación

Una misma variable referenciada puede hacer referencia a más de un tipo de Clase. De esta manera, podemos agrupar grupos de objetos de diferente clase que comparten superclase.

Por ejemplo, a nosotros nos da igual si es un coche o una moto, queremos arrancar el vehículo. Podríamos tener el siguiente código:

Clase de vehículo:

abstract class Vehiculo{
    abstract public void start();
}

Clase de Coche:

abstract class Vehiculo{
    abstract public void start();
}

Main del programa:

Coche car = new Coche();        
car.start();        
Vehiculo car2 = new Coche();        
car2.start();

Salida del programa:

Soy un coche 
Soy un coche

Polimorfismo puro

Se utiliza para nombrar una función o método que puede recibir varios tipos de argumentos en tiempo de ejecución. Podemos aceptar varios objetos de diferentes tipos en tiempo de ejecución. Por ejemplo, un método que acepte cualquier tipo de vehículo:

class PolimorfismoPuro{    
    public void funcion(Vehículo v){
        // Se ejecutará para cualquier tipo de vehículo, sea coche, camión, moto…    
    }
}

Sobrecarga

Nos encontramos con una sobrecarga cuando dos o más funciones comparten el mismo identificador, pero distinta lista de argumentos. Por ejemplo, una función definida en una clase que acepta caracteres y enteros:

class Sobrecarga{    
    public void funcion(int a){
 
    }

    public void funcion(char a){
 
    }
}

Polimorfismo de inclusión

Una subclase define un método que existe en una superclase con una lista de argumentos.

Por ejemplo, podemos tener piezas de ajedrez. Todas las piezas pueden moverse, pero ese método vendrá definido por la pieza. Podremos sobrescribir este método para especificar en una pieza utilizando la palabra reservada @Override.

Podemos tener la pieza definida de forma abstracta:

abstract class Pieza { 
    public abstract void movimiento(byte X, byte Y); 
} 

Y una pieza concreta, por ejemplo el caballo, con su movimiento definido.

class Caballo extends Pieza { 
    @Override public void movimiento(byte X, byte Y) { ... } 
}