3.设计模式之工厂模式

1. 简单工厂模式

简单工厂其实不是一个设计模式，反而比较像是一种编程习惯。

 

我的理解：简单工厂模式只是把类实例化的方法【new()】放在了工厂类中

 

example:定义一个简单汽车工厂，根据客户的不同需要，生产不同的汽车。

 

来吧

 

1.定义一个汽车的接口，有一个基本的行为方法：即车是可以开的居然

public interface ICar {
	
	//car 的行为
	 void driver();

}

2. 定义一个简单工厂，注意哟，这是重点。根据客户的不同需要，生产不同的汽车

public class SimpleFactory {
	//创建汽车的方法
	public ICar createVehicle(String type){
		ICar car = null;
		if("BMW".equals(type)){
			car = new BMWCar();
		}else if("QQ".equals(type)){
			car = new QQCar();
		}
		return car;
	}
}

3. 定义一个宝马车

/**
 *  宝马车 
 *
 */
public class BMWCar implements ICar {

	public void driver() {
		System.out.println("宝马车在开啊。。。。");
	}
}

4. 定义一个奇瑞QQ专门为屌丝服务

/**
 *    奇瑞QQ 
 *
 */
public class QQCar implements ICar{

	public void driver() {
		System.out.println("QQ车在开啊。。。。");
	}
}

5. 都准备好了，再来一个专卖店吧，专门倾听客户声音为客户服务

/**
 *  售车店
 *
 */
public class CarStore {
	private SimpleFactory factory;//这也是重点啊。
	public CarStore(SimpleFactory factory) {
		this.factory = factory;
	}
	//我需要一辆车
	public ICar orderVehicle(String type){
		return factory.createVehicle(type);
	}
}

6.运行看看

	public class Main {
	
		public static void main(String[] args) {
			//定义一个工厂方法
			SimpleFactory factory = new SimpleFactory();
			//定义一个商店
			CarStore carStore = new CarStore(factory);
			//来一辆宝马吧
			ICar bmw = carStore.orderVehicle("BMW");
			bmw.driver();
			//我没钱来一辆QQ吧
			ICar qq = carStore.orderVehicle("QQ");
			qq.driver();
		}
		
	}

 以上是我理解的最简单工厂模式。

所有工厂模式都是用来封装对象的创建。

2. 抽象工厂模式

    抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

 

看例子吧

1. 抽象工厂方法

/**
 *	抽象工厂的方法 
 */
public abstract class AbstractFactory {
	//生产Vehicle的方法
	abstract ICar createVehicle(String type);
	//生产airplane的方法
	abstract IAirplane createAirplane(String type);
}

 2. 定义一个车的接口

/**
 *  汽车接口 
 */
public interface ICar {
	public void driver();
}

 3.定义一辆宝马车

public class BMWCar implements ICar{
	@Override
	public void driver() {
		System.out.println("宝马车在开啊。。。。");
	}
}

 4.定义一个QQ

/**
 * 奇瑞QQ 
 */
public class QQCar implements ICar{
	@Override
	public void driver() {
		System.out.println("QQ在开。");
	}
}

 5.定义一个飞机的接口

/**
 * 飞机接口
 */
public interface IAirplane{
	public void fly();
}

 6. 定义一架空军一号

/**
 * 空军一号 
 */
public class AirForceOne implements IAirplane{
	@Override
	public void fly() {
		System.out.println("灰太狼的空军一号。。。");
	}
}

 7. 定义一个747

/**
 *	747 
 */
public class Airbus747 implements IAirplane{
	@Override
	public void fly() {
		System.out.println("747在飞啊。");
	}
}

 8.定义一个低级工厂，继承自抽象工厂，可以生产QQ和747

/**
 *  低级工厂 
 */
public class LowLevelFactory extends AbstractFactory{
	//只能生产QQ
	ICar createVehicle() {
		return new QQCar();
	}
	//只能生产747
	IAirplane createAirplane() {
		return new Airbus747();
	}
}

 9.定义一个高级工厂，继承自抽象工厂，可以生产bm和空车一号

/**
 *	高级工厂 
 */
public class HighLevelFactory extends AbstractFactory{

	//可以生产bm
	ICar createVehicle() {
		return new BMWCar();
	}
	//可以生产空军一号
	IAirplane createAirplane() {
		return new AirForceOne();
	}
}

 10.运行一下

public class Main {

	public static void main(String[] args) {
		//高级工厂
		AbstractFactory hignFactory = new HighLevelFactory();
		ICar bmw  = hignFactory.createVehicle();
		bmw.driver();
		IAirplane airplane747 = hignFactory.createAirplane();
		airplane747.fly();
		//低级工厂
		AbstractFactory lowFactory = new LowLevelFactory();
		ICar qq  = lowFactory.createVehicle();
		qq.driver();
		IAirplane airone = lowFactory.createAirplane();
		airone.fly();
	}
}

 我的理解：抽象工厂模式应该是有一个抽象工厂类，并且有许多继承的子工厂类。每一个类产品比方说，车，飞机，都有一个公共的接口。不同的子工厂可以组合生产不同的产品。

返回导航