创建型设计模式—factory(工厂模式)/protoype(原型模式)/builder(建造者模式)

一、Factory Method(工厂方法模式)

(1)、思想

将创建对象的过程抽象成工厂接口,将需要创建的某一类对象抽象成产品抽象类。
通过不同的工厂接口实现类,去创建不同的对象
这样就可以在外部,利用多态的特性,工厂接口指向不同的工厂接口实现类,去创建不同的对象。

(2)、步骤

 1. 创建工厂接口类,声明工厂方法,方法返回抽象产品类 
 2. 创建抽象产品类 
 3. 创建不同的工厂接口实现类,重写接口方法,返回不同的产品。
 4. 外部调用时,用接口指向不同的接口实现类,调用相同的方法创建不同的对象,实现多态。

(3)、代码

//抽象工厂接口
public interface Ifactory {
    //生产衣服
    public AbstractClothing produceClothes();
}


//服装抽象类,也就是抽象产品类
public abstract  class AbstractClothing {
    public abstract void print();
}


//外套,继承抽象产品类
public class Coat extends AbstractClothing{
    @Override
    public void print() {
        System.out.println("生产外套");
    }
}

//帽子实体,继承抽象产品类
public class Hat extends AbstractClothing{

    @Override
    public void print() {
        System.out.println("生产帽子");
    }
}

//生产外套工厂,继承抽象工厂接口,是一个具体工厂,只生产一个具体的产品
public class factoryCoatImpl implements Ifactory{
    @Override
    public AbstractClothing produceClothes() {
        Coat coat=new Coat();
        return coat;
    }
}

//生产帽子工厂,继承抽象工厂接口,是一个具体工厂,只生产一个具体的产品
public class factoryHatImpl implements Ifactory{
    @Override
    public AbstractClothing produceClothes() {
        Hat hat=new Hat();
        return hat;
    }
}

public class factoryTest {

    public static void main(String[] args) {
        Ifactory ifactory=new factoryHatImpl();
        AbstractClothing abstractClothing=ifactory.produceClothes();
        abstractClothing.print();
    }
}

二、abstract Factory (抽象工厂模式)

(1)、思想

相对于工厂方法模式,只不过这里是有多个抽象产品类,
每个抽象工厂类里面有多个方法生成不同类型的产品,对应的一个产品族的生产。

(2)、步骤

 1. 声明多个抽象产品类,对于不同的产品类型 
 2. 声明多个具体产品类,一个抽象产品类型对应有多个具体的产品
 3. 声明抽象工厂类,里面有多个工厂方法,每个工厂方法返回不同的产品类型 
 4. 声明具体的工厂类,实现抽象工厂类接口
 5. 在客户端,利用多态,抽象工厂变量指向不同的具体工厂对象,
    就可以实现生产不同的产品族的需求。

(3)、代码

//抽象产品类,外套
public abstract class AbsCoat {

    public abstract void print();
}

//抽象产品类,帽子
public abstract class AbsHat {

    public abstract void print();
}

public class CoatAnta extends AbsCoat{

    @Override
    public void print() {
        System.out.println("Anta外套");
    }
}

public class CoatNick extends AbsCoat{

    @Override
    public void print() {
        System.out.println("Nick外套");
    }
}

public class HatAnta extends AbsHat{

    @Override
    public void print() {
        System.out.println("Anta帽子");
    }
}

public class HatNick extends AbsHat{

    @Override
    public void print() {
        System.out.println("Nick帽子");
    }
}

//抽象工厂
public interface Ifactory {

    //生产外套
    public AbsCoat printCoat();

    //生产帽子
    public AbsHat printHat();
}

//anta工厂
public class AntaFactoryImpl implements Ifactory {

    @Override
    public AbsCoat printCoat() {
        return new CoatAnta();
    }

    @Override
    public AbsHat printHat() {
        return new HatAnta();
    }
}

//nick工厂
public class NickFactoryImpl implements Ifactory {

    @Override
    public AbsCoat printCoat() {
        return new CoatNick();
    }

    @Override
    public AbsHat printHat() {
        return new HatNick();
    }
}

//抽象工厂模式,多个抽象产品类,每个抽象产品类对于的是一个产品族,
//每个抽象产品类有多个具体产品子类,对于的是每种产品
//一个抽象工厂,定义多种生产产品的方法,多个具体工厂类实现方法,返回具体的产品。
//相对于抽象工厂模式的优点在于,多种产品的情况下,替换具体工厂类,就可以替换好一整套产品。
public class factoryTest {

    public static void main(String[] args) {
        Ifactory ifactory=new AntaFactoryImpl();
        ifactory.printHat().print();
        ifactory.printCoat().print();
    }
}

三、protoype(原型模式)

(1)、思想

1、对于对象创建过程比较复杂的情况,可以让这个类实现Cloneable接口
  (实际上这只是一个空接口,用于在调用obj的clone方法时做校验,
   实现了这个接口才能克隆成功,否则会抛异常)

2、调用clone方法会实现浅拷贝,也就是基本类型的变量会复制到新的对象,
   引用类型的变量只是将指向复制给新的对象,新的对象里面改变引用类型变量,
   原对象里面会跟着改变。

3、如果要实现深拷贝,可以将引用变量对象再克隆一遍,
   然后将克隆出来的引用对象set到新的对象对应的属性里去。
   或者还可以通过序列化的方式来做。

（2)、步骤

 1. 实体类实现Cloneable接口
 2. 声明一个自己的clone方法,在方法里面调用父类obj.clone，克隆出新的对象返回。

(3)、代码

//周报类
public class WeeklyLog implements Cloneable{


    private Attachment attachment;
    private String date;
    private String name;
    private String content;
    public Attachment getAttachment() {
        return attachment;
    }
    public void setAttachment(Attachment attachment) {
        this.attachment = attachment;
    }
    public String getDate() {
        return date;
    }
    public void setDate(String date) {
        this.date = date;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }

    //实现clone()方法实现浅克隆
    public WeeklyLog clone() {
        //每个类都是obj的子类,所以都可以调用obj自带的clone方法,浅拷贝对象,然后再向下转型成具体的类对象
        Object obj = null;
        try {
            obj = super.clone();
            return (WeeklyLog)obj;
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            System.out.println("不支持克隆方法！");
            return null;
        }
    }
}

//原型模式,就是类实现Cloneable,利用obj.clone()对原对象进行浅拷贝(拷贝对象里面的封装属性和原对象里的指向同一个地址),
//如果要实现深拷贝,就需要用序列化或者对原对象成员变量里面的封装类型再单独进行obj.clone(),然后指向克隆对象的成员变量。
public class protoypeTest {

    public static void main(String[] args) {
        WeeklyLog log_1,log_2;
        log_1 = new WeeklyLog();   //创建原型对象
        Attachment attachment = new Attachment(); //创建附件对象
        log_1.setAttachment(attachment);   //将附件添加到周报种去
        log_2=log_1.clone();   //克隆周报
        System.out.println("周报是否相同"+(log_1==log_2));
        System.out.println("附件是否相同"+(log_1.getAttachment()==log_2.getAttachment()));
    }
}

四、builder(建造者模式)

(1)、思想

一个对象属性比较多,并且在不同情况下,允许一部分属性为null的情况下，
可以将这些属性拆分成多次构建。

(2)、步骤:

 1. 声明一个构建类,类里面先创建一个成员变量指向new出的对象。 
 2. 声明不同的赋值方法,对对象的不同的属性进行赋值。
 3. 声明一个build方法,返回对象。