JAVA最全设计模式（23种并附带示例）

一. 创建型模式：

定义： 创建型设计模式主要用于对象的创建过程，对对象的创建进行抽象，隐藏对象创建的具体逻辑。

‌1. 工厂方法模式‌：

定义一个用于创建对象的接口，但让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

// 产品接口

interface Shape {

   void draw();

}

​

// 具体产品类

class Circle implements Shape {

   @Override

   public void draw() {

       System.out.println("Drawing a circle");

   }

}

​

class Rectangle implements Shape {

   @Override

   public void draw() {

       System.out.println("Drawing a rectangle");

   }

}

​

// 工厂类

class ShapeFactory {

   public Shape getShape(String shapeType) {

       if (shapeType == null) {

           return null;

       }

       if (shapeType.equalsIgnoreCase("CIRCLE")) {

           return new Circle();

       } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {

           return new Rectangle();

       }

       return null;

   }

}

2‌.抽象工厂模式‌：

提供一个接口，用于创建相关或依赖对象的家族，而无需明确指定具体类。

// 抽象产品接口
interface Color {
    void fill();
}
​
interface Shape {
    void draw();
}
​
// 具体产品类
class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with red color");
    }
}
​
class Green implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with green color");
    }
}
​
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}
​
class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}
​
// 抽象工厂接口
interface AbstractFactory {
    Color getColor(String color);
    Shape getShape(String shape);
}
​
// 具体工厂类
class ShapeFactory implements AbstractFactory {
    @Override
    public Color getColor(String color) {
        return null;
    }
​
    @Override
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}
​
class ColorFactory implements AbstractFactory {
    @Override
    public Color getColor(String color) {
        if (color == null) {
            return null;
        }
        if (color.equalsIgnoreCase("RED")) {
            return new Red();
        } else if (color.equalsIgnoreCase("GREEN")) {
            return new Green();
        }
        return null;
    }
​
    @Override
    public Shape getShape(String shape) {
        return null;
    }
}
​
// 工厂创造器
class FactoryProducer {
    public static AbstractFactory getFactory(String choice) {
        if (choice.equalsIgnoreCase("SHAPE")) {
            return new ShapeFactory();
        } else if (choice.equalsIgnoreCase("COLOR")) {
            return new ColorFactory();
        }
        return null;
    }
}

3‌. 单例模式‌：

确保一个类只有一个实例，并提供一个全局访问点。

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

4‌. 建造者模式‌：

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

// 产品类
class Meal {
    private String burger;
    private String drink;
​
    public void setBurger(String burger) {
        this.burger = burger;
    }
​
    public void setDrink(String drink) {
        this.drink = drink;
    }
​
    @Override
    public String toString() {
        return "Burger: " + burger + ", Drink: " + drink;
    }
}
​
// 建造者接口
interface MealBuilder {
    void buildBurger();
    void buildDrink();
    Meal getMeal();
}
​
// 具体建造者类
class VegMealBuilder implements MealBuilder {
    private Meal meal;
​
    public VegMealBuilder() {
        this.meal = new Meal();
    }
​
    @Override
    public void buildBurger() {
        meal.setBurger("Veg Burger");
    }
​
    @Override
    public void buildDrink() {
        meal.setDrink("Coke");
    }
​
    @Override
    public Meal getMeal() {
        return meal;
    }
}
​
// 指挥者类
class MealDirector {
    private MealBuilder mealBuilder;
​
    public MealDirector(MealBuilder mealBuilder) {
        this.mealBuilder = mealBuilder;
    }
​
    public Meal constructMeal() {
        mealBuilder.buildBurger();
        mealBuilder.buildDrink();
        return mealBuilder.getMeal();
    }
}

‌5. 原型模式‌：

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

import java.util.Hashtable;
​
// 抽象原型类
abstract class Shape implements Cloneable {
    private String id;
    protected String type;
​
    abstract void draw();
​
    public String getType() {
        return type;
    }
​
    public String getId() {
        return id;
    }
​
    public void setId(String id) {
        this.id = id;
    }
​
    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}
​
// 具体原型类
class Circle extends Shape {
    public Circle() {
        type = "Circle";
    }
​
    @Override
    void draw() {
        System.out.println("Drawing a circle");
    }
}
​
class Rectangle extends Shape {
    public Rectangle() {
        type = "Rectangle";
    }
​
    @Override
    void draw() {
        System.out.println("Drawing a rectangle");
    }
}
​
// 原型管理器
class ShapeCache {
    private static Hashtable shapeMap = new Hashtable();
​
    public static Shape getShape(String shapeId) {
        Shape cachedShape = shapeMap.get(shapeId);
        return (Shape) cachedShape.clone();
    }
​
    public static void loadCache() {
        Circle circle = new Circle();
        circle.setId("1");
        shapeMap.put(circle.getId(), circle);
​
        Rectangle rectangle = new Rectangle();
        rectangle.setId("2");
        shapeMap.put(rectangle.getId(), rectangle);
    }
}

