简单工厂

一般提供创建对象的功能，不需要关心具体的实现，在需要某个实例对象的时候，直接传入某个特定的值，直接得到所需实例对象，不需要反复去创建。

一般的流程是：规范接口—>实现类—>工厂创建

• 定义规范接口：

public interface BaseInterface {
}

• 创建实体类，并实现规范接口

/**
 * 目标实现类
 */

public class Impl1 implements BaseInterface{

}

这里举例Impl1 其他的实体类原理一样，如下：

• 使用工厂去创建

/**
 * 简单工厂
 */

@RequiresApi(api = Build.VERSION_CODES.KITKAT)
public class Factory {
    private static SparseArray<BaseInterface> map = new SparseArray<>();
    public static BaseInterface createInterface(int position) {
        BaseInterface anInterface = map.get(position);
        if (anInterface == null) {
            if (position == 0) {
                anInterface = new Impl1();
            } else if (position == 1) {
                anInterface = new Impl2();
            } else if (position == 2) {
                anInterface = new Impl3();
            } else if (position == 3) {
                anInterface = new Impl4();
            } else if (position == 4) {
                anInterface = new Impl4();
            }
            // 第一次进来 先创建 然后缓存
            if (anInterface != null) {
                map.put(position, anInterface);
            }
        }
        return anInterface;
    }
}

在使用的使用直接获取： Impl1 impl1 = (Impl1) Factory.createInterface(0);

-常使用的场景：创建Fragment

public class FragmentFactory {
    private static Map<Integer, Fragment> map = new HashMap<>();

    public static Fragment createFragment(int position) {
        Fragment fragment = map.get(position);
        if (fragment == null) {
            if (position == 0) {
                fragment = new ConversationListFragment();
            } else if (position == 1) {
                fragment = new ContactListFragment();
            }
            if (fragment != null) {
                map.put(position, fragment);
            }
        }
        return fragment;
    }
}

工厂方法

工厂方法在java和android里很是常用，例如：set集合，list集合

工厂方法：把对象的实现延迟到子类完成

步骤大致为：产品（接口统一，定义各种需要实现的方法）—>具体的产品的实现（代表具体的实现功能的）—>创建器（工厂统一接口）—>具体工厂的创建（产生具体的产品）

• 产品（接口统一，定义各种需要实现的方法）

/**
 * 产品，接口统一工厂实现
 */
public interface Product {

    String allSay();

}

• 具体的产品的实现（代表具体的实现功能的）

/**
 * 具体的产品的实现（代表具体的实现功能的）
 */
 public class ConcreteProduct1 implements Product{
    @Override
    public String allSay() {
        return "我是方法ConcreteProduct1";
    }
}


/**
 * 具体的产品的实现（代表具体的实现功能的）
 */
public class ConcreteProduct2 implements Product {
    @Override
    public String allSay() {
        return "我是方法ConcreteProduct2";
    }
}

• 创建器（工厂统一接口）

/**
 * 创建器——规范创建具体类
 */

public abstract class Factory {
    /**
     * 创建Product的工厂方法
     *
     * @return
     */
    public abstract Product factoryMethod();

}

• 具体工厂的创建（产生具体的产品）

/**
 * 具体的创建器，创建对应的实现类
 * 对应ConcreteProduct1
 */
public class ConcreteFactory1 extends Factory {

	@Override
	public Product factoryMethod() {
		return new ConcreteProduct1();
	}
}


/**
 * 具体的创建器，创建对应的实现类
 * 对应ConcreteProduct2
 */
public class ConcreteFartory2 extends Factory {

	@Override
	public Product factoryMethod() {
		return new ConcreteProduct2();
	}
}

• 使用具体类

public class MainActivity extends AppCompatActivity {

    private Product concreteProduct1;
    private Product concreteProduct2;

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        /**
         * 方式一
         */
        //工厂方法
        ConcreteFactory1 concreteCreator = new ConcreteFactory1();
        // 调用公用方法
        concreteProduct1 = concreteCreator.factoryMethod();

        ConcreteFartory2 concreteFartory2 = new ConcreteFartory2();
        concreteProduct2 = concreteFartory2.factoryMethod();
    }

    public void onClickOne(View view) {
        String s = concreteProduct1.allSay();
        Log.d("huangxiaoguo", s);
    }

    public void onClickTwo(View view) {
        String s = concreteProduct2.allSay();
        Log.d("huangxiaoguo", s);
    }
}

这里就实现了工厂方法的简单模型

使用反射重构工厂方法调用

• 产品类接口

/**
 * 产品，接口统一工厂实现
 * 注意这里的Product 可以使用接口（interface ）也可以是抽象类abstract 
 * 如果是接口，子类去实现，如果是抽象类，子类去继承
 * 如果有共同的操作建议使用—抽象类
 */
 
public interface Product {
	产品类的抽象方法，由具体的产品类去实现
    String allSay();
}

/**
*或者
*/
public abstract class Product {
	产品类的抽象方法，由具体的产品类去实现
     public abstract String allSay();
}

• 具体产品类

/**
 * 具体的产品的实现（代表具体的实现功能的）
 */
 public class ConcreteProduct1 implements Product {
    @Override
    public String allSay() {
        return "我是方法ConcreteProduct1";
    }
}

/**
 * 具体的产品的实现（代表具体的实现功能的）
 */
public class ConcreteProduct2 implements Product {
    @Override
    public String allSay() {
        return "我是方法ConcreteProduct2";
    }
}
----------------------------------------------------
/**
 * 或者
 */
  ------------------------------------------------------
/**
 * 具体的产品的实现（代表具体的实现功能的）
 */
 public class ConcreteProduct1 extends Product {
    @Override
    public String allSay() {
        return "我是方法ConcreteProduct1";
    }
}

/**
 * 具体的产品的实现（代表具体的实现功能的）
 */
public class ConcreteProduct2 extends Product {
    @Override
    public String allSay() {
        return "我是方法ConcreteProduct2";
    }
}

• 抽象工厂

/**
 * 创建器——规范创建具体类
 */

public abstract class Factory {
    /**
     * 创建Product的工厂方法
     * @param clz 产品对象类型
     * @return 具体的产品类型
     */
    public abstract <T extends Product> T createProduct(Class<T> clz);

}

• 具体工厂

/**
 * 具体的创建器，创建对应的实现类
 * 对应ConcreteProduct
 */
public class ConcreteFactory extends Factory {

    @Override
    public <T extends Product> T createProduct(Class<T> clz) {
        Product p = null;
        try {
            p = (Product) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) p;
    }
}

• 调用

		Factory factory = new ConcreteFactory();
        ConcreteProduct1 productA = factory.createProduct(ConcreteProduct1.class);
        ConcreteProduct2 productB = factory.createProduct(ConcreteProduct2.class);
        String s = productA.allSay();
        String s1 = productB.allSay();
        Log.d("huangxiaoguo",s);
        Log.d("huangxiaoguo",s1);

采用了反射的方式来实现生产具体的产品对象，这样更加简洁，不用为每一个产品都创建一个具体的工厂。

总结：

• 工厂方法模式通过依赖抽象来达到解耦的效果，并且将实例化的任务交给子类去完成，有非常好的扩展性。

• 缺点也很明显，就是每次我们为工厂方法添加新的产品时，都需要编写一个新的产品类，所以要根据实际情况来权衡是否要用工厂方法模式