2. 程式人生 > >Java設計模式（一）工廠模式

Java設計模式（一）工廠模式

阿新 • • 發佈：2018-12-27

目錄

1、工廠模式簡介

工廠模式（Factory Pattern）是 Java 中最常用的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。
在工廠模式中，我們在建立物件時不會對客戶端暴露建立邏輯，並且是通過使用一個共同的介面來指向新建立的物件。

2、工廠模式分類

2.1 簡單工廠模式

簡單工廠模式又 叫靜態工廠方法模式（Static FactoryMethod Pattern）,是通過專門定義一個類來負責建立其他類的例項，被建立的例項通常都具有共同的父類。
實現


我們將建立一個 Shape 介面和實現 Shape 介面的實體類。下一步是定義工廠類 ShapeFactory。
FactoryPatternDemo，我們的演示類使用 ShapeFactory 來獲取 Shape 物件。它將向 ShapeFactory 傳遞資訊（CIRCLE / RECTANGLE / SQUARE），以便獲取它所需物件的型別。

步驟1
建立一個介面:

//Shape.java
public interface Shape {
   void draw();
}

步驟2
建立實現介面的實體類。

//Rectangle.java
public class Rectangle
 
 implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}

//Square.java
public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}

//Circle.java
 

public class Circle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

步驟 3
建立一個工廠，生成基於給定資訊的實體類的物件。

//ShapeFactory.java
public class ShapeFactory {
    
   //使用 getShape 方法獲取形狀型別的物件
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
}

步驟 4
使用該工廠，通過傳遞型別資訊來獲取實體類的物件。

//FactoryPatternDemo.java
public class FactoryPatternDemo {
 
   public static void main(String[] args) {
      ShapeFactory shapeFactory = new ShapeFactory();
 
      //獲取 Circle 的物件，並呼叫它的 draw 方法
      Shape shape1 = shapeFactory.getShape("CIRCLE");
 
      //呼叫 Circle 的 draw 方法
      shape1.draw();
 
      //獲取 Rectangle 的物件，並呼叫它的 draw 方法
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
 
      //呼叫 Rectangle 的 draw 方法
      shape2.draw();
 
      //獲取 Square 的物件，並呼叫它的 draw 方法
      Shape shape3 = shapeFactory.getShape("SQUARE");
 
      //呼叫 Square 的 draw 方法
      shape3.draw();
   }
}

步驟 5
執行程式，輸出結果：

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.

2.2 工廠方法模式

定義了一個建立物件的介面，但由子類決定要例項化的類是哪一個，工廠方法讓類把例項化推遲到了子類。
實現
我們將建立 Shape 介面和介面的實體類。下一步是建立抽象工廠類 AbstractFactory。接著定義工廠類 ShapeFactory1和ShapeFactory2 ，兩個工廠類都擴充套件了 AbstractFactory。
AbstractFactoryPatternDemo，我們的演示類分別使用 ShapeFactory1 和 ShapeFactory2 來獲取兩個的 Shape 集合物件。

步驟 1
介面類和實體類的建立程式碼同簡單工廠模式

步驟2
為Shape 物件建立抽象類來獲取工廠。

//AbstractFactory.java
public abstract class AbstractFactory {
	public abstract Shape[] getShapes() ;
}

步驟3
建立擴充套件了 AbstractFactory 的工廠類，生成Shape實體類的集合物件。

//ShapeFactory1.java
public class ShapeFactory1 extends AbstractFactory {
    
	@Override
	public Shape[] getShapes() {
		return new Shape[] {new Circle(),new Square()};
	}
}

//ShapeFactory2.java
public class ShapeFactory2 extends AbstractFactory {

	@Override
	public Shape[] getShapes() {
		return new Shape[] {new Rectangle(),new Square()};
	}

}

步驟 4
分別使用不同的工廠，來獲取Shape實體類的集合物件。

//AbstractFactoryPatternDemo.java
public class AbstractFactoryPatternDemo {

