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.不使用静态工厂方法,可以形成基于继承的等级结构。
缺点:难以扩展新种类产品

总结

  • 角色不同

    • 简单工厂:具体工厂、抽象产品、具体产品
    • 工厂方法:抽象工厂、具体工厂、抽象产品、具体产品
    • 抽象工厂:抽象工厂、具体工厂、抽象产品族、抽象产品、具体产品
  • 定义

    • 简单工厂:由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类(继承自一个父类或接口)的实例。
    • 工厂方法:定义工厂父类负责定义创建对象的公共接口,而子类则负责生成具体的对象
    • 抽象工厂:提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类;具体的工厂负责实现具体的产品实例。
  • 对比

    • 工厂方法模式解决了简单工厂模式的“开放 - 关闭原则
    • 抽象工厂模式解决了工厂方法模式一个具体工厂只能创建一类产品

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

上一篇:java策略模式


下一篇:java单例模式