设计模式-工厂设计模式

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

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

// 产品接口
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();
    }
}