Android 的设计模式---工厂模式（三种）
前言：
Android 的设计模式系列文章，欢迎star，持续更新。。。
Android 的设计模式---单例模式
Android 的设计模式---建造者模式
Android 的设计模式---三种工厂模式
Android 的设计模式---策略模式
Android 的设计模式---责任链模式
Android 的设计模式---观察者模式
一：简单工厂
定义:
提供一个创建对象实例的功能，而无须关心其具体实现。被创建实例的类型可以是接口、抽象类，也可以是具体的类
实现：
- 具体的工厂类
- 输入一个类型参数，返回不同的产品对象
代码：
抽象产品类（接口或抽象类都行）：
public interface Product {
//鞋
void shop();
//帽子
void hat();
}具体产品生产类：
public class CreateProductA implements Product {
@Override
public void shop() {
System.out.println("生产鞋");
}
@Override
public void hat() {
System.out.println("生产帽子");
}
}public class CreateProductB implements Product {
@Override
public void shop() {
System.out.println("生产鞋");
}
@Override
public void hat() {
System.out.println("生产帽子");
}
}工厂类（代理类）：
public class Creator {
public static Product createProduct(String type) {
Product product = null;
switch (type) {
case "shop":
product = new CreateProductA();
break;
case "hat":
product = new CreateProductB();
break;
}
return product;
}
}客户端调用：
public class ClienTest {
public static void main(String[] args) {
//想要生产鞋
Product shopProduct = Creator.createProduct("shop");
shopProduct.shop();
//想要生产帽子
Product hatProduct = Creator.createProduct("hat");
hatProduct.hat();
}
}简述一下各自扮演的角色： 一共有两种产品：鞋和帽子；有两个不同的工厂，有一个总代理商，通过输入不同的类型去让不同的厂商生产不同的产品。
优缺点：
- 简单
- 解耦
- 拓展困难
- 不符合开闭原则
- 当产品很多的时候，会出现代码臃肿，可读性低，难以维护
使用场景 ：
new的替代品，需要用new创建对象的时候
二：工厂方法
定义：
定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
实现代码：
抽象产品类（接口或抽象类都行）：
public interface Product {
//鞋
void shop();
//帽子
void hat();
//衬衫
void shirt();
}具体产品类：
public class ProductA implements Product {
@Override
public void shop() {
System.out.println("生产鞋");
}
@Override
public void hat() {
System.out.println("生产帽子");
}
@Override
public void shirt() {
System.out.println("生产衬衫");
}
}public class ProductB implements Product {
@Override
public void shop() {
System.out.println("生产鞋");
}
@Override
public void hat() {
System.out.println("生产帽子");
}
@Override
public void shirt() {
System.out.println("生产衬衫");
}
}public class ProductC implements Product {
@Override
public void shop() {
System.out.println("生产鞋");
}
@Override
public void hat() {
System.out.println("生产帽子");
}
@Override
public void shirt() {
System.out.println("生产衬衫");
}
}工厂类（代理）：
public interface Creator {
Product createProduct();
}工厂实现类：
public class CreateProductA implements Creator {
@Override
public Product createProduct() {
return new ProductA();
}
}
public class CreateProductB implements Creator {
@Override
public Product createProduct() {
return new ProductB();
}
}public class CreateProductC implements Creator {
@Override
public Product createProduct() {
return new ProductC();
}
}客户端调用：
public class ClienTest {
public static void main(String[] args) {
//生产鞋和衬衫
CreateProductA createProductA = new CreateProductA();
Product productA = createProductA.createProduct();
productA.shop();
productA.shirt();
//生产帽子
CreateProductB createProductB = new CreateProductB();
Product productB = createProductB.createProduct();
productB.hat();
//生产衬衫
CreateProductC createProductC = new CreateProductC();
Product product = createProductC.createProduct();
product.shirt();
}
}简单描述一下各自角色：上头下来三个生产指标：鞋，帽子，衬衫；有三个产品商，一个代理商，三个产品商的自行跟代理商选择指标到各自工厂生产。
优缺点：
- 良好的封装性，代码清晰（一个调用者需要一个具体的产品工厂对象，只要知道这个产品工厂的类名，就可以了，不用知道内部的创建过程）
- 拓展性好（在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类）
- 解耦
- 每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量。
相比于简单工厂，我增加了一个产品衬衫就多出了两个类，可见如果产品越多，代码量也会成倍的增长，太可怕了 ，那有没有办法解决这种代码量激增的方法呢？，当然有的啦，《反射机制》如下：
1、我们把 Creator.class 改成如下：
public interface Creator {
T createProductByRefettion(Class tClass);
} 2、增加一个Creator的实现类CreateImpl.class
public class CreateImpl implements Creator {
@Override
public T createProductByRefettion(Class tClass) {
Product product = null;
try {
product = (Product) Class.forName(tClass.getName()).newInstance();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return (T) product;
}
} 3、客户端调用修改：
public class ClienTest {
public static void main(String[] args) {
CreateImpl createImpl = new CreateImpl();
//生产鞋和帽子
ProductA productA = createImpl.createProductByRefettion(ProductA.class);
productA.shop();
//帽子
ProductB productB = createImpl.createProductByRefettion(ProductB.class);
productB.hat();
//生产衬衫
ProductC productC = createImpl.createProductByRefettion(ProductC.class);
productC.shirt();
}
}我们使用了反射之后就不用再去给每个产品提供 一个生产工厂了，是不是方便了很多，也少了很多代码。
三：抽象方法
定义：
为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。
实现代码：
产品家族A：
public interface ProductA {
void shop();
void hat();
}产品家族的具体实现：
public class ProductImplA implements ProductA {
@Override
public void shop() {
System.out.println("生产鞋");
}
@Override
public void hat() {
System.out.println("生产帽子");
}
}抽象工厂（家族代理商）：
public interface ProductImpl {
ProductA createProductA();
}家族代理商的具体实现：
public class ProductCreateImplA implements ProductImpl {
@Override
public ProductA createProductA() {
return new ProductImplA();
}
}客户端调用：
public class ClienTest {
public static void main(String[] args) {
ProductCreateImplA productCreateImplA=new ProductCreateImplA();
ProductA productA = productCreateImplA.createProductA();
productA.hat();
productA.shop();
}
}优缺点：
- 封装性，高层模块不需要关心每个产品的实现类，不关心对象是如何创建出来的，只要知道工厂类是谁，就能创建出一个需要的对象
- 一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象，并且很容易交换产品系列
- 可以定义产品族内的约束，并且这样的约束对高层模块来说是透明的
- 产品族扩展非常困难，以上面的通用代码为例，如果要增加一个产品B，也就是说产品家族由原来的1个增加到2个，抽象工厂类也要相应的增加，然后每个实现类都要修改，违反了开闭原则。
- 抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
结尾总结：
简单工厂、工厂方法、抽象工厂这三种模式是逐步抽象的，后者适用于更为一般的场景，而前者是后者的特例。但它们的目标都是为了灵活地创建所需的对象并且对客户端隐藏对象创建细节，三者的扩展性和开发量有所不同，可以根据实际情况选择合适的模式来代替以new的方式创建对象的过程。
- 简单工厂适用于产品种类较少，且不需要太多扩展的场景
- 工厂方法模式作为简单工厂的进一步抽象和补充，更加适用于有很多扩展需求的场景
- 一个产品族都有相同的约束
如果想详细了解，请跳转到这查看详细说明 https://segmentfault.com/a/1190000019485423?utm_source=tag-newest