深入浅出设计模式（三）：4.抽象工厂模式 5.原型模式

4.抽象工厂模式(Abstract Factory)

---

上例中，对于中英文翻译就需要两个不同的工厂类，如果此时要增加语义的处理功能，按照工厂方法模式，则还需要增加一个对语义处理的抽象工厂类，然后再增加对中英文语义处理的两个具体的工厂类，这时就有2个抽象的工厂类，4个具体的工厂类。如果此时还需要增加语音播报功能，则还需要创建新的工厂类，这样工厂类的量就会不断增加，此时就需要使用抽象工厂模式了。

---

抽象工厂模式的设计原理

---

抽象工厂模式在翻译器中的实际应用

先设计三个产品接口：

Translate

// 翻译（Product）  
package AbstractFactory;

public interface Translate {

    public String sayTxt(String txt);

}

Interpret

package AbstractFactory;

// 语义（Product）  
public interface Interpret {

    public String doInterpret(String txt);

}

Speech

package AbstractFactory;

/**
 * @description 语音播报（Product） 
 * 
 * @author liuquan
 * @date  2015年12月21日
 */
public interface Speech {

    public String doSpeech(String txt);

}

再分别中英文实现这些产品接口的具体类：

ChineseTranslate

package AbstractFactory;

public class ChineseTranslate implements Translate {

    @Override
    public String sayTxt(String txt) {
        return "您好" + txt;
    }
}

ChineseInterpret

package AbstractFactory;

public class ChineseInterpret implements Interpret {

    @Override
    public String doInterpret(String txt) {
        return "解释中文语义" + txt;
    }

}

ChineseSpeech

package AbstractFactory;

public class ChineseSpeech implements Speech {

    @Override
    public String doSpeech(String txt) {
        return "语音播报" + txt;
    }

}

EnglishTranslate

package AbstractFactory;

public class EnglishTranslate implements Translate {

    @Override
    public String sayTxt(String txt) {

        return "Hello:" + txt;

    }

}

EnglishInterpret

package AbstractFactory;

public class EnglishInterpret implements Interpret {

    @Override
    public String doInterpret(String txt) {

        return "English Interpret:" + txt;

    }

}

EnglishSpeech

package AbstractFactory;

public class EnglishSpeech implements Speech {

    @Override
    public String doSpeech(String txt) {

        return "Speech Sound" + txt;

    }

}

再设计抽象工厂：

Factory

package AbstractFactory;

// 抽象工厂类  包含了三个产品（Translate、Interpret、Speech）  
public abstract class Factory {
    protected abstract Translate getTranslate();
    protected abstract Interpret getInterpret();
    protected abstract Speech getSpeech();

    public String sayTxt(String txt){
        Translate translate = getTranslate();
        Interpret interpret = getInterpret();
        Speech speech = getSpeech();
        return translate.sayTxt(txt) + "---" + interpret.doInterpret(txt) + "---" + speech.doSpeech(txt);
    }

}

ChineseFactoryMethod

package AbstractFactory;

// 中文工厂具体实现类  处理一系列中文产品（Translate、Interpret、Speech）  
public class ChineseFactoryMethod extends Factory{

    @Override
    protected Translate getTranslate() {
        return new ChineseTranslate();
    }

    @Override
    protected Interpret getInterpret() {
        return new ChineseInterpret();
    }

    @Override
    protected Speech getSpeech() {
        return new ChineseSpeech();
    }

}

EnglishFactoryMethod

package AbstractFactory;

/**
 * @description 英文工厂具体实现类  处理一系列英文产品（Translate、Interpret、Speech） 
 * 
 * @author liuquan
 * @date  2015年12月21日
 */
public class EnglishFactoryMethod extends Factory{

    @Override
    protected Translate getTranslate() {
        return new EnglishTranslate();
    }
    @Override
    protected Interpret getInterpret() {
        return new EnglishInterpret();
    }
    @Override
    protected Speech getSpeech() {
        return new EnglishSpeech();
    }

}

客户端操作：
Client

package AbstractFactory;

public class Client {

    public static void main (String[] args) {       
        Factory factory = new ChineseFactoryMethod();
        Translate translate = factory.getTranslate();
        Interpret interpret = factory.getInterpret();
        Speech speech = factory.getSpeech();
        System.out.println(translate.sayTxt("测试") + "---" + interpret.doInterpret("测试 ") + "---" + speech.doSpeech("测试 "));

        factory = new EnglishFactoryMethod();
        translate = factory.getTranslate();
        interpret = factory.getInterpret();
        speech = factory.getSpeech();
        System.out.println(translate.sayTxt("测试") + "---" + interpret.doInterpret("测试 ") + "---" + speech.doSpeech("测试 "));
    }

}

---

5.原型模式（Prototype）

哪里会用到原型模式

在java中，可以直接将对象赋值给新的对象，但因为java是地址传递，因此如果修改新对象的值，则原来对象的值也会修改。但如果希望新对象与原来是独立的，此时就需要使用原型模式。

原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。在Java中，复制对象是通过clone()实现的。

原型模式示意图

原型模式在java中的应用

浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。
深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。

先看看浅复制的情况：

Address

package Prototype;

public class Address implements Cloneable{

    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {        
        return (Address)super.clone();      
    }   

}

Product

package Prototype;

public class Product implements Cloneable{

    private String name;
    private double price;
    private Address address;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }

}

Client

package Prototype;

public class Client {

    public static void main (String[] args) throws CloneNotSupportedException { 
        Product product = new Product();
        Address address = new Address();
        address.setAddress("仓库1");
        product.setName("产品");
        product.setPrice(15);
        product.setAddress(address); 
        System.out.println("原来的对象：name = " + product.getName()  + ",Address = " + product.getAddress().getAddress() + ",Price = " + product.getPrice() );
        Product product1 = (Product) product.clone();
        System.out.println("新的对象：name = " + product1.getName()  + ",Address = " + product1.getAddress().getAddress() + ",Price = " + product1.getPrice() );
        product1.setName("新产品");
        product1.getAddress().setAddress("仓库2"); 
        System.out.println("修改了name和address的原对象：name = " + product.getName()  + ",Address = " + product.getAddress().getAddress() + ",Price = " + product.getPrice() );
        System.out.println("修改了name和address的新对象：name = " + product1.getName()  + ",Address = " + product1.getAddress().getAddress() + ",Price = " + product1.getPrice() );
    }
}

将其改为深复制：

只需将Product.java中的protected Object clone()修改成以下即可：

@Override
protected Object clone() throws CloneNotSupportedException { 
    Product obj = (Product)super.clone();
    obj.address = (Address) address.clone();
    return obj;
} 

还有一种深复制方法，需要采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象（利用了序列化和反序列化，所以一定要继承）：
/* 深复制 */

public Object deepClone() throws IOException, ClassNotFoundException {  

    /* 写入当前对象的二进制流 */  
    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();  
}