java工厂模式

讲解三种工厂模式，并比较各自优缺点

简单工厂

/**
 * @author Gjing
 * 抽象产品
 **/
interface Product {
    void create();
}

/**
 * 产品A
 */
class ProductA implements Product {
    @Override
    public void create() {
        System.out.println("产品A");
    }
}

/**
 * 产品B
 */
class ProductB implements Product {
    @Override
    public void create() {
        System.out.println("产品B");
    }
}

/**
 * 产品工厂
 */
class ProductFactory {
    Product getProduct(Integer type) {
        switch (type) {
            case 1:
                return new ProductA();
            case 2:
                return new ProductB();
            default:
                throw new NullPointerException("没有你要的产品");
        }
    }
}

** 调用：**

/**
* @author Gjing
**/
public class Test {
   public static void main(String[] args) {
       ProductFactory factory = new ProductFactory();
       Product productA = factory.getProduct(1);
       productA.create();
       Product productB = factory.getProduct(2);
       productB.create();
   }
}

工厂模式

• 工厂

/**
 * @author Gjing
 * 抽象工厂
 **/
public interface Factory {
    /**
     * 生产产品
     * @return Product
     */
    Product create();
}

/**
 * @author Gjing
 * 创建产品A 的工厂A
 **/
class FactoryA implements Factory {
    @Override
    public Product create() {
        return new ProductA();
    }
}

/**
 * @author Gjing
 * 工厂B负责创建产品B
 **/
class FactoryB implements Factory {
    @Override
    public Product create() {
        return new ProductB();
    }
}

• 产品

/**
 * @author Gjing
 * 抽象产品
 **/
interface Product {
    void create();
}

/**
 * 产品A
 */
class ProductA implements Product {
    @Override
    public void create() {
        System.out.println("产品A");
    }
}

/**
 * 产品B
 */
class ProductB implements Product {
    @Override
    public void create() {
        System.out.println("产品B");
    }
}

调用

public class Test {
    public static void main(String[] args) {
        FactoryA factoryA = new FactoryA();
        factoryA.create().create();

        FactoryB factoryB = new FactoryB();
        factoryB.create().create();
    }
}

抽象工厂模式

• 工厂

/**
 * @author Gjing
 **/
public interface Factory {
    Product getProductA();

    Product getProductB();
} 

class FactoryA implements Factory {
    @Override
    public Product getProductA() {
        return new ProductAa();
    }

    @Override
    public Product getProductB() {
        return new ProductBb();
    }
}

• 产品

/**
 * @author Gjing
 * 抽象产品
 **/
abstract class Product {
    abstract void create();
}

/**
 * 抽象产品A
 */
abstract class ProductA extends Product {
    @Override
    abstract void create();
}

/**
 * 抽象产品A的具体某个产品
 */
class ProductAa extends ProductA {
    @Override
    void create() {
        System.out.println("产品A");
    }
}

/**
 * 抽象产品B
 */
abstract class ProductB extends Product {
    @Override
    abstract void create();
}

/**
 * 抽象产品B的具体某个产品
 */
class ProductBb extends ProductB {
    @Override
    void create() {
        System.out.println("产品B");
    }
}

调用

public class Test {
    public static void main(String[] args) {
        Factory factory = new FactoryA();
        factory.getProductA().create();
        factory.getProductB().create();
    }
}

---

以上为三种不同工厂模式，他们各自的优缺点是啥？

• 简单工厂

优点：将创建使用工作分开，不必关心类对象如何创建，实现了解耦；
缺点：违背“开放 - 关闭原则”，一旦添加新产品就不得不修改工厂类的逻辑，这样就会造成工厂逻辑过于复杂。

• 工厂模式

a. 优点:      
    1. 符合开-闭原则：新增一种产品时，只需要增加相应的具体产品类和相应的工厂子类即可    
    2. 符合单一职责原则：每个具体工厂类只负责创建对应的产品     
b. 缺点：    
    1. 增加了系统的复杂度：类的个数将成对增加      
    2. 增加了系统的抽象性和理解难度     
    3. 一个具体工厂只能创建一种具体产品

• 抽象工厂

优点：
1.降低耦合
2.符合开-闭原则
3.符合单一职责原则
4.不使用静态工厂方法，可以形成基于继承的等级结构。
缺点：难以扩展新种类产品

总结

• 角色不同
  • 简单工厂：具体工厂、抽象产品、具体产品
  • 工厂方法：抽象工厂、具体工厂、抽象产品、具体产品
  • 抽象工厂：抽象工厂、具体工厂、抽象产品族、抽象产品、具体产品
• 定义
  • 简单工厂：由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（继承自一个父类或接口）的实例。
  • 工厂方法：定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象
  • 抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。
• 对比
  • 工厂方法模式解决了简单工厂模式的“开放 - 关闭原则
  • 抽象工厂模式解决了工厂方法模式一个具体工厂只能创建一类产品

---

以上为个人理解，如理解有误欢迎各位指正