HardBirch

浅学设计模式之简单工厂模式、工厂模式、抽象工厂模式

时间:12-05-22 栏目:安卓源码解析与小应用 作者:张飞不张,文采横飞 评论:2 点击: 1,714 次

     一、简单工厂

    从设计模式的类型上来说,简单工厂模式是属于创建型模式,又叫做静态工厂方法(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的书上说得很清楚。工厂方法采用的是类继承机制(生成一个子类,重写该工厂方法,在该方法中生产一个对象)。而抽象工厂采用的是对象组合机制,专门定义“工厂”对象来负责对象的创建。对象组合的方式就是把“工厂”对象作为参数传递。


工厂方法模式:
一个抽象产品类,可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式:
多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。   

区别:
工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。


工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。工厂方法:说白了就是一个方法,这个方法是创建具体的产品的,它要求所有的工厂都具有同一个签名的方法,必要时重写该方法;抽象工厂:不能直接创建产品,只能创建工厂,即抽象工厂创建的产品是工厂。虽然它也定义了创建产品的方法,但需要创建出来的具体的工厂实现,即:抽象工厂创建出的工厂创建产品。工厂方法采用的是类继承机制(生成一个子类,重写该工厂方法,在该方法中生产一个对象);而抽象工厂采用的是对象组合机制,专门定义“工厂”对象来负责对象的创建。对象组合的方式就是把“工厂”对象作为参数传递。


可以这么去理解,“抽象工厂模式”这个称呼中的“抽象”是一个动词,即对工厂方法模式进行了抽象,就变成了抽象工厂模式,这么理解后,就不难看出它们的区别: 工厂方法模式:每个抽象产品派生多个具体产品类,每个抽象工厂类派生多个具体工厂类,每个具体工厂类负责一个具体产品的实例创建; 抽象工厂模式:每个抽象产品派生多个具体产品类,每个抽象工厂派生多个具体工厂类,每个具体工厂负责多个(一系列)具体产品的实例创建。


浅学设计模式之简单工厂模式、工厂模式、抽象工厂模式:目前有2 条留言

  1. 板凳
    lidaasky:

    学习中

    2012-05-23 01:47 [回复]
  2. [reply]lidaasky[/reply]
    那么晚,都没睡,学习太刻苦了。。。

    2012-05-23 08:53 [回复]

发表评论


QQ群互动

Linux系统与内核学习群:194051772

WP建站技术学习交流群:194062106

魔豆之路QR

魔豆的Linux内核之路

魔豆的Linux内核之路

优秀工程师当看优秀书籍

优秀程序员,要看优秀书!

赞助商广告

友荐云推荐