02. 02-工厂模式

0.例子基本介绍

看一个披萨的项目:要便于扩展,要便于维护

1. 披萨的种类很多(GreekPizza,CheesePizza…)
2. 披萨的制作有preapare,bake,cut,box
3. 完成披萨店的订购功能

---

1 简单工厂模式

• 基本介绍

1. 简单工厂模式属于创建型模式,是工厂模式的一种,简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例,简单工厂模式是工厂模式家族中最简单实用的模式
2. 简单工厂模式 :

定义了一个创建对象的类,由这个类来封装实例化对象的行为

3. 在软件开发中,当我们会用到大量的创建某种,某类或某批对象时,就会使用到工厂模式

---

1.1 代码

• SimpleFactory

public class SimpleFactory {
    //static 类方法
    public static Pizza createPizza(String pizzaName){
        Pizza pizza = null;
        switch (pizzaName){
            case "GreekPizza" :
                pizza = new GreekPizza();
                pizza.setName("希腊披萨");
                break;
            case "PepperPizza" :
                pizza = new PepperPizza();
                pizza.setName("胡椒披萨");
                break;
            default:
                System.out.println("没有这个种类的披萨");
        }
        return pizza;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• PizzaStore

使用简单工厂方法

private static void simpleFactoryTest(){
        do {
            String pizzaName = getType();
            Pizza pizza = SimpleFactory.createPizza(pizzaName);
            if (pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                System.out.println("订购披萨失败");
                break;
            }
        }while (true);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

• 如果要增加新的种类,只需要对简单工厂类进行修改

---

2.工厂方法模式

1. 新的需求 :

客户在点披萨时,可以点不同口味的披萨.比如 北京的奶酪pizza,北京的胡椒pizza,或者伦敦的奶酪pizza,伦敦的胡椒pizza.

2.思路

1. 使用简单工厂模式,创建不同的简单工厂类,比如:BJPizzaSimpleFactory,LDPizzaSimpleFactory 等等.从当前这个案例来说,也是可以的,但是考虑到项目的规模,以及软件的可维护性,可扩展性不是特别好
2. 使用工厂方法模式.

---

1. 工厂方法模式介绍

1. 工厂方法模式设计方案 :

将披萨项目的实例化功能抽象成抽象方法,在不同的口味点餐子类中具体实现.

2.工厂方法模式 :

定义了一个创建对象的抽象方法,由子类决定要实例化的类.工厂方法模式将对象的实例化推迟到子类

---

2. 代码

• OrderPizza

abstract Pizza createPizza(String orderType);
1

• LDOrderPizza

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();
		}
		// TODO Auto-generated method stub
		return pizza;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• main

public class PizzaStore {

	public static void main(String[] args) {
		String loc = "bj";
		if (loc.equals("bj")) {
			//创建北京口味的各种Pizza
			new BJOrderPizza();
		} else {
			//创建伦敦口味的各种Pizza
			new LDOrderPizza();
		}
		// TODO Auto-generated method stub
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

3. 抽象工厂模式

1. 抽象工厂模式

定义了一个interface用于创建相关或有依赖关系的对象簇,而无需知名具体的类

2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合.
3. 从设计层面看,抽象工厂模式就是对简单工厂模式的改进(或者成为进一步的抽象)
4. 将工厂抽象成两层,ABSFactory(抽象工厂)和具体实现的工厂子类. 程序员可以根据创建对象类型使用对应的工厂子类.这样讲单个的简单工厂类变成了工厂簇,更利于代码的维护和扩展.
5. 类图
   

---

3.1代码

• AbsFactory

//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
    //让下面的工厂子类来具体实现
    public Pizza createPizza(String orderType);
}
1
2
3
4
5

• BJFactory

// 实现接口的方法
public class BJFactory implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("~使用的是抽象工厂模式~");
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new BJCheesePizza();
        }else if (orderType.equals("pepper")){
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• OrderPizza

public class OrderPizza {
    AbsFactory factory;
    public OrderPizza(AbsFactory factory){
        setFactory(factory);
    }

    private void setFactory(AbsFactory factory){
        System.out.println("setFactory");
        Pizza pizza = null;
        String orderType = "";
        this.factory = factory;
        do {
            orderType = getType();
            // factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
            pizza = factory.createPizza(orderType);
            if (pizza != null) { // 订购ok
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购失败");
                break;
            }
        } while (true);
    }
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

• main

public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza(new BJFactory());
    }
}
1
2
3
4
5

4.工厂模式小结

1. 工厂模式的意义

将实例化对象的代码提取出来,放到一个类中统一管理和维护,达到主项目的依赖关系的解耦.从而提高项目的扩展和维护性.

2. 三种工厂模式

1. 简单工厂模式
2. 工厂方法模式
3. 抽象工厂模式

3.设计模式的依赖抽象原则

1. 创建对象实例时,不要直接new 类, 而是把这个new 类的动作放在一个工厂的方法中,并返回.(变量不要直接持有具体类的引用)
2. 不要让类继承具体类,而是继承抽象类或者实现interface(接口)
3. 不要覆盖基类中已经实现的方法.