二. 结构型模式：

定义：结构型设计模式主要用于处理类或对象的组合，通过组合类或对象形成更大的结构。

‌1. 适配器模式‌：

将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。

// 目标接口
interface MediaPlayer {
    void play(String audioType, String 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 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");
        }
    }
}

‌2.装饰器模式‌：

动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式比生成子类更为灵活。

// 组件接口
interface Shape {
    void draw();
}
​
// 具体组件类
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Shape: Circle");
    }
}
​
// 抽象装饰器类
abstract class ShapeDecorator implements Shape {
    protected Shape decoratedShape;
​
    public ShapeDecorator(Shape decoratedShape) {
        this.decoratedShape = decoratedShape;
    }
​
    @Override
    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");
    }
}

‌3.代理模式‌：

为其他对象提供一个代理或占位符，以控制对这个对象的访问。

// 接口
interface Image {
    void display();
}
​
// 真实主题类
class RealImage implements Image {
    private String fileName;
​
    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk(fileName);
    }
​
    @Override
    public void display() {
        System.out.println("Displaying " + fileName);
    }
​
    private void loadFromDisk(String fileName) {
        System.out.println("Loading " + fileName);
    }
}
​
// 代理类
class ProxyImage implements Image {
    private RealImage realImage;
    private String fileName;
​
    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }
​
    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}

4‌. 外观模式‌：

为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

// 子系统类
class Rectangle {
    public void draw() {
        System.out.println("Rectangle::draw()");
    }
}
​
class Square {
    public void draw() {
        System.out.println("Square::draw()");
    }
}
​
class Circle {
    public void draw() {
        System.out.println("Circle::draw()");
    }
}
​
// 外观类
class ShapeMaker {
    private Circle circle;
    private Rectangle rectangle;
    private Square square;
​
    public ShapeMaker() {
        circle = new Circle();
        rectangle = new Rectangle();
        square = new Square();
    }
​
    public void drawCircle() {
        circle.draw();
    }
​
    public void drawRectangle() {
        rectangle.draw();
    }
​
    public void drawSquare() {
        square.draw();
    }
}

‌5. 桥接模式‌：

将抽象部分与它的实现部分分离，使它们都可以独立地变化。

// 实现化角色
interface Color {
    void applyColor();
}
​
// 具体实现化角色
class RedColor implements Color {
    @Override
    public void applyColor() {
        System.out.println("Applying red color");
    }
}
​
class GreenColor implements Color {
    @Override
    public void applyColor() {
        System.out.println("Applying green color");
    }
}
​
// 抽象化角色
abstract class Shape {
    protected Color color;
​
    public Shape(Color color) {
        this.color = color;
    }
​
    abstract void draw();
}
​
// 扩展抽象化角色
class Circle extends Shape {
    public Circle(Color color) {
        super(color);
    }
​
    @Override
    void draw() {
        System.out.print("Drawing a circle. ");
        color.applyColor();
    }
}
​
class Rectangle extends Shape {
    public Rectangle(Color color) {
        super(color);
    }
​
    @Override
    void draw() {
        System.out.print("Drawing a rectangle. ");
        color.applyColor();
    }
}

‌6. 组合模式‌：

将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。

import java.util.ArrayList;
import java.util.List;
​
// 组件类
abstract class Employee {
    protected String name;
    protected int salary;
​
    public Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }
​
    public abstract void add(Employee e);
​
    public abstract void remove(Employee e);
