Java шаблоны проектирования

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

Существуют различные категории шаблонов проектирования в Java, такие как паттерны создания, структурные паттерны и паттерны поведения.

Примеры паттернов создания включают в себя паттерн Singleton (Одиночка), который гарантирует, что у класса есть только один экземпляр, и паттерн Builder (Строитель), который предоставляет способ конструирования сложных объектов.

Пример паттерна Singleton:

java
public class Singleton {
    private static Singleton instance;
    
    private Singleton() {
        // private constructor to prevent instantiation
    }
    
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

Пример паттерна Builder:

java
public class Car {
    private String make;
    private String model;
    private int year;
    
    private Car(Builder builder) {
        this.make = builder.make;
        this.model = builder.model;
        this.year = builder.year;
    }
    
    public String getMake() {
        return make;
    }
    
    public String getModel() {
        return model;
    }
    
    public int getYear() {
        return year;
    }
    
    public static class Builder {
        private String make;
        private String model;
        private int year;
        
        public Builder setMake(String make) {
            this.make = make;
            return this;
        }
        
        public Builder setModel(String model) {
            this.model = model;
            return this;
        }
        
        public Builder setYear(int year) {
            this.year = year;
            return this;
        }
        
        public Car build() {
            return new Car(this);
        }
    }
}

Структурные паттерны включают в себя паттерн Adapter (Адаптер), который позволяет объектам с несовместимыми интерфейсами работать вместе, и паттерн Composite (Компоновщик), который позволяет обрабатывать группы объектов так, как если бы это был отдельный объект.

Пример паттерна Adapter:

java
public interface MediaPlayer {
    public void play(String audioType, String fileName);
}
public interface AdvancedMediaPlayer {
    public void playMp4(String fileName);
    public void playAvi(String fileName);
}
public class Mp4Player implements AdvancedMediaPlayer {
    public void playMp4(String fileName) {
        System.out.println("Playing mp4 file: " + fileName);
    }
    
    public void playAvi(String fileName) {
        // do nothing
    }
}
public class AviPlayer implements AdvancedMediaPlayer {
    public void playMp4(String fileName) {
        // do nothing
    }
    
    public void playAvi(String fileName) {
        System.out.println("Playing avi file: " + fileName);
    }
}
public class MediaAdapter implements MediaPlayer {
    AdvancedMediaPlayer player;
    
    public MediaAdapter(String audioType) {
        if (audioType.equalsIgnoreCase("mp4")) {
            player = new Mp4Player();
        } else if (audioType.equalsIgnoreCase("avi")) {
            player = new AviPlayer();
        }
    }
    
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp4")) {
            player.playMp4(fileName);
        } else if (audioType.equalsIgnoreCase("avi")) {
            player.playAvi(fileName);
        }
    }
}
public class AudioPlayer implements MediaPlayer {
    MediaAdapter adapter;
    
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing mp3 file: " + fileName);
        } else if (audioType.equalsIgnoreCase("mp4") || audioType.equalsIgnoreCase("avi")) {
            adapter = new MediaAdapter(audioType);
            adapter.play(audioType, fileName);
        } else {
            System.out.println("Invalid media type: " + audioType);
        }
    }
}

Паттерны поведения включают в себя паттерн Observer (Наблюдатель), который позволяет одним объектам следить за изменениями в других объектах, и паттерн Strategy (Стратегия), который определяет семейство алгоритмов, инкапсулирует каждый из них и обеспечивает их взаимозаменяемость.

Пример паттерна Observer:

java
import java.util.ArrayList;
import java.util.List;
public interface Observer {
    void update(String message);
}
public class MessagePublisher {
    private List observers = new ArrayList<>();
    
    public void attach(Observer observer) {
        observers.add(observer);
    }
    
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}
public class MessageSubscriber implements Observer {
    private String name;
    
    public MessageSubscriber(String name) {
        this.name = name;
    }
    
    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}

Пример паттерна Strategy:

java
public interface Strategy {
    void execute();
}
public class ConcreteStrategy1 implements Strategy {
    public void execute() {
        System.out.println("Executing strategy 1");
    }
}
public class ConcreteStrategy2 implements Strategy {
    public void execute() {
        System.out.println("Executing strategy 2");
    }
}
public class Context {
    private Strategy strategy;
    
    public Context() {
        // default strategy
        this.strategy = new ConcreteStrategy1();
    }
    
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    
    public void executeStrategy() {
        strategy.execute();
    }
}

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