Java工厂模式优雅地创建对象以及提高代码复用率和灵活性
介绍
Java工厂设计模式主要分为三种:
简单工厂模式(Simple Factory Pattern):使用一个工厂类来封装对象创建的过程,客户端只需要通过传递不同的参数来获取不同的产品对象,从而避免了客户端直接创建产品对象的操作
工厂方法模式(Factory Method Pattern):将工厂类抽象出来,每个具体产品类对应一个具体工厂类,工厂类通过多态性来创建对应的产品对象,客户端只需要知道工厂接口及其实现类即可,可以根据需求动态切换工厂实现,扩展性更好.
抽象工厂模式(Abstract Factory Pattern):在工厂方法模式的基础上,将工厂类再进行一次抽象,将多个工厂接口放到一个工厂接口中,每个具体产品对应一个具体工厂类,通过多态性来创建对应的产品对象,具有更好的扩展性和更高的抽象程度,但是也增加了系统复杂度
简单工厂模式
首先先定义一个抽象产品类:
package com.fanqiechaodan.factory.simple.product;
public abstract class Product {
public abstract void use();
}然后定义具体产品类
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...");
}
}接下来定义工厂类,用于创建不同的产品
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);
}
}
}测试:
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();
}
}
工厂方法模式
首先定义一个接口表示产品
package com.fanqiechaodan.factory.method.product;
public interface Product {
void use();
}其次定义两个具体的产品实现类
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...");
}
}然后定义一个工厂接口用于创建产品
package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
public interface Factory {
Product createProduct();
}接下来,定义两个具体的工厂实现类,分别用于创建不同的产品
public class FactoryA implements Factory{
@Override
public Product createProduct() {
return new ProductA();
}
}
public class FactoryB implements Factory{
@Override
public 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;
public class FactoryB implements Factory{
@Override
public Product createProduct() {
return new ProductB();
}
}
抽象工厂模式
首先定义抽象产品
public interface ProductA {
void doSomething();
}
public interface ProductB {
void doSomething();
}其次定义具体产品
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 ...");
}
}然后定义抽象工厂
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();
}接下来定义具体工厂
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();
}
}测试
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) {
// 使用具体工厂1创建产品A和产品B
AbstractFactory factory1 = new Factory1();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.doSomething();
productB1.doSomething();
// 使用具体工厂2创建产品A和产品B
AbstractFactory factory2 = new Factory2();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.doSomething();
productB2.doSomething();
}
}
总结
简单工厂模式
优点:
- 简单易用,客户端只需要知道工厂类和产品类即可
- 工厂类负责创建对象,客户端无需知道具体得实现细节
- 可以根据参数动态创建对象
缺点:
- 工厂类负责创建所有得产品对象,当产品类型过多时,工厂类会变得十分臃肿
- 添加新产品需要修改工厂类的代码,违反了开闭原则
工厂方法模式
优点:
- 将每个产品类型的创建部分分散到具体的工厂类中,避免了简单工厂模式中工厂类臃肿的问题
- 添加新产品只需要添加具体工厂类即可,符合开闭原则
缺点:
- 客户端需要知道所有具体工厂类,使用起来不够灵活
- 每个产品类型都需要对应一个具体的工厂类,增加了系统类的个数,增加了系统的复杂度
抽象工厂模式
优点:
- 可以创建一组相关的产品对象,确保这些对象之间的兼容性
- 隐藏了产品对象的具体实现,客户端只需要知道抽象工厂和抽象产品即可
- 可以通过替换具体工厂来实现不同的产品组合,提高了系统的灵活性
缺点;
- 增加了系统的抽象性和复杂度,需要定义多个抽象工厂接口和多个具体工厂类
- 不容易支持新种类的产品,需要添加新的产品工厂接口和具体工厂类
到此这篇关于Java工厂模式优雅地创建对象以及提高代码复用率和灵活性的文章就介绍到这了,更多相关Java工厂模式内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！
相关文章