介紹
Java工廠設計模式主要分為三種:
簡單工廠模式(Simple Factory Pattern):使用一個工廠類別來封裝物件建立的流程,客戶端只需要透過傳遞不同的參數來獲取不同的產品物件,從而避免了客戶端直接創建產品物件的操作
工廠方法模式(Factory Method Pattern):將工廠類別抽象化,每個具體產品類別對應一個具體工廠類別,工廠類別透過多態性來創建對應的產品物件,客戶端只需要知道工廠介面及其實現類別即可,可以根據需求動態切換工廠實現,擴展性更好.
#抽象工廠模式(Abstract Factory Pattern):在工廠方法模式的基礎上,將工廠類再進行一次抽象,將多個工廠接口放到一個工廠接口中,每個具體產品對應一個具體工廠類,通過多態性來創建對應的產品物件,具有更好的擴展性和更高的抽象程度,但是也增加了系統複雜度
#簡單工廠模式
#首先先定義一個抽象產品類別:
1 2 3 4 5 6 7 8 | package com.fanqiechaodan.factory.simple.product;
public abstract class Product {
public abstract void use ();
}
|
登入後複製
然後定義特定產品類別
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | public class ProductA extends Product{
@Override
public void use () {
System.out.println( "使用具体产品类A..." );
}
}
public class ProductB extends Product{
@Override
public void use () {
System.out.println( "使用具体产品类B..." );
}
}
public class ProductC extends Product{
@Override
public void use () {
System.out.println( "使用具体产品类C..." );
}
}
|
登入後複製
接下來定義工廠類別,用於建立不同的產品
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | package com.fanqiechaodan.factory.simple.factory;
import com.fanqiechaodan.factory.simple.product.Product;
import com.fanqiechaodan.factory.simple.product.ProductA;
import com.fanqiechaodan.factory.simple.product.ProductB;
import com.fanqiechaodan.factory.simple.product.ProductC;
public class SimpleFactory {
public static Product createProduct(String type) {
switch (type) {
case "A" :
return new ProductA();
case "B" :
return new ProductB();
case "C" :
return new ProductC();
default :
throw new RuntimeException( "不支持的产品类型:" + type);
}
}
}
|
登入後複製
測試:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | package com.fanqiechaodan.factory.simple;
import com.fanqiechaodan.factory.simple.factory.SimpleFactory;
import com.fanqiechaodan.factory.simple.product.Product;
public class Demo {
public static void main(String[] args) {
Product productA = SimpleFactory.createProduct( "A" );
productA. use ();
Product productB = SimpleFactory.createProduct( "B" );
productB. use ();
Product productC = SimpleFactory.createProduct( "C" );
productC. use ();
Product productD = SimpleFactory.createProduct( "D" );
productD. use ();
}
}
|
登入後複製
![怎麼使用Java工廠模式創建物件及提高程式碼復用率和靈活性](https://img.php.cn/upload/article/000/887/227/168402390997449.png)
![怎麼使用Java工廠模式創建物件及提高程式碼復用率和靈活性](https://img.php.cn/upload/article/000/887/227/168402390932020.png)
工廠方法模式
先定義一個介面表示產品
1 2 3 4 5 6 7 8 | package com.fanqiechaodan.factory.method.product;
public interface Product {
void use ();
}
|
登入後複製
#其次定義兩個特定的產品實作類別
1 2 3 4 5 6 7 8 9 10 11 12 | public class ProductA implements Product{
@Override
public void use () {
System.out.println( "使用具体产品A..." );
}
}
public class ProductB implements Product{
@Override
public void use () {
System.out.println( "使用具体产品B..." );
}
}
|
登入後複製
然後定義一個工廠介面用於建立產品
1 2 3 4 5 6 7 8 9 | package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
public interface Factory {
Product createProduct();
}
|
登入後複製
接下來,定義兩個特定的工廠實作類別,分別用於建立不同的產品![怎麼使用Java工廠模式創建物件及提高程式碼復用率和靈活性](https://img.php.cn/upload/article/000/887/227/168402390969936.png)
1 2 3 4 5 6 7 8 9 10 11 12 | public class FactoryA implements Factory{
@Override
public Product createProduct() {
return new ProductA();
}
}
public class FactoryB implements Factory{
@Override
public Product createProduct() {
return new ProductB();
}
}
|
登入後複製
測試###
1 2 3 4 5 6 7 8 9 10 11 12 13 | package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
import com.fanqiechaodan.factory.method.product.ProductB;
public class FactoryB implements Factory{
@Override
public Product createProduct() {
return new ProductB();
}
}
|
登入後複製
####### #####抽象工廠模式######先定義抽象產品###
1 2 3 4 5 6 | public interface ProductA {
void doSomething();
}
public interface ProductB {
void doSomething();
}
|
登入後複製
###其次定義具體產品###
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | public class ProductA1 implements ProductA{
@Override
public void doSomething() {
System.out.println( "ProductA1 doSomething ..." );
}
}
public class ProductA2 implements ProductA{
@Override
public void doSomething() {
System.out.println( "ProductA2 doSomething ..." );
}
}
public class ProductB1 implements ProductB{
@Override
public void doSomething() {
System.out.println( "ProductB1 doSomething ..." );
}
}
public class ProductB2 implements ProductB{
@Override
public void doSomething() {
System.out.println( "ProductB2 doSomething ..." );
}
}
|
登入後複製
###然後定義抽象工廠###
1 2 3 4 5 6 7 8 9 10 11 | package com.fanqiechaodan.factory.abstractfactory.factory;
import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;
public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
|
登入後複製
###接下來定義具體工廠###
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | public class Factory1 implements AbstractFactory{
@Override
public ProductA createProductA() {
return new ProductA1();
}
@Override
public ProductB createProductB() {
return new ProductB1();
}
}
public class Factory2 implements AbstractFactory{
@Override
public ProductA createProductA() {
return new ProductA2();
}
@Override
public ProductB createProductB() {
return new ProductB2();
}
}
|
登入後複製
###測試###
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | package com.fanqiechaodan.factory.abstractfactory;
import com.fanqiechaodan.factory.abstractfactory.factory.AbstractFactory;
import com.fanqiechaodan.factory.abstractfactory.factory.Factory1;
import com.fanqiechaodan.factory.abstractfactory.factory.Factory2;
import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;
public class Demo {
public static void main(String[] args) {
AbstractFactory factory1 = new Factory1();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.doSomething();
productB1.doSomething();
AbstractFactory factory2 = new Factory2();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.doSomething();
productB2.doSomething();
}
}
|
登入後複製
#########
以上是怎麼使用Java工廠模式創建物件及提高程式碼復用率和靈活性的詳細內容。更多資訊請關注PHP中文網其他相關文章!