Java魔法解密：揭秘七种设计模式的奇妙应用-阿里云开发者社区

1. 单例模式 (Singleton Pattern)

单例模式确保一个类只有一个实例，并提供一个全局访问点。这在需要限制某个类实例化多次时非常有用。

单例模式实现的核心思想是将类的构造方法设为私有，以防止其他类直接实例化该类。通过静态方法获取唯一的类实例。

例如，在Java中，我们可以使用双重检查锁定实现单例模式：

public class Singleton {
    private static Singleton instance;
    private Singleton() {}  // 将构造方法设为私有
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

2. 工厂模式 (Factory Pattern)

工厂模式通过一个工厂类创建其他类的对象，而无需指定具体的类。这样可以将实例化操作与客户端代码分离，使代码更加灵活和可扩展。

工厂模式包含一个工厂接口和多个实现该接口的工厂类。客户端代码通过工厂接口来获取对象实例。

例如，我们可以使用工厂模式创建不同形状的图形对象：

public interface Shape {
    void draw();
}
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle: draw()");
    }
}
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle: draw()");
    }
}
public class ShapeFactory {
    public Shape createShape(String shapeType) {
        if (shapeType.equalsIgnoreCase("circle")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("rectangle")) {
            return new Rectangle();
        }
        return null;
    }
}

3. 装饰器模式 (Decorator Pattern)

装饰器模式动态地给一个对象添加额外的功能。它是继承的一种替代方案。通过将对象包装在装饰器类中，我们可以在运行时更改对象的行为。

装饰器模式由被装饰的主体接口、主体类以及装饰器类组成。装饰器类实现主体接口，并持有一个主体类对象，在调用主体方法前后添加额外的功能。

举个例子，我们可以使用装饰器模式给图形对象添加边框：

public interface Shape {
    void draw();
}
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle: draw()");
    }
}
public abstract class ShapeDecorator implements Shape {
    protected Shape decoratedShape;
    public ShapeDecorator(Shape decoratedShape) {
        this.decoratedShape = decoratedShape;
    }
    public void draw() {
        decoratedShape.draw();
    }
}
public 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");
    }
}

4. 适配器模式 (Adapter Pattern)

适配器模式将一个类的接口转换成客户希望的另一个接口。它常用于旧代码和新代码的衔接，以便它们可以协同工作。

适配器模式由目标接口、适配器类以及待适配的类组成。适配器类实现目标接口，并持有一个待适配类对象，在调用目标方法时调用待适配类的对应方法。

例如，我们可以使用适配器模式使不同格式的音频播放器兼容统一的媒体播放器接口：

public interface MediaPlayer {
    void play(String audioType, String fileName);
}
public interface AdvancedMediaPlayer {
    void playVlc(String fileName);
    void playMp4(String fileName);
}
public class VlcPlayer implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file. Name: " + fileName);
    }
    @Override
    public void playMp4(String fileName) {
    }
}
public class Mp4Player implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
    }
    @Override
    public void playMp4(String fileName) {
        System.out.println("Playing mp4 file. Name: " + fileName);
    }
}
public 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);
        }
    }
}
public class AudioPlayer 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");
        }
    }
}

5. 观察者模式 (Observer Pattern)

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

观察者模式由主题接口、观察者接口以及具体的主题和观察者类组成。主题对象维护了观察者列表，并在状态变化时通知观察者。

举个例子，我们可以使用观察者模式实现发布-订阅系统：

import java.util.ArrayList;
import java.util.List;
public interface Observer {
    void update();
}
public class ConcreteObserver1 implements Observer {
    @Override
    public void update() {
        System.out.println("ConcreteObserver1: received notification");
    }
}
public class ConcreteObserver2 implements Observer {
    @Override
    public void update() {
        System.out.println("ConcreteObserver2: received notification");
    }
}
public interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}
public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

6. 策略模式 (Strategy Pattern)

策略模式定义了一系列的算法，并将它们封装在单独的类中，使得它们可以互相替换。这样可以在运行时更改对象的行为。

策略模式由策略接口、具体策略类和上下文类组成。上下文类持有一个策略对象，在执行某个操作时调用策略对象的方法。

举个例子，我们可以使用策略模式实现不同的数学运算：

public interface Strategy {
    int doOperation(int num1, int num2);
}
public class OperationAdd implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}
public class OperationSubtract implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}
public class Context {
    private Strategy strategy;
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

7. 模板方法模式 (Template Method Pattern)

模板方法模式定义了一个操作中的算法框架，而将一些步骤的实现延迟到子类中。它提供了一个固定的算法结构，可以在不改变算法结构的情况下重写其中的某些步骤。

模板方法模式由抽象类定义算法的结构和具体步骤，子类通过扩展抽象类并实现具体步骤来完成算法。

例如，我们可以使用模板方法模式实现咖啡和茶的冲泡过程：

public abstract class Beverage {
    public final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }
    public abstract void brew();
    public abstract void addCondiments();
    public void boilWater() {
        System.out.println("Boiling water");
    }
    public void pourInCup() {
        System.out.println("Pouring into cup");
    }
}
public class Coffee extends Beverage {
    @Override
    public void brew() {
        System.out.println("Dripping coffee through filter");
    }
    @Override
    public void addCondiments() {
        System.out.println("Adding sugar and milk");
    }
}
public class Tea extends Beverage {
    @Override
    public void brew() {
        System.out.println("Steeping the tea");
    }
    @Override
    public void addCondiments() {
        System.out.println("Adding lemon");
    }
}

以上就是对这七种常见的设计模式的详细描述。希望能对您有所帮助。如果您还有其他问题，请随时向我私信。

Java魔法解密：揭秘七种设计模式的奇妙应用

1. 单例模式 (Singleton Pattern)

2. 工厂模式 (Factory Pattern)

3. 装饰器模式 (Decorator Pattern)

4. 适配器模式 (Adapter Pattern)

5. 观察者模式 (Observer Pattern)

6. 策略模式 (Strategy Pattern)

7. 模板方法模式 (Template Method Pattern)

热门文章

最新文章

相关课程

相关电子书

相关实验场景