04_抽象工厂模式

【抽象工厂模式自己想的思路】

假设一个村庄生产两种水果：苹果和芒果，某年由于滞销导致村里积累了大量苹果和芒果，为了利用起来这些水果，村里要建设两种工厂，分别是果汁加工厂和果干加工厂，在这两个加工厂中，果汁加工厂可以生产苹果汁和芒果汁，果干加工厂可以生产苹果干和芒果干，这里就涉及了我们的抽象工厂模式。

 

【抽象工厂模式例子】

package com.Higgin.AbstractFactory;

/**
 * 苹果接口/抽象类  
 */
interface Apple{
    public void getName();
    public void getColor();
}

/**
 * 苹果汁 
 */
class AppleJuice implements Apple{
    @Override
    public void getName() {
        System.out.println("我是苹果汁！");
    }
    @Override
    public void getColor() {
        System.out.println("苹果汁，红红的！");
    }
}
/**
 * 苹果干 
 */
class AppleDry implements Apple{
    @Override
    public void getName() {
        System.out.println("我是苹果干！");
    }
    @Override
    public void getColor() {
        System.out.println("苹果干，红红的！");
    }
}

/**
 * 芒果接口/抽象类 
 */
interface Mango{
    public void getName();
    public void getColor();
}
/**
 * 芒果汁 
 */
class MangoJuice implements Mango{
    @Override
    public void getName() {
        System.out.println("我是芒果汁！");
    }
    @Override
    public void getColor() {
        System.out.println("芒果汁，黄黄的！");
    }
}
/**
 * 芒果干 
 */
class MangoDry implements Mango{
    @Override
    public void getName() {
        System.out.println("我是芒果干！");
    }
    @Override
    public void getColor() {
        System.out.println("芒果干，黄黄的！");
    }
}

/**
 * 水果工厂 接口/抽象类 
 */
interface FruitFactory{
    public Apple createApple();
    public Mango createMango();
}

/**
 * 果汁工厂 
 */
class FruitJuiceFactory implements FruitFactory{
    @Override
    public Apple createApple() {
        return new AppleJuice();
    }
    @Override
    public Mango createMango() {
        return new MangoJuice();
    }
}
/**
 * 果干工厂 
 */
class FruitDryFactory implements FruitFactory{
    @Override
    public Apple createApple() {
        return new AppleDry();
    }
    @Override
    public Mango createMango() {
        return new MangoDry();
    }
}
/**
 * 客户端 
 */
public class TestAbstractFactory {
    public static void main(String[] args) {
        //果汁工厂
        FruitFactory fruitJuiceFactory=new FruitJuiceFactory();
        //由果汁工厂 创建 苹果汁
        Apple appleJuice =fruitJuiceFactory.createApple();
        appleJuice.getName();
        appleJuice.getColor();
        //由果汁工厂 创建 芒果汁
        Mango mangoJuice=fruitJuiceFactory.createMango();
        mangoJuice.getName();
        mangoJuice.getColor();
        
        //果干工厂
        FruitFactory fruitDrtFactory=new FruitDryFactory();
        //由 果干工厂 得到 芒果干
        Mango mangoDry=fruitDrtFactory.createMango();
        mangoDry.getName();
        mangoDry.getColor();
        //由 果干工厂得到 苹果干
        Apple appleDry=fruitDrtFactory.createApple();
        appleDry.getName();
        appleDry.getColor();
        
    }
}

【运行结果】

 

【抽象工厂模式的优点】

1.封装性，每个产品的实现类不是高层模块所需要关注的，它需要关注的是接口/抽象类，它不关心对象是如何创建出来的，只要知道工厂类是谁，就能创建出一个需要的对象。

2.产品族内的约束为非公开状态。

【抽象工厂模式的缺点】

扩展较为困难。主要是产品族扩展较为困难，产品等级扩展实际是非常容易的。比如，增加一个橙子产品，只要新增橙子接口和其实现类橙子汁、橙子干，再在FruitFactory中添加上创建橙子的方法。