简单工厂模式

对比学习headfirst和大话设计模式里面的经典模型

headfirst上用的是生产披萨的例子来说明工厂模式,工厂模式适用于生产某个类下的不同子类对象,例如Pizza类下的cheesePizza和VeggiaePizza,本质上都是披萨,只是特点不同,对于根据参数而生产不同对象的形式就很适合用简单工厂模式,避免将这个选择判断的过程写在主程序里面,因为抽取后还可以在其他地方使用。if..else if..也可以用switch case来代替。

package headfirst.factory.pizzas;

public class SimplePizzaFactory {

	public Pizza createPizza(String type) {
		Pizza pizza = null;

		if (type.equals("cheese")) {
			pizza = new CheesePizza();
		} else if (type.equals("pepperoni")) {
			pizza = new PepperoniPizza();
		} else if (type.equals("clam")) {
			pizza = new ClamPizza();
		} else if (type.equals("veggie")) {
			pizza = new VeggiePizza();
		}
		return pizza;
	}
}

披萨类是一个抽象类,目的就是为了让各个子类去继承实现,所以设置为抽象,但是抽象类里面并没有抽象方法,只是单纯的不想被生成,只想被继承。这也就是为啥抽象类中没有抽象方法的一个典型例子。

package headfirst.factory.pizzas;

import java.util.ArrayList;

abstract public class Pizza {
	String name;
	String dough;
	String sauce;
	ArrayList toppings = new ArrayList();

	public String getName() {
		return name;
	}

	public void prepare() {
		System.out.println("Preparing " + name);
	}

	public void bake() {
		System.out.println("Baking " + name);
	}

	public void cut() {
		System.out.println("Cutting " + name);
	}

	public void box() {
		System.out.println("Boxing " + name);
	}

	public String toString() {
		// code to display pizza name and ingredients
		StringBuffer display = new StringBuffer();
		display.append("---- " + name + " ----\n");
		display.append(dough + "\n");
		display.append(sauce + "\n");
		for (int i = 0; i < toppings.size(); i++) {
			display.append((String )toppings.get(i) + "\n");
		}
		return display.toString();
	}
}

披萨的子类实现如下,只用写一个构造方法,将一些成员变量初始化一下就行。

package headfirst.factory.pizzas;

public class ClamPizza extends Pizza {
	public ClamPizza() {
		name = "Clam Pizza";
		dough = "Thin crust";
		sauce = "White garlic sauce";
		toppings.add("Clams");
		toppings.add("Grated parmesan cheese");
	}
}

这样主程序中只需要有一个工厂对象就可以了。在工厂对象中输入对应的字符串就可以生成对应不同品种的披萨,返回给抽象类披萨Pizza接收,多态可以解耦。以后再新增不同的披萨品种就可以不改动主程序,直接写好新品种pizza类,并修改一下工厂类,在里面多加一种判断情况就可以了

package headfirst.factory.pizzas;

public class PizzaStore {
	SimplePizzaFactory factory;
 
	public PizzaStore(SimplePizzaFactory factory) { 
		this.factory = factory;
	}
 
	public Pizza orderPizza(String type) {
		Pizza pizza;
 
		pizza = factory.createPizza(type);
 
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();

		return pizza;
	}

}

工厂模式适用于生产某个类下的不同子类对象,例如Pizza类下的cheesePizza和VeggiaePizza,本质上都是披萨,只是特点不同,对于根据参数而生产不同对象的形式就很适合用简单工厂模式,避免将这个选择判断的过程写在主程序里面,因为抽取后还可以在其他地方使用。if..else if..也可以用switch case来代替。工厂类的好处如下:

而大话设计模式里面用的是设计计算器的例子,里面也涉及到了运算符这个抽象类,他下面可以有加法,减法,乘法,除法四个子类,也是根据输入的参数来生产对应的运算符对象,也是类似的处理形式,区别在于,披萨那里是将工厂设为成员变量,构造方法里面初始化,而这里的工厂就是一个普通的变量形式处理就行了。

 

public class Calculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数A");
        double numberA = scanner.nextDouble();
        System.out.println("请输入第二个数B");
        double numberB = scanner.nextDouble();
        System.out.println("请输入要进行的运算");
        scanner.nextLine();
        String operator = scanner.nextLine();

        //工厂类(静态)方法产生所需的运算符对象
        Operation operation = OperationFactory.createOperation(operator);

        operation.numberA = numberA;
        operation.numberB = numberB;


        System.out.println("运算结果为" + operation.result());


    }

}
public abstract class Operation {
    public double numberA;
    public double numberB;

    public abstract double result();
}

同样是抽象的运算符类,类似于抽象类Pizza,工厂类用switch的形式实现

public class OperationFactory {
    public static Operation createOperation(String operator) {
        Operation operation = null;
        switch (operator) {
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
                break;
            default:
                throw new RuntimeException("unsupported operation");

        }
        return operation;

    }
}

具体的运算符乘法,实现抽象类运算符

public class OperationMul extends Operation {
    @Override
    public double result() {
        return numberA * numberB;
    }
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值