0
点赞
收藏
分享

微信扫一扫

创建型设计模式合集

非衣所思 03-05 17:30 阅读 4

在本文章开始之前先说明:

设计模式不是代码,是某类问题的通用解决放啊,本质是用来提高 软件的维护性、通用性、扩展性,并且降低软件的复杂度 。

进入正题:

单例模式

点击下面链接进入

设计模式——单例模式8种实现-CSDN博客

工厂模式

设计模式——三大工厂模式-CSDN博客

原型模式

介绍

原型模式中的浅拷贝和深拷贝

代码示例

1、浅拷贝实例

如下实例,Sheep类通过集成Cloneable接口,实现直接浅拷贝功能(克隆)。

// 创建一个实现 Cloneable 接口的原型类
class Sheep implements Cloneable {
    private String name;

    public Sheep(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // 重写 clone 方法实现深拷贝
    @Override
    public Sheep clone() {
        try {
            return (Sheep) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

public class PrototypePatternExample {
    public static void main(String[] args) {
        Sheep originalSheep = new Sheep("Dolly");

        // 使用原型对象的 clone 方法复制一个新对象
        Sheep clonedSheep = originalSheep.clone();

        System.out.println("Original sheep: " + originalSheep.getName());
        System.out.println("Cloned sheep: " + clonedSheep.getName());
    }
}

 2、深拷贝实例

(下面只是一种实现深拷贝的方式,还有一种可以使用序列化实现深克隆)

下面使用对clone方法进行重写,实现深拷贝对象功能。

// 创建一个包含引用类型成员变量的原型类
class Person implements Cloneable {
    private String name;
    private Address address;

    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public Address getAddress() {
        return address;
    }

    @Override
    public Person clone() {
        try {
            Person clonedPerson = (Person) super.clone();
            // 对引用类型成员变量进行深拷贝
            clonedPerson.address = this.address.clone();
            return clonedPerson;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

// 创建包含引用类型成员变量的另一个类
class Address implements Cloneable {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    public String getCity() {
        return city;
    }

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

public class DeepCopyExample {
    public static void main(String[] args) {
        Address originalAddress = new Address("Beijing");
        Person originalPerson = new Person("Alice", originalAddress);

        // 使用原型对象的 clone 方法进行深拷贝
        Person clonedPerson = originalPerson.clone();

        // 修改原始对象的地址
        originalAddress.setCity("Shanghai");

        // 输出克隆对象的地址,验证是否进行了深拷贝
        System.out.println("Original person's address: " + originalPerson.getAddress().getCity());
        System.out.println("Cloned person's address: " + clonedPerson.getAddress().getCity());
    }
}

小结和补充

优点


缺点

补充

建造者模式

介绍

为什么会有建造者模式

(可以说建造者模式的目的)

建造者模式的4个角色

实例

下面是一个Car的产品角色,CarBuilder就是车的各个部件(接口类),通过ConcreteCarBuilder 继承CarBuilder接口实现具体部件从而的得到车。可以在测试类(Director)中构建实现这个车

抽象建造者

public interface CarBuilder {
    void buildBody();
    void buildEngine();
    void buildTires();
    Car getCar();
}

 具体建造者

public class ConcreteCarBuilder implements CarBuilder {
    private Car car;

    public ConcreteCarBuilder() {
        this.car = new Car();
    }

    @Override
    public void buildBody() {
        car.setBody("Sedan");
    }

    @Override
    public void buildEngine() {
        car.setEngine("V6");
    }

    @Override
    public void buildTires() {
        car.setTires("All-Season");
    }

    @Override
    public Car getCar() {
        return car;
    }
}

产品

public class Car {
    private String body;
    private String engine;
    private String tires;

    public void setBody(String body) {
        this.body = body;
    }

    public void setEngine(String engine) {
        this.engine = engine;
    }

    public void setTires(String tires) {
        this.tires = tires;
    }

    public void showInfo() {
        System.out.println("Car: " + body + ", " + engine + ", " + tires);
    }
}

指挥者

public class CarBuilderExample {
    public static void main(String[] args) {
        CarBuilder carBuilder = new ConcreteCarBuilder();

        // 构建汽车对象
        carBuilder.buildBody();
        carBuilder.buildEngine();
        carBuilder.buildTires();

        // 获取构建完成的汽车对象
        Car car = carBuilder.getCar();

        // 展示汽车信息
        car.showInfo();
    }
}

建造者模式在JDK中使用

  • StringBuilder

1、Appendable接口定义了多个append方法(抽象方法),即Appendable为抽象建造者定义了抽象方法

2、AbstractStringBuilder 已经是建造者,只是不能实例化

3、StringBuilder 即充当了指挥者,也充当了具体的建造者。建造方法的实现是由AbstractStringBuilder 完成,而StringBuilder继承了AbstractStringBuilder。

小结

优点

2、缺点

最后的总结

  1. 单例模式(Singleton Pattern)

    • 单例模式确保一个类只有一个实例,并提供一个全局访问点。这对于需要共享资源的对象或控制对象的创建数量很有用。
  2. 工厂模式(Factory Pattern)

    • 工厂模式通过使用工厂方法来创建对象,而无需指定将要创建的对象的具体类。这样可以根据特定条件或参数创建相应的对象实例。
  3. 原型模式(Prototype Pattern)

    • 原型模式通过克隆(复制)现有对象来创建新对象。这种方式可以避免重复初始化成本高的对象,提高性能。
  4. 建造者模式(Builder Pattern)

    • 建造者模式用于创建一个复杂对象,将其构建过程与表示分离,使得同样的构建过程可以创建不同的表示。通常在创建具有多个部分或配置选项的对象时使用。
举报

相关推荐

0 条评论