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设计模式所有示例代码,持续更新中

评论

暂无评论