Как реализовать принцип open/closed?

Принцип Open/Closed (Open for Extension, Closed for Modification)

Этот SOLID-принцип требует, чтобы классы и модули были открыты для расширения, но закрыты для модификации. Это означает, что новая функциональность должна добавляться через расширение, а не через изменение существующего кода.

Почему это важно

Проблема без применения принципа:

• При добавлении нового функционала приходится менять существующий код
• Риск сломать работающую функциональность
• Растёт сложность ветвлений в коде
• Сложнее тестировать код

Практическая реализация в Flutter

1. Использование абстрактных классов и интерфейсов

// ❌ Плохо: замкнутый класс
class PaymentProcessor {
  void processPayment(String type, double amount) {
    if (type == "credit_card") {
      print("Обработка кредитной карты: $amount");
    } else if (type == "paypal") {
      print("Обработка PayPal: $amount");
    } else if (type == "apple_pay") {
      print("Обработка Apple Pay: $amount");
    }
  }
}

Проблема: каждый новый способ оплаты требует изменения класса.

// ✅ Хорошо: открыт для расширения
abstract class PaymentMethod {
  void process(double amount);
}

class CreditCardPayment implements PaymentMethod {
  @override
  void process(double amount) {
    print("Обработка кредитной карты: $amount");
  }
}

class PayPalPayment implements PaymentMethod {
  @override
  void process(double amount) {
    print("Обработка PayPal: $amount");
  }
}

class ApplePayPayment implements PaymentMethod {
  @override
  void process(double amount) {
    print("Обработка Apple Pay: $amount");
  }
}

class PaymentProcessor {
  final PaymentMethod _paymentMethod;
  
  PaymentProcessor(this._paymentMethod);
  
  void processPayment(double amount) {
    _paymentMethod.process(amount);
  }
}

Теперь добавление нового способа оплаты не требует изменения PaymentProcessor.

2. Стратегия с Flutter-компонентами

// Абстрактный класс для стратегий сортировки
abstract class SortStrategy {
  List<T> sort<T extends Comparable>(List<T> items);
}

// Конкретные реализации
class AscendingSortStrategy implements SortStrategy {
  @override
  List<T> sort<T extends Comparable>(List<T> items) {
    return items..sort();
  }
}

class DescendingSortStrategy implements SortStrategy {
  @override
  List<T> sort<T extends Comparable>(List<T> items) {
    return items..sort((a, b) => b.compareTo(a));
  }
}

// Использование
class DataManager {
  final SortStrategy _sortStrategy;
  
  DataManager(this._sortStrategy);
  
  List<T> sortData<T extends Comparable>(List<T> data) {
    return _sortStrategy.sort(data);
  }
}

3. Виджеты и расширяемость

// Базовый класс для кастомизируемого контейнера
abstract class CardWidget extends StatelessWidget {
  final Color backgroundColor;
  final EdgeInsets padding;
  
  const CardWidget({
    this.backgroundColor = Colors.white,
    this.padding = const EdgeInsets.all(16),
  });
  
  Widget buildContent(BuildContext context);
  
  @override
  Widget build(BuildContext context) {
    return Container(
      decoration: BoxDecoration(
        color: backgroundColor,
        borderRadius: BorderRadius.circular(8),
      ),
      padding: padding,
      child: buildContent(context),
    );
  }
}

// Расширение для конкретного типа карточки
class UserCard extends CardWidget {
  final User user;
  
  const UserCard(this.user);
  
  @override
  Widget buildContent(BuildContext context) {
    return Column(
      children: [
        Text(user.name),
        Text(user.email),
      ],
    );
  }
}

Ключевые техники реализации

• Инъекция зависимостей — передавайте зависимости конструктором
• Интерфейсы и абстрактные классы — определяйте контракты, не реализацию
• Composition over Inheritance — компонуйте объекты вместо наследования
• Factory паттерны — создавайте объекты через фабрики, не прямую инстанцировку
• Тесты — пишите юнит-тесты для проверки расширяемости

Преимущества

✅ Модульность — каждый класс отвечает за своё ✅ Тестируемость — легче писать unit-тесты ✅ Масштабируемость — новая функциональность добавляется без риска ✅ Переиспользование — компоненты легче использовать в других проектах ✅ Чистота кода — меньше условных операторов и веток

Применение этого принципа делает код более гибким и готовым к будущим изменениям.