Java 设计模式(5) —— 工厂模式

一、工厂模式

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

二、示例

披萨项目：有一家披萨店，有很多种口味的披萨，但是这些披萨除了准备工作不同，后续的烘焙，切割，打包等方法都是相同的

用传统的面向对象模式，则在用户订单类中根据不同的订单要求，生产出不同的披萨

/**
 * 披萨抽象对象，实现公共方法，抽象差异化的方法
 */
public abstract class Pizza {
    protected String name;
    public abstract void prepare();
    public void bake() {
        System.out.println(name + " baking;");
    }
    public void cut() {
        System.out.println(name + " cutting;");
    }
    public void box() {
        System.out.println(name + " boxing;");
    }
    public void setname(String name) {
        this.name = name;
    }
}

/**
 * 披萨订单类，OO模式，统一在订单类中进行分类生产
 */
public class OrderPizza {
    public OrderPizza() {
        Pizza pizza = null;
        String ordertype;
        do {
            ordertype = gettype();
            if (ordertype.equals("cheese")) {
                pizza = new CheesePizza();
            } else if (ordertype.equals("greek")) {
                pizza = new GreekPizza();
            } else if (ordertype.equals("pepper")) {
                pizza = new PepperPizza();
            } else if (ordertype.equals("chinese")) {
                pizza = new ChinesePizza();
            } else {
                break;
            }
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }
    private String gettype() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(
                    System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

缺点：无清晰的模块分离，生产与使用方法混在一起

三、简单工厂模式

定义了一个创建对象的类，由这个类来封装实例化对象的行为

/**
 * 简单工厂模式，将生产方法抽离出单独的类进行生产
 */
public class SimplePizzaFactory {
    public Pizza CreatePizza(String ordertype) {
        Pizza pizza = null;
        if (ordertype.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (ordertype.equals("greek")) {
            pizza = new GreekPizza();
        } else if (ordertype.equals("pepper")) {
            pizza = new PepperPizza();
        }
        return pizza;
    }
}

将生产方法单独用一个类处理，进行简单的模块分离

缺点：不利于拓展多个不同的工厂方法

四、工厂方法模式

定义了一个创建对象的抽象方法，由子类决定要实例化的类。

披萨项目中，若在各地开了分店，但是每个地区的人喜好不同，因此就得区分不同的工厂进行生产。

• 利用工厂方法模式将对象的实例化抽象到了子类，利用对象之间的继承关系实现差异的工厂方法

/**
 * 工厂方法对象，给不同的工厂继承
 */
public abstract class OrderPizza {
    public OrderPizza() {
        Pizza pizza = null;
        String ordertype;
        do {
            ordertype = gettype();
            pizza = createPizza(ordertype);
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }
    abstract Pizza createPizza(String ordertype);
    private String gettype() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(
                    System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

/**
 * 伦敦工厂，继承工厂方法对象
 */
public class LDOrderPizza extends OrderPizza {
    @Override
    Pizza createPizza(String ordertype) {
        Pizza pizza = null;
        if (ordertype.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (ordertype.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

/**
 * 纽约工厂，继承工厂方法对象
 */
public class NYOrderPizza extends OrderPizza {
    @Override
    Pizza createPizza(String ordertype) {
        Pizza pizza = null;
        if (ordertype.equals("cheese")) {
            pizza = new NYCheesePizza();
        } else if (ordertype.equals("pepper")) {
            pizza = new NYPepperPizza();
        }
        return pizza;
    }
}

需要使用哪种工厂就初始化哪种

OrderPizza mOrderPizza = new NYOrderPizza();

缺点：继承关系使对象之间的依赖性较高

五、抽象工厂模式

定义了一个接口用于创建相关或有依赖关系的对象族，而无需明确 指定具体类

1.定义一个工厂的接口方法

/**
 * 工厂方法的抽象接口
 */
public interface AbsFactory {
    public Pizza CreatePizza(String ordertype) ;
}

2.各工厂实现工厂方法

/**
 * 伦敦工厂实现抽象方法
 */
public class LDFactory implements AbsFactory {
    @Override
    public Pizza CreatePizza(String ordertype) {
        Pizza pizza = null;
        if (ordertype.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (ordertype.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

3.利用抽象接口在统一订单对象中进行方法调用

/**
 * 抽象工厂模式，直接利用抽象工厂进行对象生产
 */
public class OrderPizza {
    // 抽象接口
    AbsFactory mFactory;
    public OrderPizza(AbsFactory mFactory) {
        setFactory(mFactory);
    }
    public void setFactory(AbsFactory mFactory) {
        Pizza pizza = null;
        String ordertype;
        this.mFactory = mFactory;
        do {
            ordertype = gettype();
            pizza = mFactory.CreatePizza(ordertype);
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }
        } while (true);
    }
    private String gettype() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(
                    System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

4.使用哪种工厂就进行哪种工厂的初始化

/**
 * 抽象工厂模式，不同的工厂实现不同的生产方法
 * 引用工厂的时候直接引用接口对象
 */
public class PizzaStroe {
    public static void main(String[] args) {
        OrderPizza mOrderPizza;
        mOrderPizza=new OrderPizza(new LDFactory());
    }
} 

优点：利用接口进行方法抽象，对象之间耦合度较低，又可实现同种方法内部不同的处理方式。

• 依赖抽象原则

  • 变量不要持有具体类的引用

  • 不要让类继承自具体类，要继承自抽象类或接口

  • 不要覆盖基类中已实现的方法

Java设计模式所有示例代码，持续更新中