public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
            if (singleton == null) {  
                singleton = new Singleton();  
            }  
        }  
    }  
    return singleton;  
    }  
}

public interface Shape {
   void draw();
}
////////////////////////////////
public class Rectangle implements Shape {
   @Override
   public void draw() {
      System.out.println();
   }
}
//////////////
public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if ...
      return null;
   }
}

//定义抽象工厂

public interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

// 接着，定义 Button 和 Checkbox 接口：

public interface Button {
    void paint();
}

public interface Checkbox {
    void paint();
}

// 然后，实现具体的工厂类 WinFactory 和 MacFactory：

public class WinFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WinButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new WinCheckbox();
    }
}

public class MacFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacButton();
    }

    @Override
    public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
}

// 定义具体产品类 WinButton, WinCheckbox, MacButton, 和 MacCheckbox：

public class WinButton implements Button {
    @Override
    public void paint() {
        System.out.println("Rendering a button in Windows style.");
    }
}

public class MacButton implements Button {
    @Override
    public void paint() {
        System.out.println("Rendering a button in macOS style.");
    }
}

public class WinCheckbox implements Checkbox {
    @Override
    public void paint() {
        System.out.println("Rendering a checkbox in Windows style.");
    }
}

public class MacCheckbox implements Checkbox {
    @Override
    public void paint() {
        System.out.println("Rendering a checkbox in macOS style.");
    }
}

// 最后，实现客户端代码 Application 和 ApplicationConfigurator：

public class Application {
    private GUIFactory factory;
    private Button button;

    public Application(GUIFactory factory) {
        this.factory = factory;
    }

    public void createUI() {
        this.button = factory.createButton();
    }

    public void paint() {
        button.paint();
    }
}

public class ApplicationConfigurator {
    public static void main(String[] args) {
        GUIFactory factory;
        String OS = System.getProperty("os.name");
        
        if (OS.contains("Windows")) {
            factory = new WinFactory();
        } else if (OS.contains("Mac")) {
            factory = new MacFactory();
        } else {
            throw new RuntimeException("Error! Unknown operating system.");
        }

        Application app = new Application(factory);
        app.createUI();
        app.paint();
    }
}

public class Car {
    // 假设这里有一些属性和方法来表示汽车的各种特性
}

public class Manual {
    // 假设这里有一些属性和方法来表示手册的各种特性
}

// 接下来是 `Builder` 接口的定义，包括创建产品对象不同部件的方法：

public interface Builder {
    void reset();
    void setSeats(int number);
    void setEngine(String engine);
    void setTripComputer(boolean present);
    void setGPS(boolean present);
}

// 然后，我们实现具体的生成器类 `CarBuilder` 和 `CarManualBuilder`：

public class CarBuilder implements Builder {
    private Car car;

    public CarBuilder() {
        this.reset();
    }

    @Override
    public void reset() {
        this.car = new Car();
    }

    @Override
    public void setSeats(int number) {
        // 实现设置座位数的逻辑
    }

    @Override
    public void setEngine(String engine) {
        // 实现设置引擎的逻辑
    }

    @Override
    public void setTripComputer(boolean present) {
        // 实现设置行车电脑的逻辑
    }

    @Override
    public void setGPS(boolean present) {
        // 实现设置GPS的逻辑
    }

    public Car getProduct() {
        Car product = this.car;
        this.reset();
        return product;
    }
}

public class CarManualBuilder implements Builder {
    private Manual manual;

    public CarManualBuilder() {
        this.reset();
    }

    @Override
    public void reset() {
        this.manual = new Manual();
    }

    @Override
    public void setSeats(int number) {
        // 实现添加关于座椅的文档逻辑
    }

    @Override
    public void setEngine(String engine) {
        // 实现添加关于引擎的介绍逻辑
    }

    @Override
    public void setTripComputer(boolean present) {
        // 实现添加关于行车电脑的介绍逻辑
    }

    @Override
    public void setGPS(boolean present) {
        // 实现添加关于GPS的介绍逻辑
    }

    public Manual getProduct() {
        Manual product = this.manual;
        this.reset();
        return product;
    }
}

// 接着，实现 `Director` 类，它负责定义构建过程的不同步骤：

public class Director {
    public void constructSportsCar(Builder builder) {
        builder.reset();
        builder.setSeats(2);
        builder.setEngine("SportEngine");
        builder.setTripComputer(true);
        builder.setGPS(true);
    }

    // 这里可以添加更多的方法来构建不同类型的汽车
}

// 最后是客户端代码，它演示了如何使用这些类来构建产品：

public class Application {
    public static void main(String[] args) {
        Director director = new Director();

        CarBuilder carBuilder = new CarBuilder();
        director.constructSportsCar(carBuilder);
        Car car = carBuilder.getProduct();

        CarManualBuilder manualBuilder = new CarManualBuilder();
        director.constructSportsCar(manualBuilder);
        Manual manual = manualBuilder.getProduct();

        // 在这里，car 和 manual 是根据相同的构建过程创建的，
        // 但它们是完全不同的产品。
    }
}

import java.util.HashMap;
import java.util.Map;

// 抽象类实现 Cloneable 接口
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 Rectangle extends Shape {
    public Rectangle() {
        type = "Rectangle";
    }

    @Override
    void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

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

    @Override
    void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

// 缓存类
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);
    }
}

// 客户端代码
public class PrototypePatternDemo {
    public static void main(String[] args) {
        ShapeCache.loadCache();

        Shape clonedShape1 = ShapeCache.getShape("1");
        System.out.println("Shape : " + clonedShape1.getType());

        Shape clonedShape2 = ShapeCache.getShape("2");
        System.out.println("Shape : " + clonedShape2.getType());
    }
}