图解 java 设计模式（三）——彻底弄明白原型模式，建造者模式
1.1、前言
大家可以去 b 站观看韩老师的视频：b站韩老师视频链接
1.2、原型模式
1.2.1、克隆羊问题
现有一只羊 tom，姓名为 tom，年龄为 1，颜色为白色，请编写程序创建和 tom 属性完全相同的 5 只羊
1.2.2、传统方式解决克隆羊问题
1.2.2.1、思路分析
1.2.2.2、代码演示
package com.hjc.demo1.prototype;
public class Client {
public static void main(String[] args) {
System.err.println("===传统方式===");
Sheep sheep = new Sheep("tom", 1, "白色");
Sheep sheep1 = new Sheep("tom", 1, "白色");
Sheep sheep2 = new Sheep("tom", 1, "白色");
Sheep sheep3 = new Sheep("tom", 1, "白色");
Sheep sheep4 = new Sheep("tom", 1, "白色");
System.out.println(sheep);
System.out.println(sheep1);
System.out.println(sheep2);
System.out.println(sheep3);
System.out.println(sheep4);
}
}
package com.hjc.demo1.prototype;
public class Sheep {
private String name;
private int age;
private String color;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Sheep(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age=" + age +
", color='" + color + '\'' +
'}';
}
}
1.2.2.3、代码截图
1.2.2.4、传统方式的优缺点
-
优点是比较好理解，简单易操作
-
在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低
-
总是需要重新初始化对象，而不是动态地获得对象运行时的状态，不够灵活
-
改进的思路分析
思路：Java 中 Object 类是所有类的基类，Object 类提供了一个 clone()方法，该方法可以将一个 Java 对象复制一份，但是需要实现 clone 的 java 类必须实现一个Cloneable 接口，该接口表示该类能够复制且具有复制的能力 =》原型模式
1.2.3、原型模式
1.2.3.1、基本介绍
- 原型模式（Prototype 模式）是指：用 原型实例指向创建对象的种类，并且通过拷贝这些原型，创建新的对象
- 原型模式是一种创建型设计模式，允许一个对象再创建另一个可定制的对象，无需知道如何创建的细节
- 工作原理：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝他们自己来实施创建，即 对象.clone()
- 形象的理解：孙大圣拔出猴毛，变出其他大圣
1.2.3.2、原型模式类图
1.2.3.3、原型模式解决克隆羊的实例
1.2.3.3.1、代码演示
package com.hjc.demo1.prototype.improve;
public class Client {
public static void main(String[] args) {
System.err.println("===原型模式完成对象克隆===");
Sheep sheep = new Sheep("tom", 1, "白色");
Sheep sheep1 = (Sheep) sheep.clone();
Sheep sheep2 = (Sheep) sheep.clone();
Sheep sheep3 = (Sheep) sheep.clone();
Sheep sheep4 = (Sheep) sheep.clone();
Sheep sheep5 = (Sheep) sheep.clone();
System.out.println(sheep+"==hashCode:"+sheep.hashCode());
System.out.println(sheep1+"==hashCode:"+sheep1.hashCode());
System.out.println(sheep2+"==hashCode:"+sheep2.hashCode());
System.out.println(sheep3+"==hashCode:"+sheep3.hashCode());
System.out.println(sheep4+"==hashCode:"+sheep4.hashCode());
}
}
package com.hjc.demo1.prototype.improve;
public class Sheep implements Cloneable{
private String name;
private int age;
private String color;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Sheep(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age=" + age +
", color='" + color + '\'' +
'}';
}
//克隆该对象实例，使用默认的 clone 方法来完成
@Override
protected Object clone() {
Sheep sheep = null;
try {
sheep = (Sheep) super.clone();
}catch (Exception e){
System.out.println(e.getMessage());
}
return sheep;
}
}
1.2.3.3.2、代码截图
1.2.4、原型模式在 Spring 框架中源码分析
-
Spring 中原型bean 的创建，就是原型模式的应用
-
代码分析图
1.2.5、深入理解-浅拷贝与深拷贝
1.2.5.1、浅拷贝介绍
- 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象
- 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响另一个对象的该成员变量值
- 前面我们克隆羊就是浅拷贝
- 浅拷贝是使用默认的 clone()方法来实现
1.2.5.2、深拷贝基本介绍
- 复制对象的所有基本数据类型的成员变量值
- 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象（包括对象的引用类型进行拷贝）
- 深拷贝方式一：重写 clone方法来实现
- 深拷贝方式二：通过 对象序列化来实现深拷贝（推荐）
1.2.5.3、深拷贝应用实例
- 使用重写 clone 方法实现深拷贝
- 使用序列化来实现深拷贝
- 代码演示
1.2.5.3.1、代码演示
public class Client {
public static void main(String[] args) {
DeepProtoType p = new DeepProtoType();
p.name ="hjc";
p.deepCloneAbleTarget = new DeepCloneAbleTarget("大牛","小刘");
// //方式一：完成深拷贝
// DeepProtoType p2 = (DeepProtoType) p.clone();
// System.out.println("p.name="+p.name+"==p.deepCloneableTarget="+p.deepCloneAbleTarget.hashCode());
// System.out.println("p.name="+p2.name+"==p.deepCloneableTarget="+p2.deepCloneAbleTarget.hashCode());
//方式二：完成深拷贝
DeepProtoType p2 = (DeepProtoType) p.deepClone();
System.out.println("p.name="+p.name+"==p.deepCloneableTarget="+p.deepCloneAbleTarget.hashCode());
System.out.println("p.name="+p2.name+"==p.deepCloneableTarget="+p2.deepCloneAbleTarget.hashCode());
}
}
package com.hjc.demo1.prototype.deepclone;
import java.io.Serializable;
public class DeepCloneAbleTarget implements Serializable, Cloneable {
private static final long serialVersionUID = 1L;
private String cloneName;
private String cloneClass;
public DeepCloneAbleTarget(String cloneName, String cloneClass) {
this.cloneName = cloneName;
this.cloneClass = cloneClass;
}
//因为该类的属性，都是String，所以我们这里使用默认的 clone 完成即可
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
package com.hjc.demo1.prototype.deepclone;
import java.io.*;
public class DeepProtoType implements Serializable,Cloneable {
public String name;
public DeepCloneAbleTarget deepCloneAbleTarget; //对象
public DeepProtoType() {
super();
}
//深拷贝方式一：使用 clone 方法
@Override
protected Object clone() {
Object deep = null;
//这里完成基本数据类型（属性）克隆
try {
deep = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
//对引用类型的属性，进行单独处理
DeepProtoType deepProtoType = (DeepProtoType) deep;
try {
deepProtoType.deepCloneAbleTarget = (DeepCloneAbleTarget) deepCloneAbleTarget.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return deepProtoType;
}
//深拷贝方式二：通过对象序列化实现（推荐）
public Object deepClone(){
//创建流对象
ByteArrayOutputStream bos = null;
ObjectOutputStream oos =null;
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
try {
//序列化
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
//当前这个对象以对象流的方式输出
oos.writeObject(this);
//反序列化
bis = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bis);
DeepProtoType copyObj = (DeepProtoType) ois.readObject();
return copyObj;
}catch (Exception e){
e.getMessage();
return null;
}finally {
//关闭流
try {
bos.close();
oos.close();
bis.close();
ois.close();
}catch (Exception e2){
e2.getMessage();
}
}
}
}
1.2.5.3.2、代码截图
1.2.6、原型模式的注意事项
- 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能提高效率
- 不用重新初始化对象，而是 动态地获得对象运行时的状态
- 如果原始对象发生变化（增加或减少属性），其它克隆对象也会发生相应的变化，无需修改代码
- 在实现深拷贝的时候可能需要比较复杂的代码
- **缺点：**需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了 ocp 原则，这点需要注意
1.3、建造者模式
1.3.1、盖房项目需求
- 需要建房子：这一过程为打桩、砌墙、封顶
- 房子有各种各样的，比如普通房、高楼、别墅等
- 请编写程序，完成需求
1.3.2、传统方式解决盖房需求
1.3.2.1、思路分析
1.3.2.2、代码演示
package com.hjc.demo1.builder;
public class Client {
public static void main(String[] args) {
System.err.println("===传统方式===");
CommonHourse commonHourse = new CommonHourse();
commonHourse.build();
}
}
package com.hjc.demo1.builder;
public abstract class AbstractHourse {
//打地基
public abstract void builderBasic();
//砌墙
public abstract void buildWalls();
//封顶
public abstract void roofed();
public void build(){
builderBasic();
buildWalls();
roofed();
}
}
package com.hjc.demo1.builder;
public class CommonHourse extends AbstractHourse{
@Override
public void builderBasic() {
System.out.println("普通房子打地基");
}
@Override
public void buildWalls() {
System.out.println("普通房子砌墙");
}
@Override
public void roofed() {
System.out.println("普通房子建屋顶");
}
}
1.3.2.3、代码截图
1.3.2.4、传统方式的优缺点
- 优点是比较好理解，简单易操作
- 设计的结构过于简单，没有涉及缓冲层对象，程序的扩展性和维护性不好，也就是说，这种设计方案把产品（即房子）和创建产品的过程（即造房子）封装在一起，耦合性增强了
1.3.3、建造者模式
1.3.3.1、基本介绍
- 建造者模式（Builder Pattern）又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现的对象
- 建造者模式是一步一步创建一个复杂的对象，它允许用户只通过复杂对象的类型和内容就可以构建他们，用户不需要知道内部的具体构建细节。
1.3.3.2、建造者模式的四个角色
- Product（产品角色）：一个具体的产品对象
- Builder（抽象建造者）：创建一个使用 Builder 接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用。一是：隔离了客户与对象的生产过程，而是：负责控制产品对象的生产过程
1.3.3.3、建造者类图
1.3.3.4、建造者模式解决盖房需求
-
需要建房子：这一过程为打桩、砌墙、封顶。不管是普通房子也好，高楼也好都需要经历这些过程
-
思路分析图
1.3.3.4.1、代码演示
package com.hjc.demo1.builder.improve;
public class Client {
public static void main(String[] args) {
System.err.println("====建造者模式建房子====");
CommonHouse commonHouse = new CommonHouse();
HouseDirector houseDirector = new HouseDirector(commonHouse);
House house = houseDirector.constructHouse();
System.out.println("=======================");
HighBuilding highBuilding = new HighBuilding();
houseDirector.setHouseBuilder(highBuilding);
houseDirector.constructHouse();
}
}
package com.hjc.demo1.builder.improve;
public abstract class HouseBuilder {
protected House house = new House();
//打地基
public abstract void buildBasic();
//砌墙
public abstract void buildWalls();
//建屋顶
public abstract void roofed();
public House buildHouse(){
return house;
}
}
package com.hjc.demo1.builder.improve;
public class HighBuilding extends HouseBuilder{
@Override
public void buildBasic() {
System.out.println("高楼打地基");
}
@Override
public void buildWalls() {
System.out.println("高楼砌房子");
}
@Override
public void roofed() {
System.out.println("高楼建屋顶");
}
}
package com.hjc.demo1.builder.improve;
public class CommonHouse extends HouseBuilder{
@Override
public void buildBasic() {
System.out.println("普通房子打地基");
}
@Override
public void buildWalls() {
System.out.println("普通房子砌墙");
}
@Override
public void roofed() {
System.out.println("普通房子建屋顶");
}
}
package com.hjc.demo1.builder.improve;
public class House {
private String basie;
private String wall;
private String roofed;
public String getBasie() {
return basie;
}
public void setBasie(String basie) {
this.basie = basie;
}
public String getWall() {
return wall;
}
public void setWall(String wall) {
this.wall = wall;
}
public String getRoofed() {
return roofed;
}
public void setRoofed(String roofed) {
this.roofed = roofed;
}
@Override
public String toString() {
return "House{" +
"basie='" + basie + '\'' +
", wall='" + wall + '\'' +
", roofed='" + roofed + '\'' +
'}';
}
}
package com.hjc.demo1.builder.improve;
public class HouseDirector {
HouseBuilder houseBuilder = null;
public HouseDirector(HouseBuilder houseBuilder){
this.houseBuilder = houseBuilder;
}
public void setHouseBuilder(HouseBuilder houseBuilder){
this.houseBuilder =houseBuilder;
}
public House constructHouse(){
houseBuilder.buildBasic();
houseBuilder.buildWalls();
houseBuilder.roofed();
return houseBuilder.buildHouse();
}
}
1.3.3.4.2、代码截图
1.3.4、建造者模式在 jdk 的源码分析
-
java.lang.StringBuilder 中的建造者模式
-
源码分析
-
源码解读
- Appendable 接口定义了多个 append 方法（抽象方法），即 Appendable 为抽象者，定义了抽象方法
- AbstractStringBuilder 实现了 Appendable 接口方法，这里的 AbstractStringBuilder 已经是建造者，只是不能实例化
- StringBuilder 即充当了指挥者角色，同时充当了具体的建造者，建造方法的实现是由 AbstractStringBuilder 完成，而 StringBuilder 继承了 AbstractStringBuilder
1.3.5、建造者模式的注意事项
-
客户端(使用程序)不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
-
每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者， 用户使用不同的具体建造者即可得到不同的产品对象
-
可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰， 也更方便使用程序来控制创建过程
-
增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”
-
建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
-
如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，因此在这种情况下，要考虑是否选择建造者模式.
-
抽象工厂模式 VS 建造者模式
抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。而建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品
进入老胡写的 Java 设计模式四
1316
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