	public static void main(String[] args) {
		//獲取工廠1
		ShapeFactory1 shapeFactory1 = new ShapeFactory1();
		
		//獲取工廠1的物件集合
		Shape[] shapes1 = shapeFactory1.getShapes();
		System.out.println("==工廠1的物件集合==");
		for(int i=0;i<shapes1.length;i++) {
			//呼叫 物件 的 draw 方法
			if(shapes1[i] != null) {
				shapes1[i].draw();
			}else {
				break;
			}
		}
		
		//獲取工廠2
		ShapeFactory2 shapeFactory2 = new ShapeFactory2();
		
		//獲取工廠2的物件集合
		Shape[] shapes2 = shapeFactory2.getShapes();
		System.out.println("==工廠2的物件集合==");
		for(int i=0;i<shapes2.length;i++) {
			//呼叫 物件 的 draw 方法
			if(shapes2[i] != null) {
				shapes2[i].draw();
			}else {
				break;
			}
		}
	}
}

步驟 5
執行程式，輸出結果：

==工廠1的物件集合==
Inside Circle::draw() method.
Inside Square::draw() method.
==工廠2的物件集合==
Inside Rectangle::draw() method.
Inside Square::draw() method.

2.3 抽象工廠模式

抽象工廠模式（Abstract Factory Pattern）是圍繞一個超級工廠建立其他工廠。該超級工廠又稱為其他工廠的工廠。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。
在抽象工廠模式中，介面是負責建立一個相關物件的工廠，不需要顯式指定它們的類。每個生成的工廠都能按照工廠模式提供物件。
實現
我們將建立 Shape 和 Color 介面和實現這些介面的實體類。下一步是建立抽象工廠類 AbstractFactory。接著定義工廠類 ShapeFactory 和 ColorFactory，這兩個工廠類都是擴充套件了 AbstractFactory。然後建立一個工廠創造器/生成器類 FactoryProducer。
AbstractFactoryPatternDemo，我們的演示類使用 FactoryProducer 來獲取 AbstractFactory 物件。它將向 AbstractFactory 傳遞形狀資訊 Shape（CIRCLE / RECTANGLE / SQUARE），以便獲取它所需物件的型別。同時它還向 AbstractFactory 傳遞顏色資訊 Color（RED / GREEN / BLUE），以便獲取它所需物件的型別。

步驟 1
形狀介面類和實體類的建立程式碼同簡單工廠模式

步驟 3
為顏色建立一個介面。

//Color.java
public interface Color {
   void fill();
}

步驟4
建立實現顏色介面的實體類。

//Red.java
public class Red implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Red::fill() method.");
   }
}

//Green.java
public class Green implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Green::fill() method.");
   }
}

//Blue.java
public class Blue implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Blue::fill() method.");
   }
}

步驟 5
為 Color 和 Shape 物件建立抽象類來獲取工廠。

//AbstractFactory.java
public abstract class AbstractFactory {
   public abstract Color getColor(String color);
   public abstract Shape getShape(String shape) ;
}

步驟 6
建立擴充套件了 AbstractFactory 的工廠類，基於給定的資訊生成實體類的物件。

//ShapeFactory.java
public class ShapeFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      return null;
   }
}

//ColorFactory.java
public class ColorFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      if(color == null){
         return null;
      }        
      if(color.equalsIgnoreCase("RED")){
         return new Red();
      } else if(color.equalsIgnoreCase("GREEN")){
         return new Green();
      } else if(color.equalsIgnoreCase("BLUE")){
         return new Blue();
      }
      return null;
   }
}

步驟 7
建立一個工廠創造器/生成器類，通過傳遞形狀或顏色資訊來獲取工廠。

//FactoryProducer.java
public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("SHAPE")){
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("COLOR")){
         return new ColorFactory();
      }
      return null;
   }
}

步驟 8
使用 FactoryProducer 來獲取 AbstractFactory，通過傳遞型別資訊來獲取實體類的物件。

