2. 程式人生 > >設計模式之工廠模式 (二)

設計模式之工廠模式 (二)

阿新 • • 發佈：2017-06-21
height align sta sys 12px pack arrow nbsp 靈活

工廠模式分為三大類

  1. 簡單工廠(SimpleFactory)
  2. 工廠方法模式（Factory Method）
  3. 抽象工廠模式（Abstract Factory）
  4. 動態工廠（Dynamic Factory。屬於優化版簡單工廠）

目的：

工廠模式主要是為創建對象提供過渡接口。以便將創建對象的詳細過程屏蔽隔離起來，達到提高靈活性的目的。



一、簡單工廠

組成例如以下：

(1) 工廠類角色：這是本模式的核心。含有一定的商業邏輯和推斷邏輯。在java中它往往由一個詳細類實現。

(2) 抽象產品角色：它通常是詳細產品繼承的父類或者實現的接口。在java中由接口或者抽象類來實現。



(3) 詳細產品角色：工廠類所創建的對象就是此角色的實例。在java中由一個詳細類實現。



詳細樣例：

抽象產品、詳細產品角色類定義例如以下：

package com.open.design.factory;

public class SimpleFactoryData {
	
	
	//2.抽象產品角色：它通常是詳細產品繼承的父類或者實現的接口。在java中由接口或者抽象類來實現。
	public interface Car
	{
		void printName();
	}
	
	
	//3.詳細產品角色：工廠類所創建的對象就是此角色的實例。在java中由一個詳細類實現。
	public static class Benz implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Benz.");
		}
	}
	
	public static  class BMW implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am BMW.");
		}
	}
	
	public static class Audi implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Audi.");
		}
	}
	
	public static class Tesla implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Tesla.");
		}
	}
}


工廠類定義例如以下：
package com.open.design.factory;

import com.open.design.factory.SimpleFactoryData.Car;

//1.工廠類角色：這是本模式的核心，含有一定的商業邏輯和推斷邏輯。在java中它往往由一個詳細類實現
public class SimpleFactory {

	
	public static Car produce(String carName)
	{
		Car car=null;
		if("Benz".equals(carName))
		{	
			car=new SimpleFactoryData.Benz();
		}
		else if("BMW".equals(carName))
		{
			car=new SimpleFactoryData.BMW();
		}
		else if("Audi".equals(carName))
		{
			car=new SimpleFactoryData.Audi();
		}
		else if("Tesla".equals(carName))
		{
			car=new SimpleFactoryData.Tesla();
		}
		
		return car;	
	}
}


測試類例如以下：
package com.open.design.factory;

import com.open.design.factory.SimpleFactoryData.Car;

public class SimpleFactoryTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		Car car=SimpleFactory.produce("Benz");
		car.printName();
		
		car=SimpleFactory.produce("BMW");
		car.printName();
		
		car=SimpleFactory.produce("Audi");
		car.printName();
		
		car=SimpleFactory.produce("Tesla");
		car.printName();

	}

}

打印結果例如以下：

技術分享


長處與缺點：

簡單工廠方法的長處是當在系統中引入新產品時不必改動client，但須要個改動工廠類。這個工廠類集中了全部產品創建邏輯。形成了一個無所不知的全能類（也稱上帝類），假設此類出問題了，整個應用都受大影響。



二、工廠方法模式（也稱多態工廠）

組成例如以下：

(1)抽象工廠角色： 這是工廠方法模式的核心，它與應用程序無關。是詳細工廠角色必須實現的接口或者必須繼承的父類。在java中它由抽象類或者接口來實現。
(2)詳細工廠角色：它含有和詳細業務邏輯有關的代碼。

由應用程序調用以創建相應的詳細產品的對象。

(3)抽象產品角色：它是詳細產品繼承的父類或者是實現的接口。在java中一般有抽象類或者接口來實現。

(4)詳細產品角色：詳細工廠角色所創建的對象就是此角色的實例。在java中由詳細的類來實現。


詳細樣例例如以下：

抽象產品、詳細產品角色類定義例如以下：

package com.open.design.factory;

public class PolymorphicData {
	
	
	//3.抽象產品角色：它是詳細產品繼承的父類或者是實現的接口。在java中一般有抽象類或者接口來實現。

