工廠方法模式定義：

即定義一個創建對象的接口（即抽象工廠類），讓其子類（具體工廠類）決定實例化哪一個類（具體產品類）。“一對一”的關系

1，一抽象工廠類派生出多個具體工廠類；

2，一抽象產品類派生出多個具體產品類；

3，每個具體工廠類只能創建一個具體產品類的實例。

UML圖：

角色模塊：

1，抽象工廠類：工廠方法模式的核心，定義一個創建對象的接口

2，具體工廠類：繼承抽象工廠類，實現其工廠方法，實現具體業務邏輯

3，抽象產品類：是工廠方法模式所創建的產品的父類

4，具體產品類：實現抽象產品類的某個具體產品的對象。

工廠方法模式的代碼模板：

Product.java

package com.hust.factory1; //抽象產品類 public abstract class Product {//產品類的抽象方法，有具體的產品類去實現public abstract void method(); } ConcreteProductA.java

package com.hust.factory1; //具體產品類A public class ConcreteProductA extends Product {public void method() {System.out.println("我是具體產品類A");}<span style="font-size:24px;">} </span> ConcreteProductB.java

package com.hust.factory1; //具體產品類B public class ConcreteProductB extends Product {public void method() {System.out.println("我是具體產品類B");}} Factory.java

package com.hust.factory1; //抽象工廠類 public abstract class Factory {//抽象的工廠方法，具體生產什么有子類去實現public abstract <T extends Product> T createProduct(Class<T> clz); } ConcreteFactory.java

