设计模式——工厂方法模式

工厂方法模式

定义：Define an interface for creating an object, but let subclasses decide which class instance. Factory Method lets a class defer instantiation to subclasses.
（定义一个用于建立对象的接口 [这里的接口一词并不指Java中的接口构造，它能够是Java接口或抽象类] ，可是让子类决定去实例化哪一个类。工厂方法将对象的实例化推迟到其子类。）

优点：
[1].良好的封装性，代码结构清晰。若是一个调用者须要一个具体的产品对象，只要知道这个产品的类名就能够了，不用关心对象是如何建立的，下降了模块见得耦合。
[2].工厂方法模式扩展性很是优秀。若是想增长一个产品类，只须要适当的修改具体的工厂类或扩展一个工厂类就能够完成。
[3].屏蔽品类。产品的实现如何变化，调用者都不须要关心，它只须要关心产品的接口，只要接口保持不变，系统中的上层模块就不须要发生变化。由于产品的实例化工做是由工厂类负责的，一个产品对象具体由哪个产品生成是由工厂类决定的。 例如：在数据库开发中，若是使用 JDBC 链接数据库，数据库从 MySQL 且款到 Oracle，只须要改动的地方就是切换一下驱动名称。
[4].工厂方法模式是典型的解耦框架。高层模块值只须要知道产品的抽象类，其余的实现类都不用关心，符合迪米特法则，我不须要的就不要去交流；也符合依赖倒置原则，只依赖产品的抽象；也符合里氏替换原则，使用产品子类替换父类。

---

简单工厂模式（Simple Factory Pattern）

基本组成
产品抽象类Product
具体产品类ConcreteProduct1 ConcreteProduct2
工厂类Creator

• 产品抽象

public abstract class Product {
	public abstract void method();
}
复制代码

---

• 具体产品

public class ConcreteProduct1 extends Product{
	@Override
	public void method() {
	    // do something...
	}
}
public class ConcreteProduct2 extends Product{
	@Override
	public void method() {
	    // do something...
	}
}
复制代码

---

• 工厂（第一种实现方式）

public class Creator{
	public static <T extends Product> T createProduct(Class<T> c) {
		Product product=null;
		try {
			product=(Product)Class.forName(c.getName()).newInstance();
		}catch(Exception e) {
			// do something...
		}
		return (T)product;
	}
}
复制代码

特色：工厂是一个具体类，非抽象类 非接口，它的create方法，是利用反射机制生成对象返回，增长一种产品时，不须要修改工厂的代码。
缺点：不一样的产品须要不一样额外参数的时候 不支持。

---

• 工厂（第二种实现方式）

public class Creator{
        public static final int PRODUCT_ONE = 1;
        public static final int PROCUCT_TWO = 2;
        
	public static Product createProduct(int type) {
		switch(type){
		    case PRODUCT_ONE:
		        return new ConcreteProduct1();
		    case PROCUCT_TWO:
		    default:
		        return new ConcreteProduct2();
		}
	}
}
复制代码

特色：工厂是一个具体类，非抽象类 非接口，create方法一般是静态的，因此也称之为静态工厂。
缺点：扩展性差，当咱们须要增长一个产品类时还须要修改工厂类； 不一样的产品须要不一样额外参数的时候 不支持。

---

多方法静态工厂

简单工厂模式的一个问题是 当产品须要不一样额外参数的时候 不支持。 并且若是使用时传递的 type、Class 出错，将不能获得正确的对象，容错性不高。
而多方法的工厂模式为不一样产品，提供不一样的生产方法。

基本组成
产品抽象类Product
具体产品类ConcreteProduct1 ConcreteProduct2
工厂类Creator

• 产品抽象

public abstract class Product {
	public abstract void method();
}
复制代码

---

• 具体产品

public class ConcreteProduct1 extends Product{
    
    private String name;
    
    public ConcreteProduct1(String name){
        this.name = name;
    }

    @Override
    public void method() {
	    // do something...
    }
}

public class ConcreteProduct2 extends Product{

    private String name;
    private int size;
    
    public ConcreteProduct2(String name, int size){
        this.name = name;
        this.size = size;
    }

    @Override
    public void method() {
	    // do something...
    }
}
复制代码

---

• 工厂

public class Creator{

    public static Procuct createProduct1(String name){
        return new ConcreteProduct1(name);
    }
    
    public static Procuct createProduct2(String name, int size){
        return new ConcreteProduct2(name, size);
    }
}
复制代码

优势：方便建立 同种类型的 复杂参数 对象

---

普通工厂

基本组成
产品抽象类Product
工厂抽象类Creator
具体产品类ConcreteProduct1 ConcreteProduct2
具体工厂类ConcreteCreator1 ConcreteCreator2

• 产品抽象

public abstract class Product {
	public abstract void method();
}
复制代码

---

• 工厂抽象

public abstract class Creator{
    public abstract Product create();
}
复制代码

---

• 具体产品

public class ConcreteProduct1 extends Product{
	@Override
	public void method() {
	    // do something...
	}
}
public class ConcreteProduct2 extends Product{
	@Override
	public void method() {
	    // do something...
	}
}
复制代码

---

• 具体工厂

public class ConcreteCreator1 extends Creator{
    @Override
    public Product create(){
        return new ConcreteCreator1();
    }
}
public class ConcreteCreator2 extends Creator{
    @Override
    public Product create(){
        return new ConcreteCreator2();
    }
}
复制代码

特色：不单单产品须要抽象， 工厂也须要抽象；工厂方法使一个产品类的实例化延迟到其具体工厂子类。
优势：拥抱变化，当需求变化，只须要增删相应的类，不须要修改已有的类。而简单工厂须要修改工厂类的create方法，多方法静态工厂模式须要增长一个静态方法。
缺点：引入抽象工厂层后，每次新增一个具体产品类，也要同时新增一个具体工厂类。