第4章 工厂模式
在介绍工厂模式之前，先让我们来看一个例子。
这里有一个Pizza类，用来生产pizza，并返回对象，具体代码如下：
package com.ek.factory.simple; import com.ek.factory.Pizza;
import com.ek.factory.pizza.CheesePizza;
import com.ek.factory.pizza.GreekPizza;
import com.ek.factory.pizza.PepperoniPizza; /**
* @包名 com.ek.factory.simple
* @文件名 PizzaStore.java
* @作者 edi_kai
* @创建日期 2015年8月25日
* @版本 V 1.0
* @描述
*/
public class PizzaStore { Pizza pizza;
public Pizza orderPizza(String type) { if (type.equals("cheese")) {
this.pizza = new CheesePizza();
}else if (type.equals("greek")) {
this.pizza = new GreekPizza();
}else if (type.equals("pepperoni")) {
this.pizza = new PepperoniPizza();
} this.pizza.prepare();
this.pizza.bake();
this.pizza.cut();
this.pizza.box(); return this.pizza;
}
}
这代码有什么问题呢？如果我在添加一种类型的pizza或者某种pizza卖的不好我想下架，这时候，我们就只能去修改PizzaStore这个类，当只有一个pizza商店的时候或许觉不出什么问题来，但是，当我们有好几个连锁店的时候，必须去修改每个PizzaStore类，这是有悖设计原则的，面向修改关闭，面向扩展开放。
那么我们接下来又该怎么修改呢？想一下，OO的设计原则（找出代码中需要变化的地方，将其独立出来，与不变的代码相分离，以便日后维护和扩展），接下我们对代码进行优化，进而得到了经过简单工厂模式设计之后的类图和代码，如下：
package com.ek.factory.simple; import com.ek.factory.Pizza;
import com.ek.factory.pizza.CheesePizza;
import com.ek.factory.pizza.GreekPizza;
import com.ek.factory.pizza.PepperoniPizza; /**
* @包名 com.ek.factory.simple
* @文件名 SimplePizzaFactory.java
* @作者 edi_kai
* @创建日期 2015年8月25日
* @版本 V 1.0
* @描述 这是pizza的简单工厂
*/
public class SimplePizzaFactory { Pizza pizza; public Pizza createPizza(String type){
if (type.equals("cheese")) {
this.pizza = new CheesePizza();
}else if (type.equals("greek")) {
this.pizza = new GreekPizza();
}else if (type.equals("pepperoni")) {
this.pizza = new PepperoniPizza();
}
return this.pizza;
} }
package com.ek.factory.simple; import com.ek.factory.Pizza; /**
* @包名 com.ek.factory.simple
* @文件名 PizzaStore.java
* @作者 edi_kai
* @创建日期 2015年8月25日
* @版本 V 1.0
* @描述 这是修改后的PizzaStore
*/
public class PizzaStore { SimplePizzaFactory factory; public PizzaStore(SimplePizzaFactory factory) {
super();
this.factory = factory;
} public Pizza orderPizza(String type) { Pizza pizza = this.factory.createPizza(type); pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box(); return pizza;
}
}
这就是一个简单的工厂模式，简单工厂模式其实并不是一个设计模式，更像是一种编程习惯。
简单工厂模式算是最容易理解的工厂模式了，说完了简单工厂模式，让我们来分别看看它的两个延伸，工厂方法模式和抽象工厂模式。
在介绍模式之前，我们先来模拟一个需求场景，现在的汽车越来越多，那么汽车是怎么生产的呢？首先，你得有一个汽车生产工厂，然后，确定来生产什么牌子的汽车（国产车，美系车，德国车，韩系车）。不同的牌子需要由对应的工厂来生产汽车。
1丶工厂方法模式
定义：定义了一个创建对象的接口，但是由子类来决定实例化的是哪一个对象。工厂方法让类把实例化推迟到了子类中。
工厂模式对应的类图如下
类图对应的代码如下：
/**
* Project Name: head first
* File Name: CarFactory.java
* Package Name: com.ek.factory_2
* Reason: 抽象工厂
* Date: 2015年9月7日上午12:19:10
* Copyright (c) 2015, edi_kai All Rights Reserved.
* @author: edi_kai
* @version: v1.1
* @since: JDK 1.7
*/
package com.ek.factory_2; import com.ek.factory_2.product.Car; public interface CarFactory {
Car createCar(String type);
}
/**
* Project Name: head first
* File Name: ChineseCarFactory.java
* Package Name: com.ek.factory_2
* Reason: 具体工厂-国产车.
* Date: 2015年9月7日上午12:24:20
* Copyright (c) 2015, edi_kai All Rights Reserved.
* @author: edi_kai
* @version: v1.1
* @since: JDK 1.7
*/
package com.ek.factory_2; import com.ek.factory_2.product.Car;
import com.ek.factory_2.product.NormalCarBorui;
import com.ek.factory_2.product.SUVCarBYDsong; public class ChineseCarFactory implements CarFactory { @Override
public Car createCar(String type) { if ("borui".equalsIgnoreCase(type)) {
return new NormalCarBorui();
}else if ("song".equalsIgnoreCase(type)) {
return new SUVCarBYDsong();
} return null;
} }
/**
* Project Name: head first
* File Name: KoreaCarFactory.java
* Package Name: com.ek.factory_2
* Reason: 具体工厂-韩系车.
* Date: 2015年9月7日上午12:28:08
* Copyright (c) 2015, edi_kai All Rights Reserved.
* @author: edi_kai
* @version: v1.1
* @since: JDK 1.7
*/
package com.ek.factory_2; import com.ek.factory_2.product.Car;
import com.ek.factory_2.product.NormalCarELartra;
import com.ek.factory_2.product.NormalCarSonata; public class KoreaCarFactory implements CarFactory { @Override
public Car createCar(String type) { if ("sonata".equalsIgnoreCase(type)) {
return new NormalCarSonata();
}else if ("elartra".equalsIgnoreCase(type)) {
return new NormalCarELartra();
} return null;
} }
/**
* Project Name: head first
* File Name: Main.java
* Package Name: com.ek.factory_2.main
* Reason: 测试代码.
* Date: 2015年9月7日上午12:31:42
* Copyright (c) 2015, edi_kai All Rights Reserved.
* @author: edi_kai
* @version: v1.1
* @since: JDK 1.7
*/
package com.ek.factory_2.main; import com.ek.factory_2.CarFactory;
import com.ek.factory_2.ChineseCarFactory;
import com.ek.factory_2.KoreaCarFactory;
import com.ek.factory_2.product.Car; public class Main { public static void main(String[] args) {
CarFactory ccf = new ChineseCarFactory();
Car song = ccf.createCar("song"); CarFactory kcf = new KoreaCarFactory();
Car sonata = kcf.createCar("sonata"); song.getName();
song.getBrand();
song.getColor(); sonata.getName();
sonata.getBrand();
sonata.getColor();
} }
工厂方法模式的特点：
1）针对统一个产品等级，不存在父子级关系（看一下抽象工厂模式的类图即可明白）；
2）只有一个抽象产品类，所有的产品都实现/继承自该抽象类（Car）；
3）所有的具体产品类按具体的工厂类分类，当需要添加新类别的产品时，只需要添加一个具体工厂类即可（如类图中，Sonata属于韩系车，添加KoreaCarFactory实现 CarFactory即可），易于扩展，并完全符合开闭原则的！；
工厂方法模式总结：
工厂方法模式足以应付我们可能遇到的大部分业务需求。但是当产品种类非常多时，就会出现大量的与之对应的工厂类，这不应该是我们所希望的（就如同下面我们要 说的场景）。那么这种情况下就可能需要使用抽象工厂模式了。
现在需求改变了，不仅需要按照国家来生产汽车，还要按照用途来生产（私家轿车/SUV/MPV/货车）；这个需求中汽车出现了多级产品树，如果在继续使用工厂方法模式会有大量的代码，不利于后期维护，所以，这个时候我们就应该想到抽象工厂模式，来解决这个问题。
2丶抽象工厂模式
抽象工厂模式定义：抽象一个接口用来创建相关或依赖对象的家族，而不需要明确指定具体类。
产品族：具体定义我也不是很清楚，但是类图中的NormalCarBorui(吉利博瑞汽车)跟SUVCarBYDsong SUVCarCS75是同一产品族；
产品树：SUVCcar PMVCar是同一级产品树
抽象工厂模式的特点：
1）针对的是面向多个产品等级结构;
2）一个抽象工厂类，可以派生出多个具体工厂类
3）相同的产品族对应一个具体工厂，每级产品树中包含几颗树抽象工厂中就会存在几个创建方法；
总结：
工厂方法模式适用场景：产品比较单一，只有一级产品树的时候
抽象工厂模式适用场景：产品比较复杂，存在多级业务品种，业务分类的时候
再通俗深化理解下：工厂模式针对的是一个产品等级结构 ，抽象工厂模式针对的是面向多个产品等级结构的---看上面工厂方法模式跟抽象工厂模式的类图
设计到的新设计原则：
依赖倒置原则：尽量依赖抽象，不要依赖具体类
有错误的地方还请大家指出，大家共同学习，谢谢......
转载请注明出处