Java 设计模式 按顺序执行

Java 设计模式 按顺序执行

设计模式是一种被广泛使用的软件开发技巧，它提供了一种解决常见问题的方式，同时也可以提高代码的可读性和可维护性。在 Java 开发中，有许多常见的设计模式可供选择，本文将按照一定的顺序介绍这些设计模式，并给出相应的代码示例。

1. 单例模式（Singleton Pattern）

单例模式是最简单且常用的设计模式之一。它确保一个类只有一个实例，并提供一个全局访问点。

public class Singleton {
    private static Singleton instance;

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

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

在上述代码中，通过将构造函数设为私有，外部无法直接实例化 Singleton 类，只能通过 getInstance() 方法获取单例对象。

2. 工厂模式（Factory Pattern）

工厂模式用于创建对象，而不需要暴露对象的创建逻辑。它提供一个共同的接口，用于创建不同类型的对象。

public interface Shape {
    void draw();
}

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

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

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

在上述代码中，Shape 接口定义了一个 draw() 方法，Circle 和 Rectangle 类实现了 Shape 接口。ShapeFactory 类根据不同的形状类型返回相应的对象。

3. 原型模式（Prototype Pattern）

原型模式用于创建对象的克隆，而不需要通过实例化来创建新的对象。

public 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;
    }

    @Override
    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

public class Circle extends Shape {
    public Circle() {
        type = "Circle";
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

public class Rectangle extends Shape {
    public Rectangle() {
        type = "Rectangle";
    }

    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class ShapeCache {
    private static Map<String, Shape> shapeMap = new HashMap<>();

    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);
    }
}

上述代码中，Shape 抽象类实现了 Cloneable 接口，并定义了一个抽象的 draw() 方法。Circle 和 Rectangle 类继承自 Shape 抽象类，并实现了 draw() 方法。ShapeCache 类用于缓存不同形状的对象，并提供 getShape() 方法用于获取对象的克隆。

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: " + fileName);
    }

    @Override