网站导航
> 文章列表 > 工厂设计模式

工厂设计模式

网友: 文章列表 2024-03-21 16:08:22

工厂设计模式

介绍

Java工厂设计模式主要分为三种:

  1. 简单工厂模式(Simple Factory Pattern):使用一个工厂类来封装对象创建的过程,客户端只需要通过传递不同的参数来获取不同的产品对象,从而避免了客户端直接创建产品对象的操作
  2. 工厂方法模式(Factory Method Pattern):将工厂类抽象出来,每个具体产品类对应一个具体工厂类,工厂类通过多态性来创建对应的产品对象,客户端只需要知道工厂接口及其实现类即可,可以根据需求动态切换工厂实现,扩展性更好.
  3. 抽象工厂模式(Abstract Factory Pattern):在工厂方法模式的基础上,将工厂类再进行一次抽象,将多个工厂接口放到一个工厂接口中,每个具体产品对应一个具体工厂类,通过多态性来创建对应的产品对象,具有更好的扩展性和更高的抽象程度,但是也增加了系统复杂度

简单工厂模式

首先先定义一个抽象产品类:

package com.fanqiechaodan.factory.simple.product;/* @author fanqiechaodan* @Classname Product* @Description 抽象产品类* @Date 2023/3/8 18:39*/
public abstract class Product {public abstract void use();
}

然后定义具体产品类

public class ProductA extends Product{@Overridepublic void use() {System.out.println("使用具体产品类A...");}
}public class ProductB extends Product{@Overridepublic void use() {System.out.println("使用具体产品类B...");}
}public class ProductC extends Product{@Overridepublic void use() {System.out.println("使用具体产品类C...");}
}

接下来定义工厂类,用于创建不同的产品

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;/* @author fanqiechaodan* @Classname SimpleFactory* @Description 工厂类* @Date 2023/3/8 18:42*/
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);}}
}

测试:

package com.fanqiechaodan.factory.simple;import com.fanqiechaodan.factory.simple.factory.SimpleFactory;
import com.fanqiechaodan.factory.simple.product.Product;/* @author fanqiechaodan* @Classname Demo* @Description 简单工厂模式* @Date 2023/3/8 18:46*/
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();}
}

在这里插入图片描述

工厂方法模式

首先定义一个接口表示产品

package com.fanqiechaodan.factory.method.product;/* @author fanqiechaodan* @Classname Product* @Description 产品接口* @Date 2023/3/8 18:58*/
public interface Product {void use();
}

其次定义两个具体的产品实现类

public class ProductA implements Product{@Overridepublic void use() {System.out.println("使用具体产品A...");}
}public class ProductB implements Product{@Overridepublic void use() {System.out.println("使用具体产品B...");}
}

然后定义一个工厂接口用于创建产品

package com.fanqiechaodan.factory.method.factory;import com.fanqiechaodan.factory.method.product.Product;/* @author fanqiechaodan* @Classname Factory* @Description 工厂接口* @Date 2023/3/8 19:00*/
public interface Factory {Product createProduct();}

接下来,定义两个具体的工厂实现类,分别用于创建不同的产品

public class FactoryA implements Factory{@Overridepublic Product createProduct() {return new ProductA();}
}public class FactoryB implements Factory{@Overridepublic Product createProduct() {return new ProductB();}
}

测试

package com.fanqiechaodan.factory.method.factory;import com.fanqiechaodan.factory.method.product.Product;
import com.fanqiechaodan.factory.method.product.ProductB;/* @author fanqiechaodan* @Classname FactoryB* @Description 工厂实现类B* @Date 2023/3/8 19:02*/
public class FactoryB implements Factory{@Overridepublic Product createProduct() {return new ProductB();}
}

在这里插入图片描述

抽象工厂模式

首先定义抽象产品

public interface ProductA {void doSomething();
}public interface ProductB {void doSomething();
}

其次定义具体产品

public class ProductA1 implements ProductA{@Overridepublic void doSomething() {System.out.println("ProductA1 doSomething ...");}
}public class ProductA2 implements ProductA{@Overridepublic void doSomething() {System.out.println("ProductA2 doSomething ...");}
}public class ProductB1 implements ProductB{@Overridepublic void doSomething() {System.out.println("ProductB1 doSomething ...");}
}public class ProductB2 implements ProductB{@Overridepublic void doSomething() {System.out.println("ProductB2 doSomething ...");}
}

然后定义抽象工厂

package com.fanqiechaodan.factory.abstractfactory.factory;import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;/* @author fanqiechaodan* @Classname AbstractFactory* @Description 抽象工厂* @Date 2023/3/8 19:08*/
public interface AbstractFactory {ProductA createProductA();ProductB createProductB();
}

接下来定义具体工厂

public class Factory1 implements AbstractFactory{@Overridepublic ProductA createProductA() {return new ProductA1();}@Overridepublic ProductB createProductB() {return new ProductB1();}
}public class Factory2 implements AbstractFactory{@Overridepublic ProductA createProductA() {return new ProductA2();}@Overridepublic ProductB createProductB() {return new ProductB2();}
}

测试

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;/* @author fanqiechaodan* @Classname Demo* @Description 抽象工厂模式* @Date 2023/3/8 19:40*/
public class Demo {public static void main(String[] args) {// 使用具体工厂1创建产品A和产品BAbstractFactory factory1 = new Factory1();ProductA productA1 = factory1.createProductA();ProductB productB1 = factory1.createProductB();productA1.doSomething();productB1.doSomething();// 使用具体工厂2创建产品A和产品BAbstractFactory factory2 = new Factory2();ProductA productA2 = factory2.createProductA();ProductB productB2 = factory2.createProductB();productA2.doSomething();productB2.doSomething();}
}

在这里插入图片描述

总结

  1. 简单工厂模式

    优点:

    • 简单易用,客户端只需要知道工厂类和产品类即可
    • 工厂类负责创建对象,客户端无需知道具体得实现细节
    • 可以根据参数动态创建对象

    缺点:

    • 工厂类负责创建所有得产品对象,当产品类型过多时,工厂类会变得十分臃肿
    • 添加新产品需要修改工厂类的代码,违反了开闭原则

  2. 工厂方法模式

    优点:

    • 将每个产品类型的创建部分分散到具体的工厂类中,避免了简单工厂模式中工厂类臃肿的问题
    • 添加新产品只需要添加具体工厂类即可,符合开闭原则

    缺点:

    • 客户端需要知道所有具体工厂类,使用起来不够灵活
    • 每个产品类型都需要对应一个具体的工厂类,增加了系统类的个数,增加了系统的复杂度

  3. 抽象工厂模式

    优点:

    • 可以创建一组相关的产品对象,确保这些对象之间的兼容性
    • 隐藏了产品对象的具体实现,客户端只需要知道抽象工厂和抽象产品即可
    • 可以通过替换具体工厂来实现不同的产品组合,提高了系统的灵活性

    缺点;

    • 增加了系统的抽象性和复杂度,需要定义多个抽象工厂接口和多个具体工厂类
    • 不容易支持新种类的产品,需要添加新的产品工厂接口和具体工厂类
网络标签：

相关问题