设计模式真香笔记-工厂模式

工厂模式分类

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

工厂模式的作用

工厂模式：是为了将对象的创建和调用者分开，实现解耦，也就是将繁琐的对象的创建由工厂来实现。

简单工厂（并不是设计模式，而是一种习惯）

简单工厂也叫静态工厂，通过简单工厂类的静态方法传入不同的参数来返回不同的所需要的对象。
缺点：

1. 虽然工厂不需要创建实例来调用方法，但是不同通过继承来改变创建方法的行为。
2. 新增加的对象 需要修改工厂类的代码来实现。
   代码实现

• 披萨的抽象类

public abstract class Pizza {

    /**
     * 看吃的什么披萨
     */
    protected  abstract void eat();
}

• 披萨的实现类

public class BaoleziPizza extends Pizza {

    @Override
    public void eat() {
        System.out.println("保乐兹披萨有点难吃呀！");
    }
}

• 披萨的实现类

public class HualaishiPizza extends Pizza {

    @Override
    public void eat() {
        System.out.println("华莱士披萨还行吧！");
    }
}

• 简单工厂类

public class SimplePizzaFactory {
    public static Pizza createPizza(String type){
        Pizza pizza=null;
        if (type.equals("baolezi")) {
            pizza = new BaoleziPizza();
        }else if(type.equals("hualaishi")){
            pizza = new HualaishiPizza();
        }else {
            return null;
        }
        return pizza;
    }
}

• 简单工厂的测试类

public class SimplePizzaTest {
    public static void main(String[] args) {
        Pizza pizza = SimplePizzaFactory.createPizza("baolezi");
        pizza.eat();
        pizza = SimplePizzaFactory.createPizza("hualaishi");
        pizza.eat();
    }


}

工厂方法模式

工厂方法模式：定义一个创建对象的借口，由子类决定要实例化哪一个类，工厂方法把实例化推迟到子类。
优缺点：工厂方法模式更加符合开闭原则，但是每次扩展会增加新的类
设计原则
依赖倒转原则：要依赖抽象，不要依赖具体类。
依赖倒转原则的指导方针（尽量达到，而不是必须遵守）

• 变量不可以持有具体类的引用 （如果使用new，就是持有具体类的引用，改用工厂来避免）
• 不要让派生类来自于具体类 （让派生类来自于抽象类或者接口）
• 不要覆盖基类中已实现的方法（基类中的已经实现的方法，应该由所有的子类共享）
  UML类图
  
  代码实现
• Pizza抽象类

public abstract class Pizaa {
    String name;

    ArrayList list=new ArrayList();
    void prepare() {
        System.out.println("---准备做:"+name+"披萨");
        for(Object adds:list){
            System.out.println("---添加"+adds.toString());
        }
    }
    void bake() {
        System.out.println("---烤20分钟");
    }
    void cut() {
        System.out.println("---披萨切块");
    }

    void box() {
        System.out.println("---打包装盒");
    }

    public String getName() {
        return name;
    }
}

• 具体Pziaa

public class BaoleziMalaPizza extends  Pizaa {
    public BaoleziMalaPizza(){
        name = "BaoleziMalaPizza";
        list.add("Bmala酱");
    }

}

• 具体pizza

public class BaoleziZhishiPizza extends  Pizaa {
    public BaoleziZhishiPizza(){
        name = "BaoleziZhishiPizza";
        list.add("Bzhishi酱");
    }

}

• 具体pizza

public class HualaishiMalaPizza extends  Pizaa {
    public HualaishiMalaPizza(){
        name = "HualaishiMalaPizza";
        list.add("Hmala酱");
    }

}

• 具体pizza

public class HualaishiZhishiPizza extends  Pizaa {
    public HualaishiZhishiPizza(){
        name = "HualaishiMalaPizza";
        list.add("Hzhishi酱");
    }

}

• pizza工厂抽象类，有工厂方法需要子类去实现

public abstract class PizzaStore {
        public Pizaa orderPizza(String type) {
            Pizaa pizaa;
            pizaa=createPizza(type);
            pizaa.prepare();
            pizaa.bake();
            pizaa.cut();
            pizaa.box();
            return pizaa;
        }

    protected abstract Pizaa createPizza(String type);//这就是 工厂方法由子类实现
}

• 子类工厂

public class BaoleziPizzaStore extends PizzaStore {

    @Override
    protected Pizaa createPizza(String type) {
        if (type.equals("mala")) {

            return new BaoleziMalaPizza();
        }else if(type.equals("zhishi")){
            return new BaoleziZhishiPizza();
        }else {
            return null;
        }
    }
}

• 另一个子类工厂

public class HualaishiPizzaStore extends PizzaStore {

    @Override
    protected Pizaa createPizza(String type) {
        if (type.equals("mala")) {

            return new HualaishiMalaPizza();
        }else if(type.equals("zhishi")){
            return new HualaishiZhishiPizza();
        }else {
            return null;
        }
    }
}

• 工厂模式测试类

public class PizzaTest {
    public static void main(String[] args) {
        PizzaStore hualaishipizza = new HualaishiPizzaStore();
        PizzaStore baoleziPizza = new BaoleziPizzaStore();
        Pizaa pizaa = hualaishipizza.orderPizza("mala");
        System.out.println("---完成"+pizaa.getName()+"的制作"+"
");

        pizaa = baoleziPizza.orderPizza("mala");
        System.out.println("---完成"+pizaa.getName()+"的制作");
    }
}

• 输出结果
  

抽象工厂模式

抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不是需要明确指定具体类的。
优缺点：能增加产品工厂，而不能增加产品

代码实现：

• 披萨产品接口及其实现

public interface Pizza {//披萨接口
    void eat();
}
class  ExpensivePizza implements  Pizza{

    @Override
    public void eat() {
        System.out.println("贵的披萨巨好吃！");
    }
}

class CheapPizza implements Pizza {
    @Override
    public void eat() {
        System.out.println("便宜的披萨");
    }
}

• 酱料产品接口及其实现

public interface Souce {//酱料接口
        void addSouce();
}

class ExpensiveSouce implements Souce {

    @Override
    public void addSouce() {
        System.out.println("贵的酱料");
    }
}
class CheapSouce implements Souce {

    @Override
    public void addSouce() {
        System.out.println("便宜的酱料");
    }
}

• 披萨抽象工厂

public  interface AbstractPizzaFactory {//抽象工厂
   Pizza createPizza();
   Souce createSouce();
}

• 具体高级工厂

public class ExpensiveFactory implements  AbstractPizzaFactory {//具体工厂

    @Override
    public Pizza createPizza() {
        return new ExpensivePizza();
    }

    @Override
    public Souce createSouce() {
        return new ExpensiveSouce();
    }
}

• 具体低级工厂

public class CheapFactory implements AbstractPizzaFactory {//具体工厂

    @Override
    public Pizza createPizza() {
        return new CheapPizza();
    }

    @Override
    public Souce createSouce() {
        return new CheapSouce();
    }
}

• 测试类

public class AbstractPizzaTest {
    public static void main(String[] args) {
        AbstractPizzaFactory expensiveFactory = new ExpensiveFactory();
        Pizza pizza = expensiveFactory.createPizza();
        pizza.eat();
    }
}

测试结果

总结

• 简单工厂是一方法，可以将客户程序解耦具体类
• 工厂方法使用继承把对象的创建委托给子类
• 工厂模式减少应用程序和具体类之间的依赖促进松耦合
• 依赖倒转原则，依赖具体类型，而要尽量依赖抽象
• 针对抽象编程，而不是针对具体类编程