在本文章开始之前先说明:
设计模式不是代码,是某类问题的通用解决放啊,本质是用来提高 软件的维护性、通用性、扩展性,并且降低软件的复杂度 。
进入正题:
单例模式
点击下面链接进入
设计模式——单例模式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、缺点
最后的总结
-
单例模式(Singleton Pattern):
- 单例模式确保一个类只有一个实例,并提供一个全局访问点。这对于需要共享资源的对象或控制对象的创建数量很有用。
-
工厂模式(Factory Pattern):
- 工厂模式通过使用工厂方法来创建对象,而无需指定将要创建的对象的具体类。这样可以根据特定条件或参数创建相应的对象实例。
-
原型模式(Prototype Pattern):
- 原型模式通过克隆(复制)现有对象来创建新对象。这种方式可以避免重复初始化成本高的对象,提高性能。
-
建造者模式(Builder Pattern):
- 建造者模式用于创建一个复杂对象,将其构建过程与表示分离,使得同样的构建过程可以创建不同的表示。通常在创建具有多个部分或配置选项的对象时使用。