二十三种设计模式第二天：建造者模式和原型模式
一：建造者模式
建造者模式和工厂模式一样，也是不用用户手动去new，返回一个类的实例。不同的是：工厂模式往往用于同一种类的类的创建，而建造者模式则是用于复杂的类或者类中关联性较强的创建。尚不能理解没关系，我们来看实现：
普通实体类
package com.example.email.test;
public class Car {
private String wheel;//轮子
private String shell;//车盖子
private String seat;//座椅
public String getWheel() {
return wheel;
}
public void setWheel(String wheel) {
this.wheel = wheel;
}
public String getShell() {
return shell;
}
public void setShell(String shell) {
this.shell = shell;
}
public String getSeat() {
return seat;
}
public void setSeat(String seat) {
this.seat = seat;
}
}
构造该类的结构和实现，实现中定义我们想要初始化的信息
package com.example.email.test;
public interface Builder {
void setShell();
void setSeat();
void setWheel();
Car getCar();
}package com.example.email.test;
public class CarBuilder implements Builder{
Car car=null;
public CarBuilder(){
car=new Car();
}
@Override
public void setShell() {
car.setShell("车壳");
System.out.println("构造车壳");
}
@Override
public void setSeat() {
car.setSeat("座椅");
System.out.println("构造座椅");
}
@Override
public void setWheel() {
car.setWheel("轮子");
System.out.println("构造轮子");
}
@Override
public Car getCar() {
return null;
}
}
指导类director
package com.example.email.test;
public class Director {
Builder builder;
public Director(Builder builder){
this.builder=builder;
}
public Car build(){
builder.setWheel();
builder.setSeat();
builder.setShell();
return builder.getCar();
}
}
测试一下
@Test
public void test1(){
Builder builder=new CarBuilder();
Director director=new Director(builder);
director.build();
}输出
其中，在Builder的实现类中，我们可以实现的自己想要初始化的内容，在指导类中，可以定义一些复杂的操作，使得使用的人不需要再去实现这些复杂操作，只需要编写自己的Builder实现类即可。
使用场景：
1.类的初始化比较复杂，调用了库中难以调用的类
2.类之间的属性有一些关联，比如初始化顺序、内容有关联等。这些就可以在指导类里实现我想要定义的规则。
下面说说原型模式
二、原型模式
原型模式主要作用是返回一个拥有当前实例状态的复制。
复制这里喃就分为了深复制和浅复制：
深复制：重新分配一个实例空间，创建一份与当前实例的内容完全一样的实例，空间地址与原来不同。
浅复制：将新的对象引用指向原来的对象，对象共享一份存储空间，一个修改会引起另一个的修改
实现：
浅复制需要实现Cloneable接口，这个接口里面实际是空的，但实现它是为了调用公共基类Object的复制方法
class Student implements Cloneable
{
private String name;
private int age;
private Teacher teacher;
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 Teacher getTeacher()
{
return teacher;
}
public void setTeacher(Teacher teacher)
{
this.teacher = teacher;
}
@Override
public Object clone() throws CloneNotSupportedException
{
Object object = super.clone();
return object;
}
}这里面假如我创建了teacher1的复制teacher2，有
1.teacher1 ==teacher2 为false，因为teacher1和teacher2比较的是对象引用地址，不相等
2.teacher1.equels(teacher2) 为true
实现深复制
class Student implements Serializable
{
private static final long serialVersionUID = 1L;
private String name;
private int age;
private Teacher3 teacher;
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 Teacher getTeacher()
{
return teacher;
}
public void setTeacher(Teacher3 teacher)
{
this.teacher = teacher;
}
public Object deepClone() throws Exception
{
// 序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
// 反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
使用原型模式二点场景：
1.类的创建比较复杂，我可以直接使用复制来做
2.我想要保存某个类的状态，通过深复制来做
今天的2种设计模式又完成了，写的速度好慢，但到后面，相信会越来越快。