	public interface Car
	{
		void printName();
	}
	
	
	//4.詳細產品角色：詳細工廠角色所創建的對象就是此角色的實例。在java中由詳細的類來實現。
	public static class Sedan implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Sedan.");
		}
	}
	
	public static  class Train implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Train.");
		}
	}
	
	public static class Bike implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Bike.");
		}
	}
	
}


抽象工廠、詳細工廠類定義例如以下：

package com.open.design.factory;

import com.open.design.factory.PolymorphicData.Car;

public class PolymorphicFactory {

	//1.抽象工廠角色： 這是工廠方法模式的核心，它與應用程序無關。是詳細工廠角色必須實現的接口或者必須繼承的父類。在java中它由抽象類或者接口來實現。
	public static abstract class CarFactory
	{
		abstract Car createCar();
	}	

	//2.詳細工廠角色：它含有和詳細業務邏輯有關的代碼。
由應用程序調用以創建相應的詳細產品的對象。
	public static class SedanFactory extends CarFactory
	{
		public Car createCar()
		{
			return new PolymorphicData.Sedan();
		};
	}	
	
	public static class TrainFactory extends CarFactory
	{
		public Car createCar()
		{
			return new PolymorphicData.Train();
		};
	}	
	
	public static class BikeFactory extends CarFactory
	{
		public Car createCar()
		{
			return new PolymorphicData.Bike();
		};
	}	
}

測試類例如以下： 

package com.open.design.factory;

import com.open.design.factory.PolymorphicData.Car;
import com.open.design.factory.PolymorphicFactory.BikeFactory;
import com.open.design.factory.PolymorphicFactory.CarFactory;
import com.open.design.factory.PolymorphicFactory.SedanFactory;
import com.open.design.factory.PolymorphicFactory.TrainFactory;

public class PolymorphicTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		CarFactory factory=new SedanFactory();
		Car car =factory.createCar();
		car.printName();
		
		factory=new TrainFactory();
		car =factory.createCar();
		car.printName();
		
		factory=new BikeFactory();
		car =factory.createCar();
		car.printName();

	}

}

打印結果：

技術分享


長處與缺點：

當在系統中引入新產品時，既不必改動client。又不必改動詳細工廠角色能夠較好的對系統進行擴展。可是當產品種類繁多時。工廠類成倍數增長（由於種類越多，與之相應的工廠類也越多）

在工廠方法模式中，核心的工廠類不再負責全部產品的創建，而是將詳細創建的工作交給子類去做。這個核心工廠則變為抽象工廠角色，僅負責給出具工廠子類必須實現的接口，而不接觸哪一產品創建的細節。

這樣的抽象的結果，使這樣的工廠方法模式能夠用來同意系統不改動詳細工廠角色的情況下引進新產品，這一特點無疑使得工廠模式具有超過簡單工廠模式的優越性。



三、抽象工廠

組成與工廠方法模式一致，僅僅只是抽象工廠是針對多個產品等級結構，工廠方法是針對一個產品等級結構。（產品族：是指位於不同產品等級結構中，功能相關聯的產品組成的家族。比方AMD的CPU和ADM芯片的主板，組成一個家族。Intel的CPU和Intel芯片的主板，又組成一個家族。而這兩個家族都來自於兩個產品等級：CPU，主板。）


詳細樣例例如以下：

抽象產品、詳細產品角色類定義例如以下：

package com.open.design.factory;


public class AbstractFactryCar {
	
	
	//2.抽象產品角色：它通常是詳細產品繼承的父類或者實現的接口。在java中由接口或者抽象類來實現。
	public interface Car
	{
		void printName();
	}
	
	
	//3.詳細產品角色：工廠類所創建的對象就是此角色的實例。
在java中由一個詳細類實現。
	public static class Benz implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Benz.");
		}
	}
	
	public static  class BMW implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am BMW.");
		}
	}
	
	public static class Audi implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Audi.");
		}
	}
	
	public static class Tesla implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Tesla.");
		}
	}
}


package com.open.design.factory;


public class AbstractFactryHouse {
	
	
	//2.抽象產品角色：它通常是詳細產品繼承的父類或者實現的接口。在java中由接口或者抽象類來實現。

	public interface House
	{
		void printHouseName();
	}
	
	
	//3.詳細產品角色：工廠類所創建的對象就是此角色的實例。在java中由一個詳細類實現。
	public static class Villa implements House
	{
		@Override
		public void printHouseName() {
			System.out.println("i am Villa.");
		}
	}
	
