设计模式-工厂设计模式

工厂设计模式是一种创建型设计模式,有简单工厂模式,工厂设计模式,抽象工厂模式

其中使用最多的是工厂设计模式,其次是抽象工厂模式,简单工厂模式因为其扩展性较差,而且工厂设计模式是简单工厂模式的升级,简单设计模式存在的意义就是更好的理解工厂设计模式

复制代码
// 产品接口
interface Product {
    void use();
}

// 具体产品A
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

简单工厂模式;

1.只需要对工厂传入一个参数,工厂就能返回该产品类的实例

2.违背了开闭原则,每次增加一个新的产品类时,就需要修改工厂类的逻辑

代码示例:

复制代码
// 简单工厂
class SimpleFactory {
    public Product createProduct(String type) {
        if (type == null) {
            return null;
        }
        if (type.equalsIgnoreCase("A")) {
            return new ConcreteProductA();
        } else if (type.equalsIgnoreCase("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

// 客户端代码
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product productA = factory.createProduct("A");
        productA.use();
        
        Product productB = factory.createProduct("B");
        productB.use();
    }
}

工厂设计模式:

1.将具体工厂分离出来,单独写成一个类来实现共同的工厂接口

2.符合开闭原则,需要添加新的工厂时,只需要写一个新的工厂类实现工厂接口,无需修改原有代码

3.泛用性最强,使用最多的工厂设计模式

4.无法解决多维度问题,比如同一个产品但是不同厂商,像是华为的手机和小米的手机,都是手机,但是要用工厂设计模式要写两个工厂类,目前还没问题,但是一旦产品多了起来,华为的有手机,笔记本,小米的有吹风机,手机,笔记本,这就是五个工厂,两个手机厂,两个电脑厂,一个吹风机厂,随着产品越来越多,扩展也越多,这就会导致代码堆叠的毫无章法.

代码示例

复制代码
// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂A
class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class FactoryMethodDemo {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();
        
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

抽象工厂设计模式:

1.最顶层的工厂提供了创建一系列的相关对象的接口;

2.每个具体工厂实现了该接口,并创建了具体的产品

3.遵循开闭原则

复制代码
// 抽象工厂
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 客户端代码
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.use();
        productB1.use();
        
        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.use();
        productB2.use();
    }
}
相关推荐
间彧3 分钟前
Spring Boot项目中如何自定义线程池
java
间彧24 分钟前
Java线程池详解与实战指南
java
用户2986985301431 分钟前
Java 使用 Spire.PDF 将PDF文档转换为Word格式
java·后端
渣哥41 分钟前
ConcurrentHashMap 1.7 vs 1.8:分段锁到 CAS+红黑树的演进与性能差异
java
间彧1 小时前
复用线程:原理详解与实战应用
java
咖啡Beans2 小时前
使用OpenFeign实现微服务间通信
java·spring cloud
我不是混子2 小时前
说说单例模式
java
间彧5 小时前
SimpleDateFormat既然不推荐使用,为什么java 8+中不删除此类
java
数据智能老司机5 小时前
精通 Python 设计模式——分布式系统模式
python·设计模式·架构