Паттерны проектирования

Паттерны проектирования (или шаблоны проектирования) — это проверенные временем решения для часто встречающихся проблем в разработке программного обеспечения. Вместо того, чтобы изобретать велосипед каждый раз, когда вы сталкиваетесь с определённой задачей, вы можете воспользоваться паттерном, который уже был успешно использован многими разработчиками до вас.

Зачем нужны паттерны проектирования?

Каждый программист рано или поздно сталкивается с необходимостью создавать архитектуру приложения. Будь то новичок или опытный разработчик, время от времени возникают задачи, требующие структурных решений. Паттерны проектирования помогают:

• Сократить время разработки
• Улучшить качество кода
• Повысить читаемость и поддержку кода
• Снизить количество ошибок

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

Основные группы паттернов

Паттерны проектирования делятся на три основные группы:

1. Порождающие паттерны: они помогают создавать объекты наиболее удобным и безопасным способом. Примеры: Одиночка (Singleton), Фабричный метод (Factory Method), Абстрактная фабрика (Abstract Factory).
2. Структурные паттерны: эти паттерны помогают организовать структуры объектов и классов, обеспечивая удобство и гибкость их использования. Примеры: Адаптер (Adapter), Декоратор (Decorator), Фасад (Facade).
3. Поведенческие паттерны: они определяют способы взаимодействия между объектами. Примеры: Наблюдатель (Observer), Стратегия (Strategy), Команда (Command).

Порождающие паттерны

Одиночка (Singleton)

Одиночка гарантирует, что у класса будет только один экземпляр, и предоставляет к нему глобальную точку доступа. Например, в программе может быть только один объект для управления доступом к базе данных.

Пример кода:

public class Database {
    private static Database instance;

    private Database() {
        // private constructor
    }

    public static Database getInstance() {
        if (instance == null) {
            instance = new Database();
        }
        return instance;
    }
}

Фабричный метод (Factory Method)

Фабричный метод предоставляет интерфейс для создания объектов, но позволяет подклассам изменять тип создаваемых объектов. Это полезно, когда программа должна работать с различными типами объектов, которые имеют общий интерфейс.

Пример кода:

public abstract class Product {
    // общие методы для всех продуктов
}

public class ConcreteProductA extends Product {
    // реализация методов для продукта А
}

public class ConcreteProductB extends Product {
    // реализация методов для продукта Б
}

public abstract class Creator {
    public abstract Product factoryMethod();

    public void someOperation() {
        Product product = factoryMethod();
        // Использовать продукт
    }
}

public class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

public class ConcreteCreatorB extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

Структурные паттерны

Адаптер (Adapter)

Адаптер позволяет объектам с несовместимыми интерфейсами работать вместе. Например, у вас есть старый интерфейс для работы с файлами и новый, и вы хотите использовать их вместе.

Пример кода:

public interface OldInterface {
    void oldRequest();
}

public class OldImplementation implements OldInterface {
    @Override
    public void oldRequest() {
        System.out.println("Старый интерфейс работает");
    }
}

public interface NewInterface {
    void newRequest();
}

public class Adapter implements NewInterface {
    private OldInterface oldInterface;

    public Adapter(OldInterface oldInterface) {
        this.oldInterface = oldInterface;
    }

    @Override
    public void newRequest() {
        oldInterface.oldRequest();
    }
}

Декоратор (Decorator)

Декоратор динамически добавляет новые обязанности объекту. Это полезно, когда нужно добавить поведение к объекту, не изменяя его код.

Пример кода:

public interface Component {
    void operation();
}

public class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("Основная операция");
    }
}

public abstract class Decorator implements Component {
    protected Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        component.operation();
    }
}

public class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        System.out.println("Дополнительная операция A");
    }
}

public class ConcreteDecoratorB extends Decorator {
    public ConcreteDecoratorB(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        System.out.println("Дополнительная операция B");
    }
}

Поведенческие паттерны

Наблюдатель (Observer)

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

Пример кода:

import java.util.ArrayList;
import java.util.List;

public interface Observer {
    void update();
}

public class ConcreteObserver implements Observer {
    @Override
    public void update() {
        System.out.println("Получено уведомление об изменении состояния");
    }
}

public class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void detach(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }

    public void changeState() {
        // Изменение состояния
        notifyObservers();
    }
}

Стратегия (Strategy)

Стратегия определяет семейство алгоритмов, инкапсулирует каждый из них и делает их взаимозаменяемыми. Этот паттерн позволяет изменять алгоритмы независимо от клиентов, которые их используют.

Пример кода:

public interface Strategy {
    void execute();
}

public class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Стратегия A");
    }
}

public class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("Стратегия B");
    }
}

public class Context {
    private Strategy strategy;

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

---

---