首页 › 程序设计 › java

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

磊@lei / 文 发表于2018-05-18 16:16 次阅读 设计模式,java

一、工厂模式

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

工厂模式

二、示例

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

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


/**
 * 披萨抽象对象,实现公共方法,抽象差异化的方法
 */
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设计模式所有示例代码,持续更新中

收藏 赞 (0) 踩 (0)