//AbstractFactoryPatternDemo.java
public class AbstractFactoryPatternDemo {
   public static void main(String[] args) {
 
      //獲取形狀工廠
      AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
 
      //獲取形狀為 Circle 的物件
      Shape shape1 = shapeFactory.getShape("CIRCLE");
 
      //呼叫 Circle 的 draw 方法
      shape1.draw();
 
      //獲取形狀為 Rectangle 的物件
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
 
      //呼叫 Rectangle 的 draw 方法
      shape2.draw();
      
      //獲取形狀為 Square 的物件
      Shape shape3 = shapeFactory.getShape("SQUARE");
 
      //呼叫 Square 的 draw 方法
      shape3.draw();
 
      //獲取顏色工廠
      AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
 
      //獲取顏色為 Red 的物件
      Color color1 = colorFactory.getColor("RED");
 
      //呼叫 Red 的 fill 方法
      color1.fill();
 
      //獲取顏色為 Green 的物件
      Color color2 = colorFactory.getColor("Green");
 
      //呼叫 Green 的 fill 方法
      color2.fill();
 
      //獲取顏色為 Blue 的物件
      Color color3 = colorFactory.getColor("BLUE");
 
      //呼叫 Blue 的 fill 方法
      color3.fill();
   }
}

步驟 9
執行程式，輸出結果：

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method.

相關推薦

Java設計模式（一）工廠模式

目錄 1、工廠模式簡介 2、工廠模式分類 2.1 簡單工廠模式 2.2 工廠方法模式 2.3 抽象工廠模式 1、工廠模式簡介 工廠模式（Factory Pattern）是 Java 中最常用的設計模式之

設計模式（一）工廠模式

inside 類和對象 ace square 種類型 創建 實體類 需要 服務器 工廠模式 工廠模式（Factory Pattern）是 Java 中最常用的設計模式之一。這種類型的設計模式屬於創建型模式，它提供了一種創建對象的最佳方式。 在工廠模式中，我們在創建對象時不會

設計模式（一）工廠模式（補） -- 理解記憶方式

