设计模式学习笔记(四)之工厂模式(Factory)

       

        今天学习了一下工厂模式（Factory），平时编程的时候需要对象的时候，会使用到大量的new关键字，现在如果使用工厂方法，我们可以必须公开实例化使用new关键字了；

   （一）  工厂模式又分了,简单工厂模式，抽象工厂模式，工厂方法模式，首先看下工厂方法模式的类图:

  

        上面的类图声明了两个抽象类，生成Weapon的抽象工厂类，然后要生产具体的Weapon的之类工厂去实现，还有一个Weapon抽象类，并且定义了一个attack()的抽象方法，子类去继承Weapon类，并且同时实现attack()方法。

在客户端进行使用的时候只要WeaponFactory factory=new XXXFactory() 这里可以new一个具体的实现类即可。。

     看下代码实现:

  ①：Weapon接口类和对应的实现类

package com.jiangqq.dp.simplefactory;
//武器的接口类
public interface Weapon {
	//同时里面声明一个需要子类实现的方法
	public void attack();
}

package com.jiangqq.dp.simplefactory;
//具体的轰炸机类
public class Bomber implements Weapon {
	@Override
	public void attack() {
		// TODO Auto-generated method stub
		System.out.println("轰炸机发射炸弹.....");
	}
}


package com.jiangqq.dp.simplefactory;
//具体的机枪的类
public class Gun implements Weapon {
	@Override
	public void attack() {
		// TODO Auto-generated method stub
		System.out.println("机枪发射子弹....");
	}
}

②:WeaponFactory工厂和具体的创建对象工厂实现类:

package com.jiangqq.dp.simplefactory;
//武器的创建接口类
public interface WeaponFactory {
	public Weapon create();
}


package com.jiangqq.dp.simplefactory;
//机枪的具体实现类
public class GunFactory implements WeaponFactory {
	//创建一个具体的机枪对象
	@Override
	public Weapon create() {
		return new Gun();
	}
}

package com.jiangqq.dp.simplefactory;
//轰炸机的具体实现类
public class BomberFactory implements WeaponFactory {

	//创建一个具体的轰炸机对象
	@Override
	public Weapon create() {
		return new Bomber();
	}
}

   ③：下面是Client测试方法:

package com.jiangqq.dp.simplefactory;

/**=================================
 * 简单工厂模式测试客户端
 * @author jiangqq
 * @time 2012/3/15 20:57
 * ====================================
 */
public class ClientTest {
	public static void main(String[] args) {
		//声明一个可以生成机枪对象的工厂
		WeaponFactory factory1 = new GunFactory();
		//创建出对象的Weapon,--->Gun
		Weapon weapon1=factory1.create();
		//调用具体方法...
		weapon1.attack();
		WeaponFactory factory2 = new BomberFactory();
		Weapon weapon2=factory2.create();
		weapon2.attack();
	}
}

运行效果如下:

        

      

       使用接口，工厂方法，我们可以很好的去把类中相同的实现方法抽取能接口，这样我们就可以进行面向接口编程，并且在工厂实现类中进行对象的实例化，有效减了少在Client端调用的时候公开化的new实例化对象........

       但是如果我们要一次性的生成一系列的产品的时候，如果还是使用工厂方法模式的话，那就在客户端实例化的对象将会一次性成倍增加，这就需要用到抽象工厂模式了。

      

     （二）接着我们来看看另一种工厂模式---抽象工厂模式，同样先看一下类图：

     

     直接看这张图有点复杂：简单的解释一下:上面有三个抽象类分别是

 ①:抽象工厂类（AbstractFactory）:并且其中声明了两个创建具体对象的方法,让它的实现类继承并且实现，其中实现它的FirstFactory和SecondFactory是具体工厂生成出来的产品，且可以生成出一系列的对象如：Apple,Bomber...

 ②:下面两个为Fruits,Weapon抽象类，并且具体子类去实现，可以实例化具体的对象,

 先看如客户端测试的代码

package com.jiangqq.dp.abstractfactory;
/*
 * ========================================== 
 * 抽象工厂模式测试客户端
 * @author jiangqq
 * @time 2012/3/15/ 21:28 =============================================
 */
public class ClientTest {
	public static void main(String[] args) {
		System.out.println("第一个工厂================================");
		//生成一个具体的产品
		AbstractFactory factory1 = new FirstFactory();
		//得到weapon
		Weapon weapon1 = factory1.createWeapon();
		//得到fruits
		Fruits fruits1 = factory1.createFruits();
		//根据生成的对象调用具体的方法
		weapon1.attack();
		fruits1.eat();
		System.out.println("第二个工厂================================");
		AbstractFactory factory2 = new SecondFactory();
		Weapon weapon2 = factory2.createWeapon();
		Fruits fruits2 = factory2.createFruits();
		weapon2.attack();
		fruits2.eat();
	}
}

 工厂类:

package com.jiangqq.dp.abstractfactory;
//工厂抽象类
public abstract class AbstractFactory {
	//定义创建武器类，让继承它的具体工厂类具体去实现
	public abstract Weapon createWeapon();
	//定义创建水果类，让继承它的具体工厂类具体去实现
	public abstract Fruits createFruits();
}



package com.jiangqq.dp.abstractfactory;
//具体生产对象类
public class FirstFactory extends AbstractFactory {
	//生产出机枪
	@Override
	public Weapon createWeapon() {
		return new Gun();
	}
	//生成出香蕉
	@Override
	public Fruits createFruits() {
		return new Banana();
	}
}



package com.jiangqq.dp.abstractfactory;
//具体生产对象类
public class SecondFactory extends AbstractFactory {
	// 生产出轰炸机
	@Override
	public Weapon createWeapon() {
		return new Bomber();
	}
	// 生产出苹果
	@Override
	public Fruits createFruits() {
		return new Apple();
	}
}

Fruits类:

package com.jiangqq.dp.abstractfactory;
//水果抽象类
public abstract class Fruits {
	//声明的水果的方法，具体让子类去实现
	public abstract void eat();
}



package com.jiangqq.dp.abstractfactory;
//苹果具体类
public class Apple extends Fruits {
	//实现苹果的方法
	@Override
	public void eat() {
		System.out.println("吃这苹果.....");
	}
}

package com.jiangqq.dp.abstractfactory;
//香蕉具体类
public class Banana extends Fruits {
//实现香蕉的方法
	@Override
	public void eat() {
	System.out.println("吃着香蕉.....");
	}
}

Weapon类:

package com.jiangqq.dp.abstractfactory;
//武器抽象类
public abstract class Weapon {
   //声明武器的方法，具体让子类去实现
	public abstract void attack();
}

package com.jiangqq.dp.abstractfactory;
//机枪的具体类
public class Gun extends Weapon{
//实现机枪的方法
	public void attack() {
		// TODO Auto-generated method stub
		System.out.println("机枪发射子弹....");
	}
}


package com.jiangqq.dp.abstractfactory;
//轰炸机的具体实现类
public class Bomber extends Weapon {
	//实现轰炸机的方法
	@Override
	public void attack() {
		// TODO Auto-generated method stub
		System.out.println("轰炸机发射炸弹.....");
	}
}

  虽然使用抽象工厂模式，在我们需要一次性实例化一系列的产品的时候，方便很多，但是如果需要增加新的产品的时候，那么类的数量也会成倍的增加，所以说使用工厂方法或者抽象工厂都会有利有弊的，决定于具体场合我们去实现;

最后一个是简单工厂模式，但是简单工厂模式不是严格意义上的设计模式，所以这里也没有具体列出来....