/*** */ package com.hust.factory1;/*** @author tuke**/ public class ConcreteFactory extends Factory {/* * 需要哪一個類就傳入哪一個類的類型*/public <T extends Product> T createProduct(Class<T> clz) {//傳入一個class類要決定生產哪一個產品Product p=null;try {p=(Product) Class.forName(clz.getName()).newInstance();//根據類加載器實例化對象} catch (Exception e) { e.printStackTrace();}return (T) p;}}
Test.java

package com.hust.factory1;public class Test {/*** @param args*/public static void main(String[] args) {Factory mFactory=new ConcreteFactory();//實例化具體工廠Product mProductA=mFactory.createProduct(ConcreteProductA.class);//根據類名初始化具體產品mProductA.method();Product mProductB=mFactory.createProduct(ConcreteProductB.class);mProductB.method();}} 輸出：

我是具體產品類A 我是具體產品類B 具體實現例子：由工廠方法生產奧迪Q3，奧迪Q5，奧迪Q7

AudiCar.java

package com.hust.factory2; //抽象產品類 public abstract class AudiCar {//定義一個汽車的行為方法，車可以啟動開走 public abstract void drive();//定義一個汽車的行為方法，車可以自動導航public abstract void selfNavigation();} AudiCarQ3.java

/*** */ package com.hust.factory2;/*** @author Administrator**/ public class AudiQ3 extends AudiCar {@Overridepublic void drive() { System.out.println("Q3啟動啦！");}@Overridepublic void selfNavigation() {System.out.println("Q3啟自動導航啦！");}} AudiCarQ5.java
package com.hust.factory2;public class AudiQ5 extends AudiCar {@Overridepublic void drive() {System.out.println("Q5啟動啦！");}@Overridepublic void selfNavigation() {System.out.println("Q5開始巡航啦！");}} AudiCarQ7.java
package com.hust.factory2;public class AudiQ7 extends AudiCar{@Overridepublic void drive() {System.out.println("Q7啟動啦！");}@Overridepublic void selfNavigation() {System.out.println("Q7開始巡航啦！");}} AudiCarFactory.java

package com.hust.factory2; //具體工廠類 public class AudiCarFactory extends AudiFactory {//實現工廠方法，如果要實現擴展多功能，可以在抽象類里增加抽象方法，在具體類中實現，這樣就可以生產多個產品@Overridepublic <T extends AudiCar> T createAudiCar(Class<T> clz) {AudiCar mAudiCar=null;try {mAudiCar=(AudiCar) Class.forName(clz.getName()).newInstance();} catch (Exception e) {e.printStackTrace();}return (T) mAudiCar;}} AudiFactory.java
package com.hust.factory2;public abstract class AudiFactory {public abstract <T extends AudiCar> T createAudiCar(Class<T> clz); }
AudiCarFactory.java
package com.hust.factory2; //具體工廠類 public class AudiCarFactory extends AudiFactory {//實現工廠方法，如果要實現擴展多功能，可以在抽象類里增加抽象方法，在具體類中實現，這樣就可以生產多個產品@Overridepublic <T extends AudiCar> T createAudiCar(Class<T> clz) {AudiCar mAudiCar=null;try {mAudiCar=(AudiCar) Class.forName(clz.getName()).newInstance();} catch (Exception e) {e.printStackTrace();}return (T) mAudiCar;}} Test.java

package com.hust.factory2;public class TestAudiCar {/*** @param args*/public static void main(String[] args) {AudiFactory mAudiFactory=new AudiCarFactory();//構造一個工廠對象//工廠根據具體產品類的類類型生產產品，這里是上轉型對象AudiCar Q3=mAudiFactory.createAudiCar(AudiQ3.class);AudiCar Q5=mAudiFactory.createAudiCar(AudiQ5.class);AudiCar Q7=mAudiFactory.createAudiCar(AudiQ7.class);Q3.drive();Q3.selfNavigation();Q5.drive();Q5.selfNavigation();Q7.drive();Q7.selfNavigation();}} 輸出

Q3啟動啦！ Q3啟自動導航啦！ Q5啟動啦！ Q5開始巡航啦！ Q7啟動啦！ Q7開始巡航啦！
抽象工廠模式的定義：

為創建一組相關或相互依賴的對象提供一個接口，而且無需指定他們的具體類。

1，一個抽象工廠類，派生出多個具體工廠類；

2，多個抽象產品類，派生出多個具體產品類；

3，每個具體工廠類可創建多個具體產品類的實例。
UML圖：

抽象工廠代碼模板：

package com.hust.model;//抽象工廠類 public abstract class AbstractFactory {//A和B是一組或相互依賴的對象public abstract AbstractProductA createProductA();//生產產品A的抽象方法public abstract AbstractProductB createProductB();//生產產品B的抽象方法 } package com.hust.model; //具體工廠1 生產具體類A1，B1 public class ConcreteFactory1 extends AbstractFactory {public AbstractProductA createProductA() {return new ConcreteProductA1();}public AbstractProductB createProductB() {return new ConcreteProductB1();}} package com.hust.model; //具體工廠2 生產具體類A2，B2 public class ConcreteFactory2 extends AbstractFactory {public AbstractProductA createProductA() {return new ConcreteProductA2();}public AbstractProductB createProductB() {return new ConcreteProductB2();}}
/*** */ package com.hust.model;/*** @author tuke**/ //抽象產品類A public abstract class AbstractProductA {public abstract void method(); }

package com.hust.model; //具體產品類A1 public class ConcreteProductA1 extends AbstractProductA {public void method() {System.out.println("具體產品A1的方法");}} package com.hust.model; //具體產品類A2 public class ConcreteProductA2 extends AbstractProductA {public void method() {System.out.println("具體產品A2的方法");}}

package com.hust.model;//抽象產品類B public abstract class AbstractProductB {public abstract void method(); } package com.hust.model; //具體產品類B1 public class ConcreteProductB1 extends AbstractProductB {public void method() {System.out.println("具體產品B1的方法");}} package com.hust.model; //具體產品類B2 public class ConcreteProductB2 extends AbstractProductB {public void method() {System.out.println("具體產品B2的方法");}}
抽象工廠模式的簡單實現：

還拿工廠生產奧迪Q3和Q7，是一個車系，但是零部件差別很大，Q3的發動機是國產的，Q7的發動機是原裝進口的，Q3的輪胎是普通輪胎，Q7的輪胎是全尺寸越野輪胎，Q3使用的是比較普通的制動系統，而Q7是使用制動性能極好的制動系統。

雖然是一個車系，但是發動機，輪胎，制動系統對應的是一系列零部件。

汽車工廠需要生產輪胎，發動機，制動系統這3個零部件

抽象車廠類

package com.hust.audi; //一個抽象工廠，只聲明生產哪一類產品，具體的產品有子工廠去實現 public abstract class CarFactory {public abstract ITire createITire();//生產輪胎public abstract IEngine createIEngine();//生產發動機public abstract IBrake createIBrake();//生產制動系統 } 具體Q3子工廠

package com.hust.audi;public class Q3Factory extends CarFactory {public ITire createITire() { return new NormalTire();}public IEngine createIEngine() { return new DomesticEngine();}public IBrake createIBrake() { return new NormalBrake();}} 具體Q7子工廠

package com.hust.audi;public class Q7Factory extends CarFactory {public ITire createITire() { return new SUVTire();}public IEngine createIEngine() { return new ImportEngine();}public IBrake createIBrake() { return new SeniorBrake();}} 輪胎相關類

/*** */ package com.hust.audi;/*** 輪胎**/ public interface ITire {void tire(); } package com.hust.audi;public class NormalTire implements ITire {public void tire() {System.out.println("普通輪胎");} } package com.hust.audi;public class SUVTire implements ITire {public void tire() {System.out.println("越野輪胎");}}
發動機相關類

/*** */ package com.hust.audi;/*** 發動機**/ public interface IEngine {void engine(); } package com.hust.audi;public class DomesticEngine implements IEngine {public void engine() {System.out.println("國產發動機");}} package com.hust.audi;public class ImportEngine implements IEngine {public void engine() {System.out.println("進口發動機");}}
制動系統相關類

/*** */ package com.hust.audi;/*** 制動系統**/ public interface IBrake {void brake(); } package com.hust.audi;public class NormalBrake implements IBrake {public void brake() {System.out.println("普通制動");}} package com.hust.audi;public class SeniorBrake implements IBrake {public void brake() {System.out.println("高級制動");}} Test.java

package com.hust.audi;public class Test {/** * Q3工廠生產： 普通輪胎 國產發動機 普通制動 ------------------- Q7工廠生產： 越野輪胎 進口發動機 高級制動 */public static void main(String[] args) {//構造一個Q3工廠CarFactory mQ3Factory=new Q3Factory();System.out.println("Q3工廠生產：");mQ3Factory.createITire().tire();mQ3Factory.createIEngine().engine();mQ3Factory.createIBrake().brake();System.out.println("-------------------");//構造一個Q7工廠CarFactory mQ7Factory=new Q7Factory();System.out.println("Q7工廠生產：");mQ7Factory.createITire().tire();mQ7Factory.createIEngine().engine();mQ7Factory.createIBrake().brake();}}
抽象工廠模式與工廠方法模式的區別:

抽象工廠模式是工廠方法模式的升級版本，他用來創建一組相關或者相互依賴的對象。
他與工廠方法模式的區別就在于，工廠方法模式針對的是一個產品等級結構；而抽象工廠模式則是針對的多個產品等級結構。
在編程中，通常一個產品結構，表現為一個接口或者抽象類，也就是說，工廠方法模式提供的所有產品都是衍生自同一個接口或抽象類，而抽象工廠模式所提供的產品則是衍生自不同的接口或抽象類。
在抽象工廠模式中，有一個產品族的概念：所謂的產品族，是指位于不同產品等級結構中功能相關聯的產品組成的家族。抽象工廠模式所提供的一系列產品就組成一個產品族；而工廠方法提供的一系列產品稱為一個等級結構

總結

以上是生活随笔為你收集整理的Java设计模式-工厂方法模式和抽象工厂模式的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。