	public static  class TileRoofedHouse implements House
	{
		@Override
		public void printHouseName() {
			System.out.println("i am TileRoofedHouse.");
		}
	}
	
	public static class CommodityHouse implements House
	{
		@Override
		public void printHouseName() {
			System.out.println("i am CommodityHouse.");
		}
	}
}

抽象工廠、詳細工廠類定義例如以下：

package com.open.design.factory;

import com.open.design.factory.AbstractFactryCar.Car;
import com.open.design.factory.AbstractFactryHouse.House;

public class AbstractFactry {

	//抽象工廠類
	public static abstract class AbsDream
	{
		public abstract Car createCar();
		public abstract House createHouse();
	}

	
	//2.詳細工廠角色：它含有和詳細業務邏輯有關的代碼。
由應用程序調用以創建相應的詳細產品的對象。

	public static class DreamAFactory extends AbsDream
	{
		public Car createCar()
		{
			return new AbstractFactryCar.Benz();
		};
		public House createHouse()
		{
			return new AbstractFactryHouse.TileRoofedHouse();
		};
	}
	
	public static class DreamBFactory extends AbsDream
	{
		public Car createCar()
		{
			return new AbstractFactryCar.Audi();
		};
		public House createHouse()
		{
			return new AbstractFactryHouse.CommodityHouse();
		};
	}
	
	public static class DreamCFactory extends AbsDream
	{
		public Car createCar()
		{
			return new AbstractFactryCar.Tesla();
		};
		public House createHouse()
		{
			return new AbstractFactryHouse.Villa();
		};
	}
}

測試類例如以下： 

package com.open.design.factory;

import com.open.design.factory.AbstractFactry.AbsDream;
import com.open.design.factory.AbstractFactryCar.Car;
import com.open.design.factory.AbstractFactryHouse.House;

public class AbstractFactryTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		AbsDream dream = new AbstractFactry.DreamAFactory();
		Car car =dream.createCar();
		House house=dream.createHouse();
		
		car.printName();
		house.printHouseName();
		
		//-------------------
		dream = new AbstractFactry.DreamBFactory();
		car =dream.createCar();
		house=dream.createHouse();
		
		car.printName();
		house.printHouseName();
		
		//-------------------
		dream = new AbstractFactry.DreamCFactory();
		car =dream.createCar();
		house=dream.createHouse();
		
		car.printName();
		house.printHouseName();
		

	}

}

打印結果例如以下：

技術分享


長處與缺點：

抽象工廠模式面對的問題是多產品等級結構的系統設計。抽象工廠模式的每一個工廠創造出來的都是一族產品，而不是一個或者一組。


四、動態工廠

組成與簡單工廠類似。


詳細樣例：

抽象產品、詳細產品角色類定義例如以下：

package com.open.design.factory;

public class DynamicFactoryData {
	
	
	//2.抽象產品角色：它通常是詳細產品繼承的父類或者實現的接口。在java中由接口或者抽象類來實現。
	public interface Car
	{
		void printName();
	}
	
	
	//3.詳細產品角色：工廠類所創建的對象就是此角色的實例。在java中由一個詳細類實現。

	public static class Benz implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Benz.");
		}
	}
	
	public static  class BMW implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am BMW.");
		}
	}
	
	public static class Audi implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Audi.");
		}
	}
	
	public static class Tesla implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Tesla.");
		}
	}
}

工廠類定義例如以下： 

package com.open.design.factory;

import java.lang.reflect.Constructor;

import com.open.design.factory.DynamicFactoryData.Car;



public class DynamicFactory {

	public static Car produce(String carName)
	{
		ClassLoader mClassLoader=DynamicFactory.class.getClassLoader();
		try {
			Class<?
> mClass = mClassLoader.loadClass(carName);
			Constructor<?
>[] mConstructor=mClass.getConstructors();
			return (Car) mConstructor[0].newInstance();	
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return null;	
	}

}

測試類例如以下： 

package com.open.design.factory;

import com.open.design.factory.DynamicFactoryData.Car;



public class DynamicFactoryTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		Car car=DynamicFactory.produce("com.open.design.factory.DynamicFactoryData$Benz");
		car.printName();
	
		car=DynamicFactory.produce("com.open.design.factory.DynamicFactoryData$BMW");
		car.printName();
		
