浅学设计模式之简单工厂模式、工厂模式、抽象工厂模式
一、简单工厂
从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。
其包括三个角色：
- 工厂（Creator）角色 ：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
- 抽象产品（Product）角色：简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
- 具体产品（Concrete Product）角色：是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。
其UML图如下所示：
看一下写的小例子：假如一家航空公司需要购买飞机：
先定义飞机接口：
public interface IPlane {
void name();
}
在得到Product：
波音：
public class Boeing777 implements IPlane{
private String name = "Boeing777";
@Override
public void name() {
// TODO Auto-generated method stub
System.out.println("My name is:" + name);
}
}
空客：
public class Boeing737 implements IPlane {
private String name = "Boeing737";
@Override
public void name() {
// TODO Auto-generated method stub
System.out.println("My name is :" + name);
}
}
再看飞机工厂：
Create：
public class PlaneFactory {
public static IPlant getPlane(String name) throws Exception {
if (name.equalsIgnoreCase("boeing777")){
return new Boeing777();
} else if (name.equalsIgnoreCase("boeing737")){
return new Boeing737();
}else
{
throw new Exception("The type $type don't exists" );
}
}
}
当我们在客户端想要得到飞机的时候：
public class PlaneTest {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
//获取波音飞机
IPlane boeing777 = PlaneFactory.getPlane("boeing777");
//获得名字
boeing777.name();
//获取空客飞机
IPlane boeing737= PlaneFactory.getPlane("airbus");
//获得名字
boeing737.name();
}
}
运行结果：
My name is:Boeing777
My name is :Boeing737
优点：
工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个 软件体系结构 的优化。 缺点： 由于工厂类集中了所有实例的创建逻辑，违反了 高内聚 责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。 当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利； 这些缺点在 工厂方法模式 中得到了一定的克服。 使用场景 工厂类负责创建的对象比较少； 客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。
说明：以上文字概念部分，均来自百度百科。自己没有那么好的归纳能力。
二、工厂模式
5月23号修改工厂模式代码，把工厂类修改成抽象类：
public abstract class PlaneFactory {
public void letPlaneFly(String name){
IPlane iPlane = getPlane(name);
iPlane.fly();
}
abstract IPlane getPlane(String name) ;
}
不但能获取飞机，而且能让它飞！
具体工厂类，有boeing工厂和airbus工厂。
public class AirbusFactory extends PlaneFactory {
@Override
IPlane getPlane(String name) {
// TODO Auto-generated method stub
if (name.equalsIgnoreCase("airbus320")){
return new Airbus320();
} else if (name.equalsIgnoreCase("airbus380")){
return new Airbus380();
}else {
return null;
}
}
}
public class BoeingPlaneFactory extends PlaneFactory{
@Override
IPlane getPlane(String name) {
// TODO Auto-generated method stub
if (name.equalsIgnoreCase("boeing777")){
return new Boeing777();
} else if (name.equalsIgnoreCase("boeing737")){
return new Boeing737();
}else {
return null;
}
}
}
产品抽象类：plane
public abstract class IPlane {
abstract void name();
public void fly() {
name();
System.out.println("i fly in the sky");
}
}
分别继承，获得的四个飞机类：
public class Boeing777 extends IPlane {
@Override
public void name() {
// TODO Auto-generated method stub
System.out.println("i am boeing 777");
}
}
public class Boeing737 extends IPlane {
@Override
public void name() {
// TODO Auto-generated method stub
System.out.println("i am boeing 737");
}
}
public class Airbus320 extends IPlane {
@Override
public void name() {
// TODO Auto-generated method stub
System.out.println("i am airbus320");
}
}
public class Airbus380 extends IPlane {
@Override
public void name() {
// TODO Auto-generated method stub
System.out.println("i am Airbus380");
}
}
测试类：
public static void main(String[] args) throws Exception {
PlaneFactory airBus = new AirbusFactory();
//看空客飞机飞
airBus.letPlaneFly("airbus320");
airBus.letPlaneFly("airbus380");
PlaneFactory boeing = new BoeingPlaneFactory();
boeing.letPlaneFly("boeing777");
boeing.letPlaneFly("boeing737");
}
测试结果：
i am airbus320
i fly in the sky
i am Airbus380
i fly in the sky
i am boeing 777
i fly in the sky
i am boeing 737
i fly in the sky
三、抽象工厂模式
当我们发现，我们不仅需要民航飞机，我们还需要战斗机，该如何办呢？大家都知道，波音不仅生产民用飞机，还有著名的B-52，而空客也有它的军用运输机A400M。
我们生产飞机时，就需要两个接口了，军用飞机一个接口，民用飞机一个接口。看下图：
军用飞机是一个产品等级，民用飞机又是一个产品等级，而波音和空客生产两个不同的产品族。
先看看民用飞机接口：
public interface ICivilaircraft {
String getName();
//运输旅客
void passengers();
}
民用飞机：
public class Boeing777 implements ICivilaircraft{
private String name ="Boeing 777";
private String personNumber ="350";
@Override
public String getName() {
return name;
// TODO Auto-generated method stub
}
@Override
public void passengers() {
// TODO Auto-generated method stub
System.out.println(getName()+"can passengers "+personNumber+" person");
}
}
空客的空客340
public class Airbus340 implements ICivilaircraft{
private String name ="Airbus340";
private String personNumber ="380";
@Override
public String getName() {
return name;
// TODO Auto-generated method stub
}
@Override
public void passengers() {
// TODO Auto-generated method stub
System.out.println(getName()+"can passengers "+personNumber+" person");
}
}
军用飞机接口：
public interface IWarplane {
String getName();
//运输武器
void Transportarms();
}
军用飞机：
public class A400M implements IWarplane {
private String name ="A400M";
private String armweight="30吨";
@Override
public String getName() {
// TODO Auto-generated method stub
return name;
}
@Override
public void Transportarms() {
// TODO Auto-generated method stub
System.out.println(getName()+"can transport "+ armweight+" arms");
}
}
B52：
public class B52 implements IWarplane {
private String name ="B52";
private String armweight="27吨";
@Override
public String getName() {
// TODO Auto-generated method stub
return name;
}
@Override
public void Transportarms() {
// TODO Auto-generated method stub
System.out.println(getName()+"can transport "+ armweight+" arms");
}
}
在看看飞机工厂，波音公司和空客公司，先看他们的父类：
public abstract class AbstractFactory {
abstract ICivilaircraft getCivilair();
abstract IWarplane getWarplane();
}
波音：
public class BoeingFactory extends AbstractFactory{
@Override
ICivilaircraft getCivilair() {
// TODO Auto-generated method stub
return new Boeing777();
}
@Override
IWarplane getWarplane() {
// TODO Auto-generated method stub
return new B52();
}
}
空客：
public class AirBus extends AbstractFactory {
@Override
ICivilaircraft getCivilair() {
// TODO Auto-generated method stub
return new Airbus340();
}
@Override
IWarplane getWarplane() {
// TODO Auto-generated method stub
return new A400M();
}
}
测试类：
public static void main(String[] args) {
// TODO Auto-generated method stub
AbstractFactory boeing = new BoeingFactory();
AbstractFactory airbus = new AirBus();
//查看波音的民用飞机
boeing.getCivilair().passengers();
//查看波音的军用飞机
boeing.getWarplane().Transportarms();
//查看空客的民用飞机
airbus.getCivilair().passengers();
//查看空客的军用飞机
airbus.getWarplane().Transportarms();
}
测试结果：
Boeing 777 can passengers 350 person
B52 can transport 27吨 arms
Airbus340 can passengers 380 person
A400M can transport 30吨 arms
区别和联系：
抽象工厂和工厂模式有什么区别呢？他们俩又在具体什么情况下使用呢？请看下面从网上找到的不错的回答：
其实这两者的区别，GOF的书上说得很清楚。工厂方法采用的是类继承机制（生成一个子类，重写该工厂方法，在该方法中生产一个对象）。而抽象工厂采用的是对象组合机制，专门定义“工厂”对象来负责对象的创建。对象组合的方式就是把“工厂”对象作为参数传递。
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。工厂方法：说白了就是一个方法，这个方法是创建具体的产品的，它要求所有的工厂都具有同一个签名的方法，必要时重写该方法；抽象工厂：不能直接创建产品，只能创建工厂，即抽象工厂创建的产品是工厂。虽然它也定义了创建产品的方法，但需要创建出来的具体的工厂实现，即：抽象工厂创建出的工厂创建产品。工厂方法采用的是类继承机制（生成一个子类，重写该工厂方法，在该方法中生产一个对象）；而抽象工厂采用的是对象组合机制，专门定义“工厂”对象来负责对象的创建。对象组合的方式就是把“工厂”对象作为参数传递。
可以这么去理解，“抽象工厂模式”这个称呼中的“抽象”是一个动词，即对工厂方法模式进行了抽象，就变成了抽象工厂模式，这么理解后，就不难看出它们的区别： 工厂方法模式：每个抽象产品派生多个具体产品类，每个抽象工厂类派生多个具体工厂类，每个具体工厂类负责一个具体产品的实例创建； 抽象工厂模式：每个抽象产品派生多个具体产品类，每个抽象工厂派生多个具体工厂类，每个具体工厂负责多个（一系列）具体产品的实例创建。