设计模式——工厂模式

工厂模式属于创建型设计模式，其包含了简单工厂模式，工厂方法模式，抽象工厂模式

主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

直接上代码，有的概念性的东西并不是很好理解。

简单工厂模式：

逻辑就是，创建一个抽象的产品接口，具体的产品去实现共有的产品接口，在工厂类里根据逻辑创建不同具体产品

/**
 * 定义一个单车接口---抽象产品
 */
public interface Bike {
	public void getBike ();
}

/**
 * 定义摩拜单车---具体产品
 */
public class MoBike implements Bike {
	@Override
	public void getBike () {
		System.out.println("获得一辆摩拜单车");
	}
}

/**
 * 定义ofo单车---具体产品
 */
public class OfoBike implements Bike{
	@Override
	public void getBike () {
		System.out.println("获得一辆OFO单车");
	}
}

/**
 * 工厂类，根据不同的逻辑返回不同的单车产品
 */
public class BikeFactory {
	public static Bike makeBike(String bikename){
		if("mobike".equalsIgnoreCase(bikename)){
			return new MoBike();
		}else if("ofo".equalsIgnoreCase(bikename)){
			return new OfoBike();
		}
	}
}

public class FactoryPatternMain {
	public static void main (String[] args) {
		Bike bike = BikeFactory.makeBike("mobike");
		bike.getBike();
                Bike bike = BikeFactory.makeBike("ofo");
		bike.getBike();
	}
}

如果我们需要新的单车产品，我们只需要两步：

1、创建一个新的产品去实现抽象产品

2、修改工厂类逻辑

我们使用的时候只需要向makeBike(String bikename) 传入不同的参数就可以生成不同的对象。

上面就是一个简单的工厂模式例子，但是我们会发现，这样违背了开闭原则，每次我们新增加产品的时候都要去修改我们的

工厂类。下面介绍另外一种工厂模式：

工厂方法模式：逻辑是创建一个抽象的产品接口，具体的产品去实现共有的产品接口，创建一个抽象工厂类，

每个产品有自己的具体工厂类去实现抽象工厂类，调用时根据不同的工厂产生不同的产品。代码如下：

保留简单工厂模式中的Bike接口，MoBike类，OfoBike类。创建抽象工厂类和具体工厂类

/**
 * 创建工厂规范接口
 */
public interface IBikeFactory {

	public Bike makeBike ();
}

/**
 * 创建一个MoBike的工厂类
 */
public class MoBikeFactory implements IBikeFactory {
	@Override
	public Bike makeBike () {
		return new MoBike();
	}
}

public class OfoBikeFactory implements IBikeFactory {
	@Override
	public Bike makeBike () {
		return new OfoBike();
	}

}

public class FactoryPatternMain {
	public static void main (String[] args) {
		IBikeFactory bikeFactory = new MoBikeFactory();
		Bike bike = bikeFactory .makeBike();
		bike.getBike();

		IBikeFactory bikeFactory = new OfoBikeFactory();
		Bike ofobike = bikeFactory .makeBike();
		ofobike.getBike();

	}
}

这时候如果再增加一个产品的话我们只需要新增一个产品类和产品工厂类就行，不需要改动原来的代码。

下面再介绍一种工厂模式，抽象工厂模式：

1、定义两个抽象接口

/**
 * 自行车接口
 */
public interface Bike {
	public void MakeBike ();
}

/**
 * 电动车接口
 */
public interface ElectroBike {
	public void MakeBike();
}

2、定义具体实现

/**
 * 摩拜自行车
 */
public class MoBike implements Bike {
	@Override
	public void MakeBike () {
		System.out.println("获得一辆摩拜单车");
	}
}

/**
 * 摩拜电动车
 */
public class MoElectroBike implements ElectroBike{
	@Override
	public void MakeBike () {
		System.out.println("获得一辆摩拜电动车");
	}

}

/**
 * ofo自行车
 */
public class OfoBike implements Bike{
	@Override
	public void MakeBike () {
		System.out.println("获得一辆OFO单车");
	}
}

/**
 * ofo电动车
 */
public class OfoElectroBike implements ElectroBike {
	@Override
	public void MakeBike () {
		System.out.println("获得一辆OFO电动车");
	}
}

3、创建抽象工厂

/**
 * 抽象工厂
 */
public abstract class AbstractBikeFactory {
	abstract Bike getBike ();    //获得自行车
	abstract ElectroBike getElectroBike ();   //获得电动车
}

4、创建具体工厂

/**
 * 创建一个MoBike的工厂类
 */
public class MoBikeFactory extends AbstractBikeFactory {

	@Override
	Bike getBike () {
		return new MoBike();
	}

	@Override
	ElectroBike getElectroBike () {
		return new MoElectroBike();
	}
}

/**
 * 创建ofo工厂
 */
public class OfoBikeFactory extends AbstractBikeFactory{

	@Override
	Bike getBike () {
		return new OfoBike();
	}

	@Override
	ElectroBike getElectroBike () {
		return new OfoElectroBike();
	}
}

5、使用

public class FactoryPatternMain {
	public static void main (String[] args) {
		AbstractBikeFactory moBikeFactory = new MoBikeFactory();
		moBikeFactory.getBike().MakeBike();
		moBikeFactory.getElectroBike().MakeBike();

		AbstractBikeFactory ofoBikeFactory = new OfoBikeFactory();
		ofoBikeFactory.getBike().MakeBike();
		ofoBikeFactory.getElectroBike().MakeBike();
	}
}