工厂方法模式

应用最广泛的模式–> 工厂方法模式
工厂方法模式是创建型设计模式之一。
定义：
定义一个用于创建对象的接口，让子类决定实例化哪个类。
使用场景：
任何需要生产复杂对象的地方，都可以使用工厂方法模式。复杂对象适合使用工厂模式，
用new 就可以完成创建对象无需使用工厂模式。

工厂方法通用模板

	// 抽线产品类
	public abstract class Product {
	    /**
	     * 产品类的抽象方法
	     */
	    public abstract void method();
	}

	//具体产品A
	class ConcreteProductA extends Product {
	    @Override
	    public void method() {
	        System.out.println("具体产品A");
	    }
	}

	//具体产品B
	class ConcreteProductB extends Product {
	    @Override
	    public void method() {
	        System.out.println("具体产品B");
	    }
	}

	//抽象工厂类
	public abstract class Factory {
	    /**
	     * 抽象工厂方法
	     * 具体生产什么由子类去实现
	     */
	    public abstract Product createProduct();
	}

	//具体工厂
	public class ConcreteFactory extends Factory {

	    @Override
	    public Product createProduct() {
	        return new ConcreteProductA();
	    }
	}

	// 客户类
	public class Client {

	    public static void main(String[] args) {
	    	// 创建工厂
	        Factory factory = new ConcreteFactory();
	        // 通过工厂创建产品
	        Product product = factory.createProduct();
	        // 具体的产品
	        product.method();
	    }
	}

	// 如果我们想创建产品B

	//具体工厂
	public class ConcreteFactory extends Factory {

	    @Override
	    public Product createProduct() {
	//        return new ConcreteProductA();
	        // 创建产品B
	        return new ConcreteProductB();
	    }
	}
	// 多工厂方法模式
	//具体工厂
	public class ConcreteFactoryB extends Factory {
	    @Override
	    public Product createProduct() {
	        return new ConcreteProductB();
	    }
	}
	//具体产品B
	class ConcreteProductB extends Product {
	    @Override
	    public void method() {
	        System.out.println("具体产品B");
	    }
	}
	// 客户类
	public class Client {

	    public static void main(String[] args) {
	        // 创建工厂
	        Factory factoryA = new ConcreteFactoryA();
	        // 通过工厂创建产品
	        Product productA = factoryA.createProduct();
	        // 具体的产品
	        productA.method();

	        // 创建工厂
	        Factory factoryB = new ConcreteFactoryB();
	        // 通过工厂创建产品
	        Product productB = factoryB.createProduct();
	        // 具体的产品
	        productB.method();
	    }
	}

	利用反射更简洁的生产具体产品对象
	//抽象工厂类
	public abstract class Factory {
	    /**
	     * 抽象工厂方法
	     * 具体生产什么由子类去实现
	     *
	     * @param clazz 产品对象类型
	     * @param <T>   具体产品
	     * @return 具体产品对象
	     */
	    public abstract <T extends Product> T createProduct(Class<T> clazz);
	}

	//具体工厂
	public class ConcreteFactory extends Factory {

	    @Override
	    public <T extends Product> T createProduct(Class<T> clazz) {
	        Product product = null;
	        try {
	            product = (Product) Class.forName(clazz.getName()).newInstance();
	        } catch (IllegalAccessException | InstantiationException | ClassNotFoundException e) {
	            e.printStackTrace();
	        }
	        return (T) product;
	    }
	}

	// 客户类
	public class Client {

	    public static void main(String[] args) {
	        // 创建工厂
	        Factory factory = new ConcreteFactory();
	        // 通过工厂创建产品
	        Product product = factory.createProduct(ConcreteProductA.class);
	        // 具体的产品
	        product.method();
	        // 创建工厂
	        Factory factory = new ConcreteFactory();
	        // 通过工厂创建产品
	        Product product = factory.createProduct(ConcreteProductB.class);
	        // 具体的产品
	        product.method();
	    }
	}

	// 静态工厂模式（简单的工厂模式）
	//抽象工厂类
	public class Factory {
	    /**
	     * 抽象工厂方法
	     * 具体生产什么由子类去实现
	     */
	    public static Product createProduct() {
	        return new ConcreteProductB();
	    }
	}


Java 中的工厂方法模式：
	List 和Set 为例，List 和 Set 都继承与 Collection 接口，而Collection
	接口继承于 Iterable接口。
		public interface Iterable<T> {
			/**
		     * Returns an iterator over elements of type {@code T}.
		     *
		     * @return an Iterator.
		     */
		    Iterator<T> iterator();
		}
Android 源码中的工厂方法模式：

	Activity 中的 onCreate()，为不同的Activity 设置不同的View。


优点：
	工厂方法模式是完全符合设计原则的，其降低了对象之间的耦合度，而且
	工厂方法模式依赖于抽象的架构，其将实例化的任务交由子类去完成，由
	非常好的扩展性。

缺点：
	每次为工厂方法模式添加新的产品就要编写一个新的产品类，同时还要引入抽象层，必然会导致类结构的复杂化。