Java 23种设计模式详解，打开面向对象设计之门

后端

2023-03-20 15:34:21

设计模式：面向对象编程中的强大工具

导言

在软件工程领域，面向对象设计（OOP）是一种至关重要的理念，它帮助我们组织和管理代码，使其更易于理解和维护。设计模式是在 OOP 中广泛应用的解决方案，它们提供了应对常见设计挑战的有效方法。

设计模式概述

Java 语言中有 23 种常用的设计模式，它们分为三大类：

创建型模式： 控制对象创建。
结构型模式： 组织和组合对象。
行为型模式： 定义对象之间的交互。

创建型模式

工厂方法模式： 创建不同类型对象的通用接口，而无需指定具体的类。
抽象工厂模式： 创建一系列相关对象的通用接口，而无需指定具体的类。
建造者模式： 分离对象的创建和表示，允许以不同的方式组装和配置对象。
单例模式： 确保一个类只有一个实例，控制对象创建。
原型模式： 通过复制现有对象来创建新对象，无需指定具体的类。

代码示例：工厂方法模式

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.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }
        return null;
    }
}

public class Client {
    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();
        Shape circle = shapeFactory.getShape("CIRCLE");
        circle.draw();
        Shape square = shapeFactory.getShape("SQUARE");
        square.draw();
    }
}

结构型模式

适配器模式： 将一个接口转换成另一个接口，使不兼容的类能够协同工作。
桥接模式： 将一个类的实现和它的接口解耦，提高可扩展性。
组合模式： 将对象组织成树状结构，使我们可以统一操作整个结构。
装饰器模式： 动态地为对象添加额外的功能，而无需改变原有对象。
外观模式： 为复杂系统提供一个简化的接口，方便客户端使用。
享元模式： 通过共享相似的对象实例来减少内存消耗。
代理模式： 为对象提供代理或占位符，控制对对象的访问。

代码示例：适配器模式

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: " + fileName);
        } else if (audioType.equalsIgnoreCase("WAV")) {
            System.out.println("Playing WAV file: " + fileName);
        } else {
            System.out.println("Unsupported audio format: " + audioType);
        }
    }
}

class MediaAdapter implements MediaPlayer {
    private AdvancedMediaPlayer advancedMediaPlayer;

    public MediaAdapter(String audioType) {
        if (audioType.equalsIgnoreCase("VLC")) {
            advancedMediaPlayer = new VlcPlayer();
        } else if (audioType.equalsIgnoreCase("MP4")) {
            advancedMediaPlayer = new Mp4Player();
        }
    }

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("VLC")) {
            advancedMediaPlayer.playVlc(fileName);
        } else if (audioType.equalsIgnoreCase("MP4")) {
            advancedMediaPlayer.playMp4(fileName);
        } else {
            System.out.println("Unsupported audio format: " + audioType);
        }
    }
}

public class Client {
    public static void main(String[] args) {
        AudioPlayer audioPlayer = new AudioPlayer();
        audioPlayer.play("MP3", "filename.mp3");
        audioPlayer.play("WAV", "filename.wav");

        MediaAdapter mediaAdapter = new MediaAdapter("VLC");
        mediaAdapter.play("VLC", "filename.vlc");
        mediaAdapter = new MediaAdapter("MP4");
        mediaAdapter.play("MP4", "filename.mp4");
    }
}

行为型模式

命令模式： 将请求封装成对象，允许异步请求或请求队列。
策略模式： 封装算法或行为，允许动态切换策略。
观察者模式： 定义对象之间的依赖关系，当一个对象的状态发生改变时通知依赖对象。
迭代器模式： 提供遍历集合元素的标准方式，而无需暴露集合的内部结构。
访问者模式： 允许外部对象对集合元素执行操作，而无需改变集合本身。
责任链模式： 将请求处理责任链化，允许多个对象逐一处理请求。
模板方法模式： 定义算法的骨架，允许子类重新定义某些步骤。
解释器模式： 将一个语言的语法和语义封装成对象，允许解释和执行该语言的程序。
中介者模式： 将多个对象之间的交互集中到一个对象中，简化对象之间的通信。
状态模式： 根据对象的当前状态改变其行为。

代码示例：命令模式

interface Command {
    void execute();
}

class LightOnCommand implements Command {
    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOn();
    }
}

class LightOffCommand implements Command {
    private Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOff();
    }
}

class SimpleRemoteControl {
    private Command slot;

    public SimpleRemoteControl() {
    }

    public void setCommand(Command command) {
        this.slot = command;
    }

    public void buttonWasPressed() {
        slot.execute();
    }
}

public class Client {
    public static void main(String[] args) {
        SimpleRemoteControl remote = new SimpleRemoteControl();
        Light light = new Light();
        LightOnCommand lightOnCommand = new LightOnCommand(light);
        LightOffCommand lightOffCommand = new LightOffCommand(light);

        remote.setCommand(lightOnCommand);
        remote.buttonWasPressed();
        remote.setCommand(lightOffCommand);
        remote.buttonWasPressed();
    }
}