5种Java经典创建型模式详解

以下是使用标准的Markdown格式文本，详细讲解5种Java经典创建型模式的完整攻略：

5种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;
    }
}

在上述示例中，通过私有构造函数和静态方法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 createShape(String type) {
        if (type.equalsIgnoreCase(\"circle\")) {
            return new Circle();
        } else if (type.equalsIgnoreCase(\"rectangle\")) {
            return new Rectangle();
        }
        return null;
    }
}

在上述示例中，通过工厂类ShapeFactory的createShape()方法根据参数类型来创建不同的形状对象。

3. 抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式用于创建一组相关或依赖的对象，将对象的创建逻辑封装在抽象工厂类中。以下是一个示例：

public interface Shape {
    void draw();
}

public interface Color {
    void fill();
}

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

public class Red implements Color {
    @Override
    public void fill() {
        System.out.println(\"Filling with red color\");
    }
}

public interface AbstractFactory {
    Shape createShape();
    Color createColor();
}

public class ShapeFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }

    @Override
    public Color createColor() {
        return null;
    }
}

public class ColorFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return null;
    }

    @Override
    public Color createColor() {
        return new Red();
    }
}

在上述示例中，通过抽象工厂类AbstractFactory和具体工厂类ShapeFactory、ColorFactory来创建形状和颜色对象。

4. 建造者模式（Builder Pattern）

建造者模式用于创建复杂对象，将对象的构建过程分解为多个步骤，并提供一个指导者来控制构建过程。以下是一个示例：

public class Product {
    private String part1;
    private String part2;

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    public void show() {
        System.out.println(\"Part 1: \" + part1);
        System.out.println(\"Part 2: \" + part2);
    }
}

public interface Builder {
    void buildPart1();
    void buildPart2();
    Product getResult();
}

public class ConcreteBuilder implements Builder {
    private Product product;

    public ConcreteBuilder() {
        product = new Product();
    }

    @Override
    public void buildPart1() {
        product.setPart1(\"Part 1\");
    }

    @Override
    public void buildPart2() {
        product.setPart2(\"Part 2\");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

public class Director {
    public void construct(Builder builder) {
        builder.buildPart1();
        builder.buildPart2();
    }
}

在上述示例中，通过建造者接口Builder和具体建造者类ConcreteBuilder来构建产品对象，指导者类Director控制构建过程。

5. 原型模式（Prototype Pattern）

原型模式用于创建对象的克隆副本，通过复制现有对象的属性来创建新对象。以下是一个示例：

public abstract class Shape implements Cloneable {
    private String id;
    protected String type;

    public 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 id) {
        Shape cachedShape = shapeMap.get(id);
        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);
    }
}

在上述示例中，通过原型模式和clone()方法来创建形状对象的克隆副本。

以上是关于5种Java经典创建型模式的详细攻略。通过单例模式、工厂模式、抽象工厂模式、建造者模式和原型模式，我们可以灵活地创建和管理对象的创建过程。根据示例代码进行定制和优化，以满足您的具体需求。