		car=DynamicFactory.produce("com.open.design.factory.DynamicFactoryData$Audi");
		car.printName();
		
		car=DynamicFactory.produce("com.open.design.factory.DynamicFactoryData$Tesla");
		car.printName();
	}

}

打印結果例如以下：

技術分享


長處與缺點：

簡單模式的優化版，代碼簡潔。




總結：

（1）簡單工廠模式是由一個詳細的類去創建其它類的實例。

（對於添加新的產品。無能為力）
（2）工廠方法模式是有一個抽象的父類定義公共接口，子類負責生成詳細的對象，這樣做的目的是將類的實例化操作延遲到子類中完畢。

（支持添加新產品）
（3）抽象工廠模式提供一個創建一系列相關或相互依賴對象的接口。而無須指定他們詳細的類。它針對的是有多個產品的等級結構。而工廠方法模式針對的是一個產品的等級結構。

（對於添加新的產品，無能為力。支持添加產品族）




本文代碼地址：https://github.com/zz7zz7zz/design-pattern

參考博文：http://www.cnblogs.com/forlina/archive/2011/06/21/2086114.html

http://www.cnblogs.com/devinzhang/archive/2011/12/19/2293160.html

設計模式之工廠模式 (二)

相關推薦

淺析JAVA設計模式之工廠模式(二)

1.2 源碼 pub color post del tar pop south 1 工廠方法模式簡單介紹 工廠方法 (Factroy Method)模式：又稱多態性工廠模式（Polymorphic Factory），在這樣的模式中，核心工廠不再是一個詳

設計模式之工廠模式 (二)

height align sta sys 12px pack arrow nbsp 靈活 工廠模式分為三大類 簡單工廠(SimpleFactory)工廠方法模式（Factory Method） 抽象工廠模式（Abstract Factory）動態工廠（Dynamic

Java設計模式之工廠模式（二）：抽象工廠模式

mar 模式 blank http left taxi ref www. app 2碳依5FVL冒傲3http://t.docin.com/etw488 am懦7鈉N山段9慌Q闌http://shequ.docin.com/ipu5657 iK1諾5N鍛認EUK剖嘲肆h

Java程式設計師從笨鳥到菜鳥（三十二）23種設計模式之工廠模式

設計模式的六大原則 開閉原則是最基礎的設計原則，其它的五個設計原則都是開閉原則的具體形態，依照java的語言的稱謂，開閉原則是抽象類，其它的五個原則是具體實現類 開閉原則：軟體實體應當對外擴充套件開放，對修改關閉，通俗點說就是應該在不修改原有程式碼的

設計模式之工廠模式（二）

diagonal lam p 地址 加盟 tom 挨踢 類型 jpg 但是 之前已經帶大家稍微入門了工廠模式（即簡單工廠模式）的方法，沒看過的朋友可以移步去查看一番。設計模式之工廠模式（一）。今天我們繼續吃著披薩，學習著工廠模式的接下來部分吧。 加盟披薩店 我們先前的披薩店

漫談設計模式之工廠模式

設計模式 策略模式 工廠模式 單例模式今天在這裏不過多介紹什麽是設計模式和為什麽要使用它？可以參考漫談設計模式之組合模式。一、什麽是抽象工廠設計模式？ 一言以蔽之，抽象工廠就是用來創建功能相關的類，二、在什麽場景下使用它？ 顧名思義，在我們的業務當中會有一種場景，有一個查詢頁面，上面有很多很多的查

Java設計模式之工廠模式

href 1.2 net main override create 靜態工廠方法 lan soft 工廠方法模式 工廠方法模式分為三種：普通工廠模式、多個工廠方法模式和靜態工廠方法模式。 1、普通工廠模式 普通工廠模式就是建立一個工廠類，對實現了同一接口的一些類進行實

設計模式之工廠模式

一個 重要 沒有 告訴 統一 -s 還需 修改 span 大學學的最多的就是據結構和算法，不可否認，數據結構和算法非常重要，是編程的基石。但是在實際開發過程中，除非做的是比較底層的開發，否則的話，對設計模式的運用要比對數據結構和算法的運用要多。今天就來聊聊設計模式中的工廠模

設計模式之工廠模式類圖