​
    public abstract void print();
}
​
// 树叶类
class Developer extends Employee {
    public Developer(String name, int salary) {
        super(name, salary);
    }
​
    @Override
    public void add(Employee e) {
        // 树叶节点不能添加子节点
    }
​
    @Override
    public void remove(Employee e) {
        // 树叶节点不能移除子节点
    }
​
    @Override
    public void print() {
        System.out.println("

‌7. 享元模式‌：

运用共享技术有效地支持大量细粒度的对象。

import java.util.HashMap;
​
// 享元接口
interface Shape {
    void draw();
}
​
// 具体享元类
class Circle implements Shape {
    private String color;
    private int x;
    private int y;
    private int radius;
​
    public Circle(String color) {
        this.color = color;
    }
​
    public void setX(int x) {
        this.x = x;
    }
​
    public void setY(int y) {
        this.y = y;
    }
​
    public void setRadius(int radius) {
        this.radius = radius;
    }
​
    @Override
    public void draw() {
        System.out.println("Circle: Draw() [Color : " + color + ", x : " + x + ", y :" + y + ", radius :" + radius);
    }
}
​
// 享元工厂类
class ShapeFactory {
    private static final HashMap circleMap = new HashMap();
​
    public static Shape getCircle(String color) {
        Circle circle = (Circle) circleMap.get(color);
​
        if (circle == null) {
            circle = new Circle(color);
            circleMap.put(color, circle);
            System.out.println("Creating circle of color : " + color);
        }
        return circle;
    }
}

三. 行为型模式：

定义： 行为型设计模式主要用于处理对象之间的交互和职责分配，帮助对象之间更有效地通信和协作，从而实现更灵活、可维护的软件设计

1. 策略模式‌：

定义一系列的算法，把它们一个个封装起来，并且使它们可互相替换。此模式让算法的变化独立于使用算法的客户。

// 策略接口
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 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));
    }
}

2‌. 模板方法模式‌：

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

// 抽象类，定义模板方法和基本方法
abstract class Game {
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();
​
    // 模板方法
    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }
}
​
// 具体子类 - 足球游戏
class Football extends Game {
    @Override
    void initialize() {
        System.out.println("Football Game Initialized! Start playing.");
    }
​
    @Override
    void startPlay() {
        System.out.println("Football Game Started. Enjoy the game!");
    }
​
    @Override
    void endPlay() {
        System.out.println("Football Game Finished!");
    }
}
​
// 具体子类 - 篮球游戏
class Basketball extends Game {
    @Override
    void initialize() {
        System.out.println("Basketball Game Initialized! Start playing.");
    }
​
    @Override
    void startPlay() {
        System.out.println("Basketball Game Started. Enjoy the game!");
    }
​
    @Override
    void endPlay() {
        System.out.println("Basketball Game Finished!");
    }
}
​
// 测试代码
public class TemplatePatternDemo {
    public static void main(String[] args) {
        Game footballGame = new Football();
        footballGame.play();
​
        System.out.println();
​
        Game basketballGame = new Basketball();
        basketballGame.play();
    }
}

‌3. 观察者模式‌：

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

import java.util.ArrayList;
import java.util.List;
​
// 主题接口
interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}
​
// 观察者接口
interface Observer {
    void update(int state);
}
​
// 具体主题类
class ConcreteSubject implements Subject {
    private List observers = new ArrayList();
    private int state;
​
    public int getState() {
        return state;
    }
​
    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }
​
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }
​
    @Override
    public void removeObserver(Observer o) {
        observers.remove(o);
    }
​
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }
}
​
// 具体观察者类
class ConcreteObserver implements Observer {
    private int observerState;
​
    @Override
    public void update(int state) {
        observerState = state;
        System.out.println("Observer state updated to: " + observerState);
    }
}
​
// 测试代码
public class ObserverPatternDemo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        ConcreteObserver observer1 = new ConcreteObserver();
        ConcreteObserver observer2 = new ConcreteObserver();
​
        subject.registerObserver(observer1);
        subject.registerObserver(observer2);
​
        subject.setState(10);
    }
}

‌4. 迭代器模式‌：

提供一种方法顺序访问一个聚合对象中的各个元素，而又不需暴露该对象的内部表示。

// 迭代器接口
interface Iterator {
    boolean hasNext();
    Object next();
}
​
// 聚合接口
interface Container {
    Iterator getIterator();
}
​
// 具体聚合类
class NameRepository implements Container {
    public String[] names = {"Robert", "John", "Julie", "Lora"};
​
    @Override
    public Iterator getIterator() {
        return new NameIterator();
    }
​
    private class NameIterator implements Iterator {
        int index;
​
        @Override
        public boolean hasNext() {
            return index  
 
‌5. 责任链模式‌：
 
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
 
// 抽象处理者类
abstract class AbstractLogger {
    public static final int INFO = 1;
    public static final int DEBUG = 2;
    public static final int ERROR = 3;
​
    protected int level;
​
    // 责任链中的下一个元素
    protected AbstractLogger nextLogger;
​
    public void setNextLogger(AbstractLogger nextLogger) {
        this.nextLogger = nextLogger;
    }
​
    public void logMessage(int level, String message) {
        if (this.level