4.抽象工厂模式(Abstract Factory)
上例中,对于中英文翻译就需要两个不同的工厂类,如果此时要增加语义的处理功能,按照工厂方法模式,则还需要增加一个对语义处理的抽象工厂类,然后再增加对中英文语义处理的两个具体的工厂类,这时就有2个抽象的工厂类,4个具体的工厂类。如果此时还需要增加语音播报功能,则还需要创建新的工厂类,这样工厂类的量就会不断增加,此时就需要使用抽象工厂模式了。
抽象工厂模式的设计原理
抽象工厂模式在翻译器中的实际应用
先设计三个产品接口:
// 翻译(Product)
package AbstractFactory;
public interface Translate {
public String sayTxt(String txt);
}
package AbstractFactory;
// 语义(Product)
public interface Interpret {
public String doInterpret(String txt);
}
package AbstractFactory;
/**
* @description 语音播报(Product)
*
* @author liuquan
* @date 2015年12月21日
*/
public interface Speech {
public String doSpeech(String txt);
}
再分别中英文实现这些产品接口的具体类:
package AbstractFactory;
public class ChineseTranslate implements Translate {
@Override
public String sayTxt(String txt) {
return "您好" + txt;
}
}
package AbstractFactory;
public class ChineseInterpret implements Interpret {
@Override
public String doInterpret(String txt) {
return "解释中文语义" + txt;
}
}
package AbstractFactory;
public class ChineseSpeech implements Speech {
@Override
public String doSpeech(String txt) {
return "语音播报" + txt;
}
}
package AbstractFactory;
public class EnglishTranslate implements Translate {
@Override
public String sayTxt(String txt) {
return "Hello:" + txt;
}
}
package AbstractFactory;
public class EnglishInterpret implements Interpret {
@Override
public String doInterpret(String txt) {
return "English Interpret:" + txt;
}
}
package AbstractFactory;
public class EnglishSpeech implements Speech {
@Override
public String doSpeech(String txt) {
return "Speech Sound" + txt;
}
}
再设计抽象工厂:
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);
}
}
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();
}
}
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中的应用
浅复制:将一个对象复制后,基本数据类型的变量都会重新创建,而引用类型,指向的还是原对象所指向的。
深复制:将一个对象复制后,不论是基本数据类型还有引用类型,都是重新创建的。简单来说,就是深复制进行了完全彻底的复制,而浅复制不彻底。
先看看浅复制的情况:
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();
}
}
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;
}
}
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();
}