設計模式——工廠模式

工廠模式屬於創建型設計模式，其包含了簡單工廠模式，工廠方法模式，抽象工廠模式

主要是爲創建對象提供過渡接口，以便將創建對象的具體過程屏蔽隔離起來，達到提高靈活性的目的。

直接上代碼，有的概念性的東西並不是很好理解。

簡單工廠模式：

邏輯就是，創建一個抽象的產品接口，具體的產品去實現共有的產品接口，在工廠類里根據邏輯創建不同具體產品

/**
 * 定義一個單車接口---抽象產品
 */
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();
	}
}