原型模式
- 原型模式：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的对象；
- 原型模式的角色：
- 抽象原型类：规定了具体原型对象必须实现的clone()方法；
- 具体原型类：实现抽象原型类的clone()方法，它是可以被复制的对象；
- UML类图如下：
image.png
- 原型模式的克隆分为浅克隆与深克隆：
- 浅克隆：创建一个新对象，新对象的属性与原来对象完全相同，
- 深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址；
- 在Java中的Object类中提供了clone()方法来实现克隆，Cloneable接口就是抽象原型类，而实现了Cloneable接口的子类就是具体原型类；
- 代码实现如下：
import androidx.annotation.NonNull;
public class Realizetype implements Cloneable{
public Realizetype() {
System.out.println("具体原型对象查创建成功");
}
@NonNull
@Override
public Realizetype clone() throws CloneNotSupportedException {
System.out.println("具体原型对象复制成功");
return (Realizetype) super.clone();
}
}
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import com.example.sign.prototype.Realizetype;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Realizetype realizetype = new Realizetype();
try {
Realizetype clone = realizetype.clone();
System.out.println("原型与克隆是否是同一个对象" + (realizetype == clone));
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
- 案例：三好学生的奖状，同一学校三好学生的奖状除了获奖人姓名不同，其他都相同，可以使用原型模式复制多个三好学生奖状，然后再修改奖状上的名字即可，UML类图如下：
image.png
- 代码实现如下：
import androidx.annotation.NonNull;
public class Citation implements Cloneable{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show() {
System.out.println(name + "同学: 在2021年12月1日 获取三号学生，特发此状");
}
@NonNull
@Override
public Citation clone() throws CloneNotSupportedException {
return (Citation) super.clone();
}
}
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import com.example.sign.prototype.Citation;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Citation citation = new Citation();
try {
Citation c1 = citation.clone();
c1.setName("张三");
citation.setName("李四");
citation.show();
c1.show();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
- 使用场景：
- 对象创建非常复杂，可使用原型模式快捷创建对象；
- 性能和安全要求比较高的；
扩展(深克隆)
- 将三好学生奖状类
Citation的name 属性 修改为Student 类型的属性，代码如下：
public class Student {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
import androidx.annotation.NonNull;
public class Citation implements Cloneable{
private Student student;
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public void show() {
System.out.println(student.getName() + "同学: 在2021年12月1日 获取三号学生，特发此状");
}
@NonNull
@Override
public Citation clone() throws CloneNotSupportedException {
return (Citation) super.clone();
}
}
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import com.example.sign.prototype.Citation;
import com.example.sign.prototype.Student;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Citation citation = new Citation();
Student student = new Student();
student.setName("张三");
citation.setStudent(student);
try {
Citation c1 = citation.clone();
c1.getStudent().setName("李四");
citation.show(); //李四
c1.show(); //李四
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
-
citation与c1指向同一个对象； - 下面通过
序列化技术，实现对象的深克隆，代码如下：
import java.io.Serializable;
public class Student implements Serializable {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
import androidx.annotation.NonNull;
import java.io.Serializable;
public class Citation implements Cloneable, Serializable {
private Student student;
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public void show() {
System.out.println(student.getName() + "同学: 在2021年12月1日 获取三号学生，特发此状");
}
@NonNull
@Override
public Citation clone() throws CloneNotSupportedException {
return (Citation) super.clone();
}
}
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import com.example.sign.prototype.Citation;
import com.example.sign.prototype.Student;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Citation citation = new Citation();
Student student = new Student();
student.setName("张三");
citation.setStudent(student);
//创建输出流
try {
//将对象序列化到磁盘文件
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("User/liyanyan/desktop/a.txt"));
//写对象
oos.writeObject(citation);
oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("User/liyanyan/desktop/a.txt"));
Citation citation1 = (Citation) ois.readObject();
ois.close();
Student student1 = citation1.getStudent();
student1.setName("李四");
citation.show(); //张三
citation1.show(); //李四
} catch (Exception e) {
e.printStackTrace();
}
}
}
-
citation与citation1指向的是两个不同的对象，其中Citation类与Student类都必须实现Serializable接口； - 上述的浅克隆，深克隆与iOS中浅拷贝，深拷贝的原理是相同的；
建造者模式
- 建造者模式：将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示；
- 实现了构建与装配的解耦，不同的构建器，相同的装配，可作出不同的对象，相同的构建器，不同的装配顺序也可作出不同的对象，也就实现了构建算法与装配算法之间的解耦，实现了更好的复用；
- 建造者模式可以将部件与其组装过程分开，一步一步创建一个复杂对象，客户只需要指定复杂对象的类型就可以得到该对象，而无需知道其内部的具体构造细节；
- 建造者模式中的角色：
- 抽象建造者类(Builder)：定义了复杂对象各部件创建的接口；
- 具体建造者类：实现了Builder中的接口，完成部件的创建，在构造完成之后，返回产品实例；
- 产品类：需要的创建的复杂对象；
- 指挥者类(Director)：调用具体建造者来创建复杂对象的各个部分，在指挥者类中，不涉及具体产品信息，只负责保证对象各部分完整创建或按某种顺序创建；
- 下面以创建自行车为案例，来阐述建造者模式，首先产品类是自行车这个复杂对象，其包含车架与车座，车架有碳纤维，铝合金，车座有真皮，橡胶，UML类图如下所示：
image.png
- 代码实现如下：
public class Bike {
private String frame;
private String seat;
public String getFrame() {
return frame;
}
public void setFrame(String frame) {
this.frame = frame;
}
public String getSeat() {
return seat;
}
public void setSeat(String seat) {
this.seat = seat;
}
}
//抽象建造者
public abstract class Builder {
protected Bike bike = new Bike();
public abstract void buildFrame();
public abstract void buildSeat();
public abstract Bike createBike();
}
public class MobleBuilder extends Builder{
@Override
public void buildFrame() {
bike.setFrame("碳纤维车架");
}
@Override
public void buildSeat() {
bike.setSeat("真皮车座");
}
@Override
public Bike createBike() {
return bike;
}
}
public class OfoBuilder extends Builder{
@Override
public void buildFrame() {
bike.setFrame("铝合金车架");
}
@Override
public void buildSeat() {
bike.setSeat("橡胶车座");
}
@Override
public Bike createBike() {
return bike;
}
}
//指挥者类 装配
public class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public Bike construct() {
builder.buildFrame();
builder.buildSeat();
return builder.bike;
}
}
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import com.example.sign.build.Bike;
import com.example.sign.build.Director;
import com.example.sign.build.MobleBuilder;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Director director = new Director(new MobleBuilder());
Bike bike = director.construct();
System.out.println(bike.getFrame() + bike.getSeat());
}
}
- 上述案例是Builder模式的常规用法，指挥者Director在建造者模式中具有很重要的作用，它用于指导具体构建者如何构建产品，控制先后次序，并向调用者返回完整的产品类，可以考虑将指挥者Director与抽象建造者类Builder进行合并，代码如下：
//抽象建造者
public abstract class Builder {
protected Bike bike = new Bike();
public abstract void buildFrame();
public abstract void buildSeat();
public abstract Bike createBike();
public Bike construct() {
this.buildFrame();
this.buildSeat();
return this.createBike();
}
}
- 这样设计简化了系统结构，但加重了抽象建造者Builder的职责，若指挥者Director类逻辑过于复杂，建议还是将两者分开；
