Қолданбаларыңыздың архитектурасын жобалау кезінде…

Мен ашықтық-жабықтық қағидатын (O) абстракциялар (интерфейстер, абстрактты сыныптар) арқылы қолданамын. Бұл мүмкіндік береді:

Барлық жаңа функционалдылықты бұрынғы кодты өзгеріссіз қосу. Мен интерфейсті анықтаймын, ол мінез-құлықты сипаттайды. Клиенттік код осы интерфейспен өзара әрекеттеседі. Жаңа жүзеге асыруды қосу үшін мен жаңа сыныпты жасаймын, ол осы интерфейсті жүзеге асырады, ал интерфейсті қолданатын сыныптарға өзгеріс енгізбестен.
Полиморфизмді қолдану. Интерфейс немесе абстрактты сыныптың әртүрлі жүзеге асырулары контекстке байланысты орнатылуы мүмкін, бұл олардың қолданылуын өзгертпестен.

Қолдану мысалдары:

Стратегия (Strategy): Мен PaymentMethod интерфейсін анықтаймын. CreditCardPayment, PayPalPayment сыныптары оны жүзеге асырады. OrderProcessor сыныбы PaymentMethod-ке негізделген, бұл жаңа төлем әдістерін оңай қосуға мүмкіндік береді.

// Төлем әдісін сипаттайтын интерфейс
public interface PaymentMethod {
    void pay(double amount);
}

// Несие картасымен төлеу жүзеге асыру
public class CreditCardPayment implements PaymentMethod {
    @Override
    public void pay(double amount) {
        System.out.println("Төлеу " + amount + " несие картасымен");
        // Төлемді өңдеу логикасы
    }
}

// PayPal арқылы төлеу жүзеге асыру
public class PayPalPayment implements PaymentMethod {
    @Override
    public void pay(double amount) {
        System.out.println("Төлеу " + amount + " PayPal арқылы");
        // PayPal төлемін өңдеу логикасы
    }
}

// Төлем әдісін қолданатын сынып (өзгертуге жабық)
public class OrderProcessor {
    private PaymentMethod paymentMethod;

    public OrderProcessor(PaymentMethod paymentMethod) {
        this.paymentMethod = paymentMethod;
    }

    public void processOrder(double totalAmount) {
        System.out.println("Тапсырысты өңдеу...");
        paymentMethod.pay(totalAmount); // Абстракцияны қолдану
        System.out.println("Тапсырыс өңделді.");
    }
}

Фабрика (Factory Method): Мен объектілерді жасау үшін фабриканы қолданамын. Фабрика жалпы интерфейс бойынша объектілерді қайтарады, бұл жаңа типтегі объектілерді қосуға мүмкіндік береді, оны қолданатын кодты өзгерту қажет емес.

// Өнім интерфейсі
public interface Product {
    void display();
}

// А нақты өнімі
public class ConcreteProductA implements Product {
    @Override
    public void display() {
        System.out.println("Бұл Product A");
    }
}

// B нақты өнімі
public class ConcreteProductB implements Product {
    @Override
    public void display() {
        System.out.println("Бұл Product B");
    }
}

// Абстрактты фабрика
public abstract class ProductFactory {
    public abstract Product createProduct();
}

// A өнімі үшін нақты фабрика
public class ConcreteFactoryA extends ProductFactory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// B өнімі үшін нақты фабрика
public class ConcreteFactoryB extends ProductFactory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// Клиенттік код, ол фабриканы қолданады (өзгертуге жабық)
public class Client {
    private ProductFactory factory;

    public Client(ProductFactory factory) {
        this.factory = factory;
    }

    public void demonstrateProduct() {
        Product product = factory.createProduct(); // Абстракцияны қолдану
        product.display();
    }
}

Декоратор (Decorator): Объектілерге динамикалық түрде жаңа мінез-құлық қосуға мүмкіндік береді, оларды декораторлар деп аталатын объектілермен орау арқылы жүзеге асырылады, олар да сол интерфейсті жүзеге асырады.

// Компонент интерфейсі
public interface Coffee {
    double getCost();
    String getDescription();
}

// Негізгі компонент
public class SimpleCoffee implements Coffee {
    @Override
    public double getCost() {
        return 5.0;
    }

    @Override
    public String getDescription() {
        return "Қарапайым кофе";
    }
}

// Абстрактты декоратор
public abstract class CoffeeDecorator implements Coffee {
    protected Coffee decoratedCoffee;

    public CoffeeDecorator(Coffee decoratedCoffee) {
        this.decoratedCoffee = decoratedCoffee;
    }

    @Override
    public double getCost() {
        return decoratedCoffee.getCost();
    }

    @Override
    public String getDescription() {
        return decoratedCoffee.getDescription();
    }
}

// Нақты декоратор: сүт
public class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee decoratedCoffee) {
        super(decoratedCoffee);
    }

    @Override
    public double getCost() {
        return super.getCost() + 1.5;
    }

    @Override
    public String getDescription() {
        return super.getDescription() + ", Сүт";
    }
}

// Нақты декоратор: қант
public class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee decoratedCoffee) {
        super(decoratedCoffee);
    }

    @Override
    public double getCost() {
        return super.getCost() + 0.5;
    }

    @Override
    public String getDescription() {
        return super.getDescription() + ", Қант";
    }
}

// Клиенттік код, компоненттерді қолданатын (өзгертуге жабық)
public class CoffeeShop {
    public static void main(String[] args) {
        Coffee myCoffee = new SimpleCoffee();
        System.out.println(myCoffee.getDescription() + " құны: $" + myCoffee.getCost());

        myCoffee = new MilkDecorator(myCoffee); // Декораторға орау
        System.out.println(myCoffee.getDescription() + " құны: $" + myCoffee.getCost());

        myCoffee = new SugarDecorator(myCoffee); // Басқа декораторға орау
        System.out.println(myCoffee.getDescription() + " құны: $" + myCoffee.getCost());
    }
}

Бұл тәсілдер кодты икемді, кеңейтілген, қолдауға оңай және өзгерістерге тұрақты етеді.

Қолданбаларыңыздың архитектурасын жобалау кезінде SOLID принципінің ашық-жабық қағидатын (O) қалай қолданасыз?