工厂模式-C-工厂方法

傷城~ 2022-07-12 12:17 163阅读 0赞

package D\_Factory.c;

/\*\*  
\*工厂方法模式： 定义一个创建对象的接口，但由子类决定要实例化的类是哪一个，工厂方法让类把实例化推迟到子类  
\*依赖倒置原则:要依赖抽象，不要依赖具体类，不能让高层组件依赖底层组件，高层和底层都应该依赖于抽象  
\*在应用工厂方法之后，高层组件(pizzaStore)和底层组件(具体的pizza类)都依赖Pizza抽象，遵循了此原则  
\*指导方针：  
\* 1：变量不能持有具体类的引用(如果采用new就会持有具体类的引用，可以采用工厂避免)  
\* 2：不要让类派生自具体类(如果派生自具体类就会依赖具体类)  
\* 3：不要覆盖基类中已实现的方法(如果覆盖基类已实现的方法，那么基类就不是适合被继承的抽象，基类中的实现方法，应该由子类共享)  
\*/  
public class Main \{

public static void main(String[] args) {
        ChicagoPizzaStore chicagoPizzaStore = new ChicagoPizzaStore();
        Pizza orderPizza = chicagoPizzaStore.orderPizza("pepperoni");
        System.out.println(orderPizza.getName());
    }

\}  
package D\_Factory.c;

public class ChicagoPizzaStore extends PizzaStore \{  
public Pizza createPizza(String type) \{  
Pizza pizza = null;  
if (type.equals(“cheese”)) \{  
pizza = new NYStyleCheesePizza();  
\} else if (type.equals(“pepperoni”)) \{  
pizza = new NYStylePepperoniPizza();  
\}  
return pizza;  
\}  
\}  
package D\_Factory.c;

public interface Dough \{

\}  
package D\_Factory.c;

public class NYStyleCheesePizza extends Pizza \{

public NYStyleCheesePizza() {
        name = "NYStyleCheesePizza";
    }

\}  
package D\_Factory.c;

public class NYStylePepperoniPizza extends Pizza \{  
public NYStylePepperoniPizza() \{  
name = “NYStylePepperoniPizza”;  
\}  
\}  
package D\_Factory.c;

public abstract class Pizza \{  
public String name;  
public Dough dough;  
public String sauce;  
public String cheese;  
public String clam;

public void prepare() {
        System.out.println("prepare");
    }
    
    public void bake() {
        System.out.println("bake");
    }
    
    public void cut() {
        System.out.println("cut");
    }
    
    public void box() {
        System.out.println("box");
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }

\}  
package D\_Factory.c;

/\*\*  
\* 由于做披萨做法有差异，使用其他厂商的盒子等等  
\* 解决让披萨制作局限于pizzaStore类，同时又能让加盟店依然可以自由制作该地区风味的披萨  
\*/  
public abstract class PizzaStore \{

public final Pizza orderPizza(String type) {
        Pizza pizza;
        pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    
    // 让子类决定创建何种口味风格的披萨,此方法如同工厂
    //工厂方法用来处理对象的创建，并将这样的行为封装在子类中，这样客户程序中关于超类的代码和子类对象创建代码解耦了
    protected abstract Pizza createPizza(String type);