工廠方法 png 工廠模式 src 設計模式 方法 .cn 技術分享 img 工廠模式：實例化對象，用工廠方法代替new操作 工廠模式包括工廠方法模式和抽象工廠模式 抽象工廠模式是工廠方法模式的擴展 實際應用舉例： 設計模式之工廠模式類圖

設計模式之工廠模式 Factory實現

aps 引擎 rac sed urn lose pla logs rgs simpleFactory //car接口 public interface Car { void run(); } //兩個實現類 public class Audi implemen

JAVA 設計模式 之 工廠模式

java 工廠模式 設計模式 1、為什麽要使用工廠模式？ 比方說，一位滴滴司機，如果要去開車掙錢的話，他得自己會制造汽車，然後，才能使用汽車掙錢；對於這位司機來說，要求很高了，畢竟汽車很難制造出來； 如果使用工廠模式的話，這位司機，只需要知道汽車工廠就可以了，直接去工廠提車就行。從

23種設計模式之工廠模式

stream -a cdd 一個 sim ted bfd 變化 行為 披薩項目為例，使用工廠模式設計 需求：方便披薩品種擴展，便於維護，要能運行時擴展 披薩族（組）設計類圖 假設只有原料不同，其他操作如烘焙、切割、打包相同，就把prepare方法設置為抽象方法 一般設計如

PHP設計模式之工廠模式

interface () pub spa 設計 ace inter 接口 div <?php // 設計模式之工廠模式 class Factory { static public function fac ($id) { switch ($id)

JavaScript設計模式之工廠模式

無法 生產 什麽 接口 child ear 具體實現 bsp 常用 工廠模式是一種最常用的實例化對象模式，是用工廠方法代替new操作的一種模式。在工廠模式中，我們在創建對象時不會對客戶端暴露創建邏輯，並且是通過使用一個共同的接口來指向新創建的對象。因為工廠模式就相當於創建實

C++設計模式之-工廠模式的總結

ide char* break product 有一個 對象 ride pan 多態 工廠模式分為3種，即簡單工廠模式、工廠方法模式、抽象工廠模式，其實大同小異，總結下來就是： 簡單工廠模式：一個工廠，多個產品。產品需要有一個虛基類。通過傳入參數，生成具體產品對象，並利用

設計模式之----工廠模式

工廠模式 有一個OEM製造商代理做HP膝上型電腦(Laptop)，後來該製造商得到了更多的品牌膝上型電腦的訂單Acer，Lenovo，Dell，該OEM商發現，如果一次同時做很多個牌子的本本，有些不利於管理。利用工廠模式改善設計，用Java控制檯應用程式實現該OEM製造商的工廠模式。繪製

Java設計模式之 工廠模式

Java設計模式 - 工廠模式   工廠模式使用場景: 工廠模式分為簡單工廠 工廠 抽象工廠模式. 當用戶需要一個類的子類例項,且不希望與該類的子類行成耦合或者不知道該類有哪些子類可用時,可採用工廠模式; 當用戶需要系統提供多個物件,且希望和建立物件的類解耦時,可採用抽象工廠模

常見的設計模式之工廠模式和單例模式

工廠模式 工廠方法模式有兩個抽象類，一個是產品抽象類，一個是工廠抽象類，若干個具體產品類和對應的具體工廠類，具體產品抽象類與產品抽象類是實現關係，與具體工廠類是依賴關係，具體工廠類與抽象工廠類是實現關係。 客戶端程式碼如下 工廠模式是定義一個用於建立物件的介面，讓子類決定將哪一個

PHP 設計模式之工廠模式 (靜態工廠模式)

### 工廠模式： 由工廠類根據引數來決定創建出哪一種產品類的例項。工廠類是指包含了一個專門用來建立其他物件的方法的類。所謂按需分配，傳入引數進行選擇，返回具體的類。工廠模式的最主要作用就是物件建立的封裝、簡化建立物件操作。 簡單的說，就是呼叫工廠類的一個方法（傳入引數）來得到需要的類； 優點

趣味設計模式之工廠模式

   一開始的時候，我覺得設計模式不是很重要，因為在工作的過程中，處理起來大多數是業務的邏輯，好像也是隻有在面試的時候有作用，正所謂“面試造火箭，進門當螺絲”。但是隨著自己的不斷深入的理解，閱讀一些好的專案的原始碼的時候才發現心有餘，而力不足。當自己需要設計一個系統的時候也有