深入理解Java的设计模式

设计模式（Design Patterns）是软件开发中的宝贵经验总结，提供了解决常见设计问题的模板和最佳实践。在Java开发中，设计模式尤为重要，因为它们能够提高代码的可维护性、可扩展性和可重用性。本篇博客将详细介绍几种常见的设计模式，帮助读者掌握如何在Java开发中应用这些模式。

什么是设计模式？

设计模式是软件设计中反复出现的解决方案。它们不是具体的代码，而是关于如何解决某一类型问题的一般性描述。设计模式通常分为三大类：

1. 创建型模式：关注对象的创建方式。
2. 结构型模式：关注类和对象的组合。
3. 行为型模式：关注类和对象之间的交互。

创建型模式

单例模式（Singleton Pattern）

单例模式确保一个类只有一个实例，并提供一个全局访问点。单例模式在需要控制资源的唯一性时非常有用，例如数据库连接、线程池等。

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造函数，防止外部实例化
    }

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

优点

• 控制实例数量，节省资源。
• 提供全局访问点。

缺点

• 多线程环境下需要考虑同步问题。
• 可能违背单一职责原则，因为类既要管理实例的创建，又要执行其他任务。

工厂模式（Factory Pattern）

工厂模式通过定义一个创建对象的接口来实现对象的实例化，而不是直接通过new操作符。这样可以使得创建过程与使用过程分离。

interface Shape {
    void draw();
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Square");
    }
}

class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }
        return null;
    }
}

优点

• 封装创建逻辑，代码更简洁。
• 易于扩展，增加新类型无需修改现有代码。

缺点

• 增加了系统的复杂性，需要更多的类和接口。

结构型模式

适配器模式（Adapter Pattern）

适配器模式将一个类的接口转换成客户端期望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以协同工作。

interface MediaPlayer {
    void play(String audioType, String fileName);
}

class AudioPlayer implements MediaPlayer {
    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing mp3 file. Name: " + fileName);
        }
    }
}

interface AdvancedMediaPlayer {
    void playVlc(String fileName);
    void playMp4(String fileName);
}

class VlcPlayer implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file. Name: " + fileName);
    }

    @Override
    public void playMp4(String fileName) {
        // do nothing
    }
}

class Mp4Player implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        // do nothing
    }

    @Override
    public void playMp4(String fileName) {
        System.out.println("Playing mp4 file. Name: " + fileName);
    }
}

class MediaAdapter implements MediaPlayer {
    AdvancedMediaPlayer advancedMusicPlayer;

    public MediaAdapter(String audioType) {
        if (audioType.equalsIgnoreCase("vlc")) {
            advancedMusicPlayer = new VlcPlayer();
        } else if (audioType.equalsIgnoreCase("mp4")) {
            advancedMusicPlayer = new Mp4Player();
        }
    }

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("vlc")) {
            advancedMusicPlayer.playVlc(fileName);
        } else if (audioType.equalsIgnoreCase("mp4")) {
            advancedMusicPlayer.playMp4(fileName);
        }
    }
}

class AudioPlayerAdapter implements MediaPlayer {
    MediaAdapter mediaAdapter;

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing mp3 file. Name: " + fileName);
        } else if (audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")) {
            mediaAdapter = new MediaAdapter(audioType);
            mediaAdapter.play(audioType, fileName);
        } else {
            System.out.println("Invalid media. " + audioType + " format not supported");
        }
    }
}

优点

• 解耦客户端与服务端接口。
• 增强代码的复用性。

缺点

• 增加代码复杂性。
• 可能导致过多的适配器类。

装饰者模式（Decorator Pattern）

装饰者模式通过将对象放入包含行为的特殊封装对象中来动态地扩展对象的功能。

interface Shape {
    void draw();
}

class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Shape: Rectangle");
    }
}

abstract class ShapeDecorator implements Shape {
    protected Shape decoratedShape;

    public ShapeDecorator(Shape decoratedShape) {
        this.decoratedShape = decoratedShape;
    }

    public void draw() {
        decoratedShape.draw();
    }
}

class RedShapeDecorator extends ShapeDecorator {

    public RedShapeDecorator(Shape decoratedShape) {
        super(decoratedShape);
    }

    @Override
    public void draw() {
        decoratedShape.draw();
        setRedBorder(decoratedShape);
    }

    private void setRedBorder(Shape decoratedShape) {
        System.out.println("Border Color: Red");
    }
}

public class DecoratorPatternDemo {
    public static void main(String[] args) {
        Shape rectangle = new Rectangle();

        Shape redRectangle = new RedShapeDecorator(new Rectangle());

        System.out.println("Rectangle with normal border");
        rectangle.draw();

        System.out.println("\nRectangle with red border");
        redRectangle.draw();
    }
}

优点

• 动态扩展对象功能。
• 避免使用继承扩展类功能。

缺点

• 增加了许多小对象，复杂度提高。
• 不容易调试。

行为型模式

策略模式（Strategy Pattern）

策略模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。策略模式让算法独立于使用它的客户端。

interface Strategy {
    int doOperation(int num1, int num2);
}

class OperationAdd implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

class OperationSubtract implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}

class OperationMultiply implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 * num2;
    }
}

class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context context = new Context(new OperationAdd());
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

        context = new Context(new OperationSubtract());
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

        context = new Context(new OperationMultiply());
        System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
    }
}

优点

• 算法可自由切换。
• 避免使用多重条件判断语句。
• 提高算法的扩展性。

缺点

• 客户端必须知道所有策略类，并自行决定使用哪一个策略类。
• 策略模式会增加系统中类的数量。

观察者模式（Observer Pattern）

观察者模式定义了对象间的一对多依赖关系，当一个对象改变状态时，其所有依赖者都会收到通知并自动更新。

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

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

    public int getState() {
        return state;
    }

    public void setState(int