　　設計，是為了更好的應對變化。 　　思考記憶方向：此模式是不是 提取了抽象、分離了具體、依賴於抽象、封裝了具體   /** * 簡單工廠 ：一個簡單工廠（選擇某個資料庫） + 資料庫介面（多個數據庫例項） * * IFactory * MySqlFactory OracleFacto

設計模式（一）工廠模式Factory（建立型）

         在面向物件程式設計中, 最通常的方法是一個new操作符產生一個物件例項,new操作符就是用來構造物件例項的。但是在一些情況下, new操作符直接生成物件會帶來一些問題。舉例來說, 許多型別物件的創造需要一系列的步驟: 你可能需要計算或取得物件的初始

以C/C++語法淺談二十三種設計模式（一）——工廠模式（Factory Method）

0.寫在前面 在軟體開發過程中，為了提高開發效率、增強軟體執行的穩定性，降低後期專案維護的成本，我們志在追求更加高效、簡單的設計思路來引領我們的專案產品，在經過不斷的探索與總結的過程中，我們最常用的設計模式有23中，總體分為三大類，即建立型模式、結構型模式和行為型模式，具體如下：

java設計模式（一）---工廠方法模式

基本上有興趣瞭解設計模式的都會知道工廠模式，因為各種模式相關的書籍以及部落格什麼的都是以工廠模式開頭的，對於一時興起或者三天熱度的都是會看到工廠模式，但是工廠模式也是用到比較廣泛的模式，屬於建立型模式。工廠模式分為工廠方法模式和抽象工廠模式，這篇主要總結一下工廠

Java面向物件設計模式（一）——工廠方法模式

工廠方法模式（Factory Method） 工廠方法模式分為三種： 1、普通工廠模式，就是建立一個工廠類，對實現了同一介面的一些類進行例項的建立。首先看下關係圖： 舉例如下：（我們舉一個傳送郵件和簡訊的例子） 首先，建立二者的共同介面： publici

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

額外 mod 通過反射 pat 擴展 簡單實現 需要 factory actor 　　工廠模式是最常見的實例化對象的模式，用來替代new操作。采用這種模式創建對象會有一些額外的操作，但他會帶給系統更大的擴展性和更少的修改量。典型的應用spring bean容器。下面簡單實現

java設計模式---（2）工廠模式

工廠模式就是自己不去例項化物件，而使用物件工廠去例項化物件，大致分3種：簡單工廠模式、工廠模式、抽象工廠模式 先定義幾個類：Person類，人這個類是個父類，而人分很多種人，這裡舉例子有Student類和Teacher類繼承了Person類。 簡單工廠模式 public class

大話設計模式之（一）工廠模式

(大話設計模式) 最近在研究大話設計模式，正好終結一下，以備自己後續檢視。 書中對設計模式分類有28種，今天終結下最為常見的模式，工廠模式。工廠模式有三種：簡單工廠模式，工廠方法模式，抽象工廠模式。 下面說說這三種模式的差異，並一一舉以書中的例子加以說明。 簡單工廠模式：用一個單獨的類來做建

Objective-C常用設計模式（一）--工廠方法模式

工廠方法模式：定義建立物件的介面，讓子類決定例項化哪一個類。工廠方法使得一個類的例項化延遲到其子類。幾乎所有面向物件語言寫的應用程式都能看到工廠方法。“專門定義一個類來負責建立其他類的例項，被建立的例項通常具有共同的父類。”工廠方法模式使用場景：編譯時無法準確預期要建立的物件

java23種設計模式（一）工廠方法模式

在說工廠方法模式之前，先了解一下簡單工廠模式。工廠方法模式其實是在簡單工廠上面做了一些增強。 簡單工廠模式：有一個專門的類來生產其他類的例項，生產的這些例項有一個共同父類。這個跟我們的多型有一點像。 例子： 假如我們有一個滑鼠工廠，這個工廠既可以生產聯想滑鼠，又可以生產巨集碁滑鼠。 程式碼如下： 1、滑鼠工廠

設計模式（一）——命令模式

進行 span request st2 ges 耦合 i++ 設計 ima 1.描述 將一個請求封裝為一個對象，從而使用戶可以用不同的請求對客戶進行參數化；對請求排隊或記錄請求日誌，以及支持可撤銷操作。 2.用途 在程序設計中，經常涉及道一個對象請求另一個對象調用其方法的情

設計模式（三） 工廠模式

初始化 重要 不能 還需 new 不同 參數 裏的 作用 概述： 屬於創建型設計模式，需要生成的對象叫做產品 ，生成對象的地方叫做工廠 。 使用場景： 在任何需要生成復雜對象的地方，都可以使用工廠方法模式。 直接用new可以完成的不需要用工廠模式 下面將介紹五種工廠

設計模式（1）--工廠模式

工廠模式（Factory Pattern）是 Java 中最常用的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。 在工廠模式中，我們在建立物件時不會對客戶端暴露建立邏輯，並且是通過使用一個共同的介面來指向新建立的物件。 介紹 意圖：定義一個建立物件的介面

磊哥學設計模式（二）工廠模式

工廠模式 什麼是工廠模式 工廠方法模式（FACTORY METHOD）是一種常用的物件建立型設計模式,此模式的核心精神是封裝類中不變的部分，提取其中個性化善變的部分為獨立類，通過依賴注入以達到解耦、複用和方便後期維護拓展的目的。它的核心結構有四個角色，分別是抽象工廠；具體工廠；抽象產

設計模式（三）工廠模式

簡單工廠模式違反了開放—封閉原則，工廠模式解除了其弊端 工廠方法模式，定義一個建立物件的介面，讓子類決定例項化哪一個類。工廠方法使一個類的例項化延遲到子類 簡單工廠模式用switchcase在一個類中，建立相應的類，工廠模式是為每一個類建立一個例項化該類的類，例如OperationAdd

PHP設計模式（二）——工廠模式(Factor Pattern)

@[TOC](PHP設計模式（二）——工廠模式(Factor Pattern)) 工廠模式(Factor Pattern)，就是負責生成其他物件的類或方法 (一)為什麼需要工廠模式 工廠模式可以將物件的生產從直接new 一個物件，改成通過呼叫一個工廠方法生產

設計模式（四）—— 工廠模式

  一、含義 工廠模式包含兩個方式：一個是抽象工廠模式，一個是工廠方法模式。 抽象工廠模式：提供一個介面，用於建立相關或依賴物件的家族，而不需要明確指定具體類。 工廠方法模式：定義一個建立物件的介面，但由子類決定要例項化的類是哪一個。工廠方法讓類把例項化推遲到子類中。

設計模式（一）策略模式和狀態模式

今天要和大家一起分享下在《Head First 設計模式》學習到的內容，很實用的兩個模式：策略模式，狀態模式。 為什麼要說這兩個模式呢。在模式圖中，是一樣的，他倆就像孿生兄弟，但是目的卻不同。 狀態模式： 書中說明了列舉了下面情況。 糖果公司要求實現糖果機功能。狀態圖如下。