Los Principios SOLID explicados

package co.com.sebastianagudelo.solid.o

// Clase base abstracta que representa un personaje con acciones comunes
public abstract class Character {
    // Método para atacar
    public void attack() {
        System.out.println("Character attacks!");
    }

    // Método para defender
    public void defend() {
        System.out.println("Character defends!");
    }

    // Método para moverse
    public void move() {
        System.out.println("Character moves!");
    }
}

// Subclase que representa un dragón, que hereda las acciones comunes de Character
public class Dragon extends Character {
    // Método específico para el dragón que le permite volar
    public void fly() {
        System.out.println("Dragon flies!");
    }
}

// Subclase que representa un mago, que hereda las acciones comunes de Character
public class Wizard extends Character {
    // Método específico para el mago que le permite lanzar hechizos
    public void castSpell() {
        System.out.println("Wizard casts a spell!");
    }
}

// Subclase que representa un espadachín, que hereda las acciones comunes de Character  
public class SwordsMan extends Character {
    // Método específico para el espadachín que le permite usar dos espadas
    public void useTwoSwords() {
        System.out.println("Swords Man uses two swords!");
    }
}

// Clase principal para demostrar el uso de diferentes personajes
public class Main {
    public static void main(String[] args) {
        // Crear un personaje de tipo Dragon y realizar acciones específicas
        Character dragon = new Dragon();
        dragon.attack(); // Acción común de atacar
        ((Dragon) dragon).fly(); // Acción específica de volar del dragón

        // Crear un personaje de tipo Wizard y realizar acciones específicas
        Character wizard = new Wizard();
        wizard.defend(); // Acción común de defender
        ((Wizard) wizard).castSpell(); // Acción específica de lanzar hechizos del mago

        // Crear un personaje de tipo SwordsMan y realizar acciones específicas
        Character swordsMan = new SwordsMan();
        swordsMan.move(); // Acción común de moverse
        ((SwordsMan) swordsMan).useTwoSwords(); // Acción específica de usar dos espadas del espadachín
    }
}

package co.com.sebastianagudelo.solid.l

// Clase base que representa un vehículo
abstract class Vehicle {
    // Método que indica que el vehículo puede moverse
    public void move() {
        System.out.println("Can move");
    }
}

// Subclase para vehículos con motor
class EngineVehicle extends Vehicle {
    // Método que permite arrancar el motor del vehículo
    public void startEngine() {
        System.out.println("Can start engine");
    }
}

// Subclase para vehículos voladores
class FlyingVehicle extends EngineVehicle {
    // Método que permite que el vehículo vuele
    public void fly() {
        System.out.println("Can fly");
    }
}

// Clase para bicicleta (no tiene motor ni puede volar)
class Bicycle extends Vehicle {
    // No necesita métodos adicionales; usa el método move() de Vehicle
}

// Clase para carro (tiene motor pero no puede volar)
class Car extends EngineVehicle {
    // Usa el método startEngine() de EngineVehicle
}

// Clase para avión (tiene motor y puede volar)
class Airplane extends FlyingVehicle {
    // Usa los métodos startEngine() y fly() de FlyingVehicle
}

// Ejemplo de uso: clase principal que muestra el uso de diferentes tipos de vehículos
public class Main {
    public static void main(String[] args) {
        Bicycle bike = new Bicycle();
        bike.move(); // La bicicleta puede moverse

        Car car = new Car();
        car.move(); // El carro puede moverse
        car.startEngine(); // El carro puede arrancar el motor

        Airplane plane = new Airplane();
        plane.move(); // El avión puede moverse
        plane.startEngine(); // El avión puede arrancar el motor
        plane.fly(); // El avión puede volar
    }
}

package co.com.sebastianagudelo.solid.i

// Clase base
abstract class Vehicle {
    public void move() {
        System.out.println("Can move");
    }
}

// Interface para vehículos con motor
interface EngineVehicle {
    void startEngine();
}

// Interface para transformación
interface Transformable {
    void transform();
}

// Interface para combate
interface Warrior {
    void attack();
}

// Subclase para vehículos voladores
class FlyingVehicle extends Vehicle {
    public void fly() {
        System.out.println("Can fly");
    }
}

// Clase para Autobot, que implementa EngineVehicle, Transformable, y Warrior
class Autobot extends Vehicle implements EngineVehicle, Transformable, Warrior {
    @Override
    public void startEngine() {
        System.out.println("Autobot can start engine");
    }

    @Override
    public void transform() {
        System.out.println("Autobot can transform");
    }

    @Override
    public void attack() {
        System.out.println("Autobot can attack");
    }
}

// Clase para Decepticon, que implementa EngineVehicle, Transformable, y Warrior, y puede volar
class Decepticon extends FlyingVehicle implements EngineVehicle, Transformable, Warrior {
    @Override
    public void startEngine() {
        System.out.println("Decepticon can start engine");
    }

    @Override
    public void transform() {
        System.out.println("Decepticon can transform");
    }

    @Override
    public void attack() {
        System.out.println("Decepticon can attack");
    }
}

// Ejemplo de uso
public class Main {
    public static void main(String[] args) {
        Autobot autobot = new Autobot();
        autobot.move();
        autobot.startEngine();
        autobot.transform();
        autobot.attack();

        Decepticon decepticon = new Decepticon();
        decepticon.move();
        decepticon.startEngine();
        decepticon.transform();
        decepticon.attack();
        decepticon.fly();
    }
}

package co.com.sebastianagudelo.solid.d

// Servicio de pago abstracto
abstract class AbstractPaymentService {
    public abstract void processPayment(double amount);
}

// Implementación del servicio de pago con tarjeta de crédito
class CreditCardPaymentService extends AbstractPaymentService {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing credit card payment of $" + amount);
    }
}

// Servicio de checkout que utiliza el servicio de pago
class CheckoutService {
    private AbstractPaymentService paymentService;

    public CheckoutService(AbstractPaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void checkout(double amount) {
        System.out.println("Initiating checkout for amount $" + amount);
        paymentService.processPayment(amount);
    }
}

// Ejemplo de uso
public class Main {
    public static void main(String[] args) {
        AbstractPaymentService paymentService = new CreditCardPaymentService();
        CheckoutService checkoutService = new CheckoutService(paymentService);

        checkoutService.checkout(100.0);
    }
}