Orientación a objetos

• Hasta ahora: encapsulamos código en funciones.

• OOP encapsula conceptos en clases: personas,

  trabajadores, vehículos...

• Una clase define:

  • Variables que describen el concepto: Atributos.

  • Funciones para manipular dicho concepto: Métodos .

Orientación a objetos (Ejemplo)

Sintaxis para definir una clase:

class Vehiculo {
	public int numRuedas;
	public String numCarroceria;
	public void avanza(){
		/* Aquí el código del método */
	}
}

Para crear una instancia (objeto) de la clase

//importamos la definición
import paquete.Vehiculo; 

//llamamos a la constructora
Vehiculo v = new Vehiculo(); 

Orientación a objetos (Matriz de acceso)

Orientación a objetos(Acceso)

​

• Podemos acceder a los métodos de igual forma:

import paquete.Vehiculo;
Vehiculo v = new Vehiculo();
v.numRuedas = 2;
System.out.println (v.numRuedas);

• Podemos acceder a los atributos públicos de la siguiente manera:

v.avanza(); 

Orientación a objetos (visibilidad de los atributos)

Opciónes de visibilidad:

• public: Acceso universal tanto dentro como fuera de la clase y paquete donde se encuentra (carpeta).
• protected: Sólo accesible desde la propia clase y sus descendientes
• private: Sólo accesible en la clase.

public class Vehiculo{
	public int numRuedas;
	private String numCarroceria;
}

Vehiculo vi = new Vehiculo();
System.out.println(vi.numRuedas);
Sstem.out.println(vi.numCarroceria);

Orientación a objetos (Acceso 2)

public class Vehiculo {
	protected int numRuedas;
	private String numCarroceria;
	
	public String getNumCarroceria() {
		return this.numCarroceria;
	}
	public void setNumCarroceria(String carr) { 
		this.numCarroceria = carr;
	}
}

Vehiculo v = new Vehiculo(); 
v.setNumCarroceria(“13354a-X”); 
System.out.println(v.getNumCarroceria());

Mediante métodos públicos (get/set) accedemos a atributos privados:

Orientación a objetos(métodos)

También podemos definir la visibilidad de los métodos

class Vehiculo{
	private String numCarroceria;
	
	public String setNumCarroceria (String numCarroceria){
		if (this.checkNumCarroceria(numCarroceria)) 
			return false; 
		else {
			this.numCarroceria = numCarroceria; 
			return true;
		}
	}
	
	private boolean checkNumCarroceria(String numCarroceria){
		return numCarroceria.isEmpty();
	}
}	

Vehiculo v = new Vehiculo();
v.checkNumCarroceria(“23213-ax”); // Error
v.setNumCarroceria(“”); // Devolverá false

Orientación a objetos (constructores)

• Para crear una instancia de la clase y dar valores iniciales a sus atributos
• Existe en todas las clases (aunque no se defina explícitamente)
• Se puede  crear una instancia de la clase con valores iniciales.

public Vehiculo(int a, String b) {
    numRuedas = a;
    numCarroceria = b;
}

Vehiculo v = new vehiculo(4, “1234-ax”); // Vehículo de 4 ruedas

Orientación a Objetos (Herencia)

• Nos permite reutilizar código
• Especialización de un concepto
• La heredera recibe los atributos y métodos del padre (públicos y protegidos)

class Coche extends Vehiculo {
	protected int numPuertas;
}

class Moto extends Vehiculo {
	protected String manillar;
}
/* Heredan numRuedas, numCarroceria y la función avanza() */

Interfaces

• Definen comportamientos que las clases deben implementar.
• Sólo contienen la definición del método.
• No se instancian, se implementan.
• Obligan a la clase a implementar los métodos.

public interface VehiculoConPuertas{
    void abrirPuertas();
    void cerrarPuertas();
}

public class Coche extends Vehiculo implements VehiculoConPuertas{
    @Override
    void abrirPuertas(){
          /* Implementación ...*/
    }

    @Override
    void cerrarPuertas(){
          /* Implementación ...*/        
    }
}

Clases y métodos abstractos

abstract class Vehiculo {
    public abstract void avanzar();
    protected int numPuertas;
}

class Moto extends Vehiculo {    
    protected String manillar;
    
    public void avanzar(){
        /* ... */    
    }
}

class abstract CocheCarreras extends Vehiculo {    
    protected String manillar;    
    public abstract void avanzar();
}

• Una clase abstracta no puede ser instanciada.
• Una clase con uno o más métodos abstractos ha de ser abstracta.
• Un método abstracto sólo contiene la definición del método.
• Una clase B que hereda de una clase abstracta A, ha de implementar las funciones abstractas o bien ser abstracta.

Orientación a Objetos (Polimorfismo)

void aparcarVehiculos(Vehiculo v){
	System.out.println(v.aparcar());
}

Moto m = new Moto();
Coche c = new Coche();
aparcarVehiculos(m);
aparcarVehiculos(c);

Se pueden redefinir métodos de la superclase para que se comporten de otra manera

La función aparcarVehiculos no sabe de qué tipo concreto es v, sin embargo ejecuta la función aparcar correspondiente porque v toma la forma del vehículo concreto que le pasan.

Al hecho de que v pueda tomar diferentes formas se le llama polimorfismo.

Orientación a objetos (Polimorfismo)

class Avion extends Vehiculo {
	public int numAlas;
	public void aparcar(){...}
	public void arreglarAlas(){...}
}

Si en el futuro alguien utiliza nuestra clase abstracta vehículo:

La función aparcar seguirá funcionando igual

Ejercicio

Crea las clases Directivo, Consultor y Becario, que heredan de la clase abstracta Trabajador.

Trabajador contendrá los datos básicos: datos personales y sueldo bruto.

Declarad una función abstracta que calculará el sueldo neto anual (bruto anual menos retención).

Directivo, Consultor y Becario redefinirán dicha función con retenciones diferentes.