设计模式：Abstract Method--抽象工厂模式

抽象工厂模式

属于创建型模式，是所有形态的工厂模式中最为抽象和最其一般性的，抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型情况下，能够创建多个产品族的产品对象。

• 抽象工厂角色creator

                  包含多个产品结构的声明，任何工厂类都必须实现这个接口或者抽象类

• 具体工厂角色concrete creator

                    具体工厂类是抽象工厂类的实现，负责实例化某个产品族的产品对象

• 抽象角色produc角色

                抽象模式所创建额所有对象的父类，它负责描述所有实例所共有的公共接口

• 具体产品concrete product角色

              抽象模式创建的具体实例对象
 

 抽象工厂模式针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。
 总结：抽象工厂中方法对应产品结构，具体工厂对应产品族
 
  抽象工厂接口FruitFactory，产生多个结构的声明
  具体工厂类NorthFactory：实现抽象工厂接口，具体实例化这个结构的实例对象
  抽象产品接口Fruit：
  抽象类产品：Apple
  具体产品NorthApple：

代码实现：

public abstract  class Apple implements Fruit {
    public abstract  void get();
}
******************************************************************
//香蕉类
public  abstract class  Banana implements Fruit {
    public abstract void get();
}
******************************************************************

//水果接口
interface Fruit {
    void get();
}
******************************************************************

public class NorthApple extends Apple {
    @Override
    public void get() {
        System.out.println("采集北方苹果");
    }
}
******************************************************************


public class NorthBanana extends Banana {
    @Override
    public void get() {
        System.out.println("采集北方香蕉");
    }
}

******************************************************************

public class SourthApple extends Apple {
    @Override
    public void get() {
        System.out.println("采集南方苹果");
    }
}
******************************************************************

public class SourthBanana extends Banana {
    @Override
    public void get() {
        System.out.println("采集南方香蕉");
    }
}
******************************************************************

public class NorthFactory implements FruitFactory {
    @Override
    public Fruit getApple() {
        return new NorthApple();
    }

    @Override
    public Fruit getBanana() {
        return new NorthBanana();
    }
}
******************************************************************

public class SourthFactory implements FruitFactory {
    @Override
    public Fruit getApple() {
        return new SourthApple();
    }

    @Override
    public Fruit getBanana() {
        return new SourthBanana();
    }
}
******************************************************************


/**
 * 抽象工厂对应产品的结构，具体工厂对应的产品族
 * 产品族中是苹果和香蕉
 * 产品结构中是北方和南方
 *
 * 相当于结构中类产品中多个产品线
 *
 * 抽象工厂接口FruitFactory，产生多个结构的声明
 * 具体工厂类NorthFactory：实现抽象工厂接口，具体实例化这个结构的实例对象
 *
 * 抽象产品接口Fruit：
 *
 * 抽象类产品：Apple
 *
 * 具体产品NorthApple：
 *
 */
public interface FruitFactory {
    //对应产结构：南方还是北方，具体的工厂可以分别获取北方中的苹果和香蕉这个产品族
    public Fruit getApple();

    public Fruit getBanana();
}

测试：

public class MainClass {
    public static void main(String[] args) {
        FruitFactory fruitFactory = new NorthFactory();
        Fruit apple = fruitFactory.getApple();
        Fruit banana = fruitFactory.getBanana();
        apple.get();
        banana.get();


        SourthFactory sourthFactory = new SourthFactory();
        Fruit apple1 = sourthFactory.getApple();
        apple1.get();
        Fruit banana1 = sourthFactory.getBanana();
        banana1.get();
    }
}

 

扩展：增加一个结构：比如温室苹果

扩展：增加一个水果族：比如菠萝需要改动比较多

 

案例二：

 

public class AbstractClient {

    public static void main(String[] args) {
        getPizza();
    }

    //选择产地;
    public static void getPizza(){
        AbstractClient pizzaShop=new AbstractClient();
        String gettype = pizzaShop.gettype();
        if(gettype.equals("北京")){
            new ToOrderPizza(new BJFactory());
        }else if(gettype.equals("伦敦")){
            new ToOrderPizza(new LDFactory());
        }else {
            System.out.println("抱歉,暂时不提供该产地");
        }
    }

    //输入选择生产地;
    private String gettype() {
        try {
            BufferedReader strs = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("输入订购的披萨产地(目前仅提供北京/伦敦):");
            String str = strs.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

abstract class Pizza {
    protected String name;

    //制作披萨时准备原材料的工作;
    public abstract void prepare();

    //烘烤披萨;
    public void bake() {
        System.out.println(name + " 烘焙中...;");
    }

    //披萨切片;
    public void cut() {
        System.out.println(name + " 切片中.....;");
    }

    //披萨包装;
    public void box() {
        System.out.println(name + " 打包....;");
    }

    //为披萨设置种类名;
    public void setName(String name) {
        this.name = name;
    }

}

class BJChessPizza  extends Pizza {
    @Override
    public void prepare() {
        setName("北京奶酪味披萨");
        System.out.println("北京生产的奶酪味披萨准备工作==>;");
    }
}

class BJPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京胡椒味披萨");
        System.out.println("北京生产的胡椒味披萨准备工作==>;");
    }
}

class LDChessPizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦奶酪味披萨");
        System.out.println("伦敦生产的奶酪味披萨准备工作==>;");
    }
}

class LDPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦胡椒味披萨");
        System.out.println("伦敦生产的胡椒味披萨准备工作==>;");
    }
}

interface AbstractFactory {
    Pizza createPizza(String operatType);
}

class BJFactory implements AbstractFactory{

    @Override
    public Pizza createPizza(String operatType) {
        if (operatType.equalsIgnoreCase("chiness")) {
            return new BJChessPizza();
        } else if (operatType.equalsIgnoreCase("pepper")) {
            return new BJPepperPizza();
        }
        return null;

    }
}

class LDFactory implements AbstractFactory {
    @Override
    public Pizza createPizza(String operatType) {
        if (operatType.equalsIgnoreCase("chiness")) {
            return new LDChessPizza();
        } else if (operatType.equalsIgnoreCase("pepper")) {
            return new LDPepperPizza();
        }
        return null;

    }
}

/**
 * 订购类
 */
class ToOrderPizza {
    private AbstractFactory abstractFactory;

    public ToOrderPizza(AbstractFactory abstractFactory) {
        setAbstractFactory(abstractFactory);
    }

    private void setAbstractFactory(AbstractFactory abstractFactory) {
        Pizza pizza=null;
        String orderType="";

        this.abstractFactory = abstractFactory;
        do {
            orderType=gettype();
            pizza=this.abstractFactory.createPizza(orderType);
            if(pizza!=null) {
                //披萨制作;
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else{
                System.out.println("<----没有该种类披萨,订购失败---->");
                break;
            }
        }while (true);
    }


    //获取披萨的种类;
    private String gettype() {
        try {
            BufferedReader strs = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("输入订购的披萨种类:");
            String str = strs.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}