Programación orientada a objetos

¿Qué es POO y por qué es importante?

POO (Programación orientada a objetos), es un paradigma de programación, modelo o estilo de programación que brinda una forma limpia y clara de como usar conceptos de clases y objetos. Permitiendo tener un código organizado, limpio y sencillo de mantener.

---

Herencia

Introduce el concepto de jerarquías con Clases Padres (Superclases) y Clases Hijos (Subclases)

• Clase Padre

public class Character {  
    public String name;  
    public String maxHp;  
  
    Character(String name, String maxHp) {  
        this.name = name;  
        this.maxHp = maxHp;  
    }  
}

• Clase Hijo

public class Magician extends Character {  
    public String magicType;  
    public String typeAttack;  
    private int level;  
  
    Magician(String name, String maxHp, String magicType, String typeAttack) {  
        super(name, maxHp);  
        this.magicType = magicType;  
        this.typeAttack = typeAttack;  
    }  
}

Esto simplifica la cantidad de código que se escribe, aplicando DRY (Don’t repeat yourself).

---

Encapsulamiento

Restringe el acceso a métodos y atributos de las clases

• Público: Se pueden acceder desde cualquier parte del código.
• Protegido: Se puede acceder únicamente desde la misma clase o desde las clases que heredan.
• Privado: Se puede acceder únicamente desde la misma clase.

public class Magician extends Character {  
    public String magicType;  
    public String typeAttack;  
    private int level;  
  
    public Magician(String name, String maxHp, String magicType, String typeAttack, int level) {  
        super(name, maxHp);  
        this.magicType = magicType;  
        this.typeAttack = typeAttack;  
        this.level = level;  
    }  
}

final Magician magician = new Magician("Magician", "100", "ICE", "ICE BREAKER", 2);

final int level = magician.level;  // 'level' has private access in 'ec.api.test.service.Magician'
final String typeAttack = magician.typeAttack;

---

Abstracción

Se trata de modelar entidades del mundo real centrado en él ¿Qué hace? Y NO en él ¿Cómo lo hace?, ocultando los detalles internos de la implementación.

public abstract class Pago {  
    protected double amount;  
  
    protected Pago(double amount) {  
        this.amount = amount;  
    }  
  
    public abstract void makePayment();  
  
    public void showInfoAmount() {  
        System.out.printf("Amount to pay: $%s%n", amount);  
    }  
}

public class PagoEfectivo extends Pago {  
    public PagoEfectivo(double amount) {  
        super(amount);  
    }  
  
    @Override  
    public void makePayment() {  
        System.out.printf("Making payment %s ...", this.amount);  
    }  
}

public class PagoTarjeta extends Pago {  
    private String cardNumber;  
  
    public PagoTarjeta(double amount, String cardNumber) {  
        super(amount);  
        this.cardNumber = cardNumber;  
    }  
  
    @Override  
    public void makePayment() {  
        System.out.println("Making Payment for Tarjeta " + this.cardNumber);  
    }  
  
    @Override  
    public void showInfoAmount() {  
        System.out.printf("[CARD] Amount to pay: $%s%n", amount);  
    }  
}


final PagoEfectivo pagoEfectivo = new PagoEfectivo(100);  
final PagoTarjeta pagoTarjeta = new PagoTarjeta(100, "123123123123");  
  
final List<Pago> payments = new ArrayList<>();  
payments.add(pagoTarjeta);  
payments.add(pagoEfectivo);  
  
for (Pago pago : payments) {  
    pago.showInfoAmount();  
}

[CARD] Amount to pay: $100.0
Amount to pay: $100.0

Output

---

Polimorfismo

Permite que un método tome varias formas (Varía su comportamiento), existe dos tipos:

Polimorfismo Dinámico

• Ocurre en Tiempo de Ejecución.
• Se da cuando se hace Herencia y el comportamiento de clase hijo cambia con el de la clase padre
• Se evidencia cuando se usa @Override

public abstract class Animal {  
    public abstract void doSound();  
}

public class Cat extends Animal {  
    @Override  
    public void doSound() {  
        System.out.println("Miau");  
    }  
}

public class Dog extends Animal {  
    @Override  
    public void doSound() {  
        System.out.println("Woof");  
    }  
}

final Cat cat = new Cat();  
final Dog dog = new Dog();  
  
final List<Animal> animals = new ArrayList<>();  
  
animals.add(cat);  
animals.add(dog);  
  
for (Animal animal : animals) {  
    animal.doSound();  
}

Miau
Woof

output

Polimorfismo Estático

• Ocurre en Tiempo de Compilación
• Se da cuando realizamos sobrecarga de métodos (Varios métodos con el mismo nombre, pero, con diferentes argumentos)

public class Dog extends Animal {  
    @Override  
    public void doSound() {  
        System.out.println("Woof");  
    }  
  
    public void doSound(String ambient) {  
        if (ambient.equals("pool")) {  
            System.out.println("woof glu glu glu");  
        }  
  
        if  (ambient.equals("forest")) {  
            System.out.println("woof woof oof of f");  
        }  
    }  
}

final Dog dog = new Dog();
dog.doSound("forest");

woof woof oof of f

output

---

Tiempo de Compilación vs. Tiempo de Ejecución

Compilación

1) javac lee los archivos .java y los pasa bytecode (archivos con extensión .class) 2) Aquí el compilador verifica, tipos correctos, métodos y variables que existan, sintáxis válida.

Proceso Compilación

Ejecución

1) La JVM toma esos archivos .class (bytecode) y ejecuta instrucción por instrucción.

Proceso Ejecución

Analogía

Imaginemos que queremos cocinar algo:

• Compilación: Verificar que tengamos todos los ingredientes y utensilios necesarios. (Sin esto no podemos empezar a cocinar)
• Ejecución: Aquí se nos puede quemar o que se nos pase la sal. (Podemos cocinar, pero, en el proceso podemos cometer errores)