Què és la Programació Orientada a Objectes?

La programació orientada a objectes (P.O.O.) és un paradigma de programació que utilitza objectes per a la creació de les aplicacions.

A més, ens ofereix una sèrie d'avantatges, entre els quals destaquen:

• Permetre la reutilització i ampliació del codi.
• Facilitar el treball en equip.
• Agilitzar el desenvolupament de programari.
• Una programació semblant al món real, basada en "objectes".

Es basa en tres parts principals:

• Encapsulació: Variables privades amb mètodes que ens permeten utilitzar les variables.
• Herència: Podem fer que una classe hereti atributs i mètodes d'una altra classe.
• Polimorfisme: Funcions, mètodes, variables o objectes que poden tenir diverses formes diferents.

A continuació, veurem diferents exemples per a cadascun d'ells.

Encapsulació

En l'encapsulació utilitzem variables privades i hi permetem l'accés mitjançant mètodes que ens permetran iniciar les variables. A aquests mètodes se'ls coneix com a getter i setter. D'aquesta manera, podem controlar que els mètodes interns de l'objecte siguin els que hi poden accedir i que els altres objectes no canviïn l'estat intern d'un objecte d'una manera inesperada.

L'estructura seria la següent:

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

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

Herència

Mitjançant l'herència podem fer que una classe hereti les variables i els mètodes d'una altra classe.

La classe de la qual heretem s'anomena superclasse o classe pare. Una subclasse té els atributs i mètodes propis afegits als atributs i mètodes de la superclasse. Per crear herència s'utilitza la paraula reservada extends.

Per exemple, tots els vehicles necessiten arrencar. Per tant, podem definir una classe que defineixi el mètode start per a qualsevol vehicle, i després definir vehicles més concrets amb les seves característiques i la seva forma d'arrencar.

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

Una classe abstracta ens permet definir l'estructura sense la implementació. Després podem definir les nostres classes que hereten:

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

Polimorfisme

El polimorfisme és l'habilitat d'una funció, mètode, variable o objecte de posseir diverses formes diferents. Per simplificar-ho, podríem dir que un mateix identificador comparteix diversos significats diferents.

En general, es parla de:

• Polimorfisme d'assignació
• Polimorfisme pur
• Sobrecàrrega
• Polimorfisme d'inclusió

Polimorfisme d'assignació

Una mateixa variable referenciada pot fer referència a més d'un tipus de Classe. D'aquesta manera, podem agrupar grups d'objectes de diferent classe que comparteixen superclasse.

Per exemple, a nosaltres ens és igual si és un cotxe o una moto, volem arrencar el vehicle. Podríem tenir el codi següent:

Classe de vehicle:

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

Classe de Cotxe:

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

Main del programa:

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

Sortida del programa:

Soy un coche 
Soy un coche

Polimorfisme pur

S'utilitza per anomenar una funció o mètode que pot rebre diversos tipus d'arguments en temps d'execució. Podem acceptar diversos objectes de diferents tipus en temps d'execució. Per exemple, un mètode que accepti qualsevol tipus de vehicle:

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

Sobrecàrrega

Ens trobem amb una sobrecàrrega quan dues o més funcions comparteixen el mateix identificador, però diferent llista d'arguments. Per exemple, una funció definida en una classe que accepta caràcters i enters:

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

    public void funcion(char a){
 
    }
}

Polimorfisme d'inclusió

Una subclasse defineix un mètode que existeix en una superclasse amb una llista d'arguments.

Per exemple, podem tenir peces d'escacs. Totes les peces es poden moure, però aquest mètode vindrà definit per la peça. Podrem sobresriure aquest mètode per especificar en una peça utilitzant la paraula reservada @Override.

Podem tenir la peça definida de forma abstracta:

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

I una peça concreta, per exemple el cavall, amb el seu moviment definit.

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