工厂方法设计模式

文接简单工厂，我们知道，开闭原则指的是对修改关闭，对扩展开放，而工厂方法就是为了解决这个问题，它提供一个工厂抽象接口，每一种产品的生产都会有自己的工厂，

消费者从对应工厂获取产品即可，如果增加了一种产品，只需要增加对应的工厂即可，从而避免了修改，只是扩展。但是也会出现一个问题，那就是会出现大量的工厂类，代码量大。

 

   类结构：

 

 

 

 

  1 工厂接口

//工厂接口，用于定义工厂对外的方法
public interface FruitFactory {
    Fruit getFruit();
}

2 对应产品的工厂

public class AppleFactory implements FruitFactory {
    @Override
    public Apple getFruit() {
         return new Apple();
    }
}

public class PearFactory implements  FruitFactory{
    @Override
    public Pear getFruit() {
        return new Pear();
    }
}

public class BananaFactory implements  FruitFactory{
    @Override
    public Banana getFruit() {
        return new Banana();
    }
} 

3 抽象产品

/**
 * 抽象产品 Fruit
 */
public abstract class AbstractFruit {

    /**
     * 产品类的公共方法
     */
    public void methodPublicUse(){
        //业务逻辑处理
    }

    /**
     * 抽象方法:生成水果
     */
    public abstract void doFruitSth();

}

4 具体产品

/**
 * 具体产品类
 */
public class Apple extends AbstractFruit {
    @Override
    public void doFruitSth() {
        //业务逻辑处理,生产水果
    }
}

/**
 * 具体产品类
 */
public class Banana extends AbstractFruit {
    @Override
    public void doFruitSth() {
        //业务逻辑处理,生产水果
    }
}

/**
 * 具体产品类
 */
public class Pear extends AbstractFruit {
    @Override
    public void doFruitSth() {
        //业务逻辑处理,生产水果
    }
}

5 使用举例

 public static void main(String[] args) {
        //工厂接口(定义工厂方法)
        FruitFactory fruitFactory;
        //抽象产品（水果）
        AbstractFruit fruit;

        /* 具体化产品工厂(苹果)，调用 工厂方法getFruit()生成产品(苹果) */
        fruitFactory = new AppleFactory();
        //执行工厂方法，获取具体产品（苹果）
        fruit = fruitFactory.getFruit();
        //用产品 fruit 做其他业务...
        fruit.methodPublicUse();
        fruit.doFruitSth();

        /* 具体化产品工厂(梨)，调用 工厂方法getFruit()生成产品(梨) */
        fruitFactory = new PearFactory();
        //执行工厂方法，获取具体产品（梨）
        fruit = fruitFactory.getFruit();
        //用产品 fruit 做其他业务...
        fruit.methodPublicUse();
        fruit.doFruitSth();

        /* 具体化产品工厂(香蕉)，调用 工厂方法getFruit()生成产品(香蕉) */
        fruitFactory = new BananaFactory();
        //执行工厂方法，获取具体产品（香蕉）
        fruit = fruitFactory.getFruit();
        //用产品 fruit 做其他业务...
        fruit.methodPublicUse();
        fruit.doFruitSth();

    }

 

6 系统应用工厂方法举例

    /**
     * 在Collection接口中定义了一个 iterator方法，返回Iterator接口的实例，这个实例就是我们要的产品。
     * Iterator接口----抽象产品
     * Iterator的实现类---具体产品
     * Collection接口---工厂接口，用于定义工厂对外的方法
     * LinkedList链表类--具体造产品的工厂
     * ArrayList类--具体造产品的类工厂
     * CopyOnWriteArrayList类--具体造产品的类工厂
     */
    public static void systemExample() {
        //工厂接口(定义工厂方法)
        Collection<Integer> list;
        //抽象产品(迭代器)
        Iterator<Integer> iterator;

        /* 用具体工厂（LinkedList）构造具体产品（iterator） */
        list = new LinkedList<Integer>();
        for (int i = 0; i < 5; i++) {
            list.add(i);
        }
        //具体工厂（list）生成(iterator())具体产品（iterator）
        iterator = list.iterator();
        //用具体产品（iterator）做事情，如下
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        /* 用具体工厂（ArrayList）构造具体产品（iterator） */
        list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            list.add(i);
        }
        //具体工厂（list）生成(iterator())具体产品（iterator）
        iterator = list.iterator();
        //用具体产品（iterator）做事情，如下
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        /* 用具体工厂（CopyOnWriteArrayList）构造具体产品（iterator） */
        list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 5; i++) {
            list.add(i);
        }
        //具体工厂（list）生成(iterator())具体产品（iterator）
        iterator = list.iterator();
        //用具体产品（iterator）做事情，如下
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }