常用设计模式----工厂设计模式

package org.design.patterns;

/**
 * 简单工厂： 把new对象的操作提取出来，放到一个类中，由该类统一负责对象的创建，这个类就可以称为 简单工厂。
 * 如果把该工厂中创建对象的方法定义为static的，就称为是静态工厂（显然，这种不能被子类继承）
 */

class Product {// 简单的产品类，这里为了简单地说明问题，没有考虑产品的抽象
 protected int id;
 protected String name;
 protected String type;

 // ...
}

class SimpleFactory {
 public Product createProduct(String productType) {
  Product pro = new Product();

  return pro;
 }
}

// class StaticSimpleFactory {
// public static Product createProduct(String productType) {
// Product pro = new Product();
//
// return pro;
// }
// }

class ProductStore {
 SimpleFactory simpleFactory;

 public ProductStore(SimpleFactory simpleFactory) {
  this.simpleFactory = simpleFactory;
 }

 public Product initProduct(String type) {// 这里的产品
            // type可以考虑用static常量或枚举类型以减少出错哦
  // 得到产品
  Product pro = simpleFactory.createProduct(type);
  // StaticSimpleFactory.createProduct(type);//静态工厂，缺点是createProduct不能被子类重写

  // 其他操作
  // ....

  return pro;
 }
}

// 这样就可通过ProductStore.initProduct得到想要的产品

// ====================================
/**
 * 工厂方法模式： 定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化延迟到子类。
 */
abstract class FactoryMethodStore {

 public Product initProduct(String type) {
  Product pro = createProduct(type);// 不需要知道生产的具体产品，而是由子类决定。

  // ...

  return pro;
 }

 abstract Product createProduct(String type);// 抽象类的抽象工厂方法，需要子类实现
}

class MyFactoryMethodStore extends FactoryMethodStore {

 @Override
 Product createProduct(String type) {
  Product pro = new Product();

  return pro;
 }
}

// 这样就可通过MyFactoryMethodStore.initProduct得到想要的产品

/*
 * 工厂方法模式中用到了一个重要的设计原则，依赖倒置原则： 依赖倒置原则： 要依赖抽象，不要依赖具体类。 -----
 * “倒置”也是一种思想，就是不理会具体实现类的情况下去设计，
 * 例如FactoryMethodStore的initProduct方法调用了抽象的createProduct却不考虑其具体实现。
 */

// ======================================

/**
 * 抽象工厂模式：
 * 提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
 * 
 * 
 */

// Product_1，Product_2，Product_3是一个产品族的不同产品，这里为了简单没有考虑产品间的继承关系
class Product_1 {
 protected int id;
 protected String name;
 protected String type;

 // ...
}

class Product_2 {
 protected int idd;
 protected String namee;
 protected String typee;

 // ...
}

class Product_3 {
 protected int iddd;
 protected String nameeee;
 protected String typeeee;

 // ...
}

// 创建一族产品的工厂接口，当然如果内部有通用的实现的话也可写成抽象类的形式
interface AbstractFactory {
 public Product_1 createProOne();

 public Product_2 createProTwo();

 public Product_3 createProThree();
}

class ProductFamily {
 AbstractFactory abstractFactory;

 public ProductFamily(AbstractFactory abstractFactory) {
  this.abstractFactory = abstractFactory;
 }

 /**
  * 创建一个产品族
  */
 public void createFamily() {// 依赖于接口，没有理会具体实现类，而进行的设计----依赖倒置原则
  Product_1 pro1 = abstractFactory.createProOne();
  Product_2 pro2 = abstractFactory.createProTwo();
  Product_3 pro3 = abstractFactory.createProThree();
          
  System.out.println(pro1+"&"+ pro2+"&"+pro3);
  // ...
 }
}
/**
 *抽象工厂的具体实现类，其实就是一个工厂方法。
 *抽象工厂每个方法都声明成抽象，而子类的方法对这些抽象方法实现来创建具体对象。
 */
class MyAbstractFactory implements AbstractFactory {

 @Override
 public Product_1 createProOne() {
  Product_1 pro1 = new Product_1();

  // ...
  return pro1;
 }

 @Override
 public Product_2 createProTwo() {
  Product_2 pro2 = new Product_2();

  // ...
  return pro2;
 }

 @Override
 public Product_3 createProThree() {
  Product_3 pro3 = new Product_3();

  // ...
  return pro3;
 }
}
//通过调用new ProductFamily(new MyAbstractFactory());就可以创建一个产品族了。
 //=============================

/*总结：
 * 1.所有的工厂都是用来封装对象的创建；
 * 2.简单工厂，虽然不是真正的设计模式，但仍不失为一直简单的方法，可以将客户程序从具体类中解耦；
 * 3.工厂方法使用继承：把对象的创建委托给子类，子类实现工厂方法来创建对象，将实例化延迟到了子类；
 * 4.抽象工厂使用对象组合：创建对象家族时不需要考虑具体实现，实现了接口的实现类 的方法中（实现类又是工厂方法）有具体对象的创建；
 * 5.所有的工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合；
 * 6.依赖倒置原则：避免依赖具体类型，尽量依赖抽象。
 */