3.工厂模式

转载

mob60475704ea1a 2021-07-24 17:13:00

3.工厂模式_实例化

简单工厂模式

由一个工厂对象决定创建出哪一种产品类的实例
定义了一个创建对象的类，由这个类来封装实例化对象的行为。

3.工厂模式_简单工厂模式_02

计算类，工厂类，测试类

public class Operation {
     int num1;
     int num2;

    public int getNum1() {
        return num1;
    }

    public void setNum1(int num1) {
        this.num1 = num1;
    }

    public int getNum2() {
        return num2;
    }

    public void setNum2(int num2) {
        this.num2 = num2;
    }
    public  int getResult(){
        return 0;
    }

}

public class Minus extends Operation {
    @Override
    public int getResult() {
        return num1-num2; }
}
public class Add extends Operation {
    @Override
    public int getResult() {
        return num1+num2;
    }
}

/**
 * @author wuyimin
 * @create 2021-07-24 16:34
 * @description 简单工厂类
 * 由这个工厂来决定返回出什么样的对象
 */
public class SimpleFactory {
    public static Operation createOperation(String op) {
        Operation operation = null;
        switch (op) {
            case "+":
                operation = new Add();
                break;
            case "-":
                operation = new Minus();
                break;
            default:
                break;
        }
        return operation;
    }
}

public class MyFactoryTest {
    @Test
    public void test01(){
        String op="+";
        Operation operation = SimpleFactory.createOperation(op);
        operation.setNum1(10);
        operation.setNum2(5);
        System.out.println(operation.getResult());

    }
}

优点

工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

缺点

由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。

当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

这些缺点在工厂方法模式中得到了一定的克服。

工厂方法模式

创建一个创造对象的抽象方法，由子类决定要实例化的类

抽象类

public abstract class Factory {
    public abstract Product create();
}

public abstract class Product {
    public abstract void show();
}

抽象类的子类

public class ProductA extends Product{
    @Override
    public void show() {
        System.out.println("生产了A");
    }
}
public class ProductB extends Product{
    @Override
    public void show() {
        System.out.println("生产了A");
    }
}
public class FactoryA extends Factory {

    @Override
    public ProductA create() {
        return new ProductA();
    }
}
public class FactoryB extends Factory {
    @Override
    public ProductB create() {
        return new ProductB();
    }
}

测试类

public class TestHere {
    @Test
    public void test01(){
        Factory factory=new FactoryA();
        Product product = factory.create();
        product.show();
    }
}

优点：

更符合开-闭原则
新增一种产品时，只需要增加相应的具体产品类和相应的工厂子类即可
简单工厂模式需要修改工厂类的判断逻辑

符合单一职责原则
每个具体工厂类只负责创建对应的产品
简单工厂中的工厂类存在复杂的switch逻辑判断

不使用静态工厂方法，可以形成基于继承的等级结构。
简单工厂模式的工厂类使用静态工厂方法

总结：工厂模式可以说是简单工厂模式的进一步抽象和拓展，在保留了简单工厂的封装优点的同时，让扩展变得简单，让继承变得可行，增加了多态性的体现。

缺点：

添加新产品时，除了增加新产品类外，还要提供与之对应的具体工厂类，系统类的个数将成对增加，在一定程度上增加了系统的复杂度；同时，有更多的类需要编译和运行，会给系统带来一些额外的开销；
由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。
虽然保证了工厂方法内的对修改关闭，但对于使用工厂方法的类，如果要更换另外一种产品，仍然需要修改实例化的具体工厂类；
一个具体工厂只能创建一种具体产品

抽象工厂模式

3.工厂模式_工厂类_03

三个抽象类

public abstract class AbfactoryA {
    public void common(){
        System.out.println("A的公共方法");
    }
    public abstract void  doSomething();
}
public abstract class AbfactoryB {
    public void common(){
        System.out.println("B的公共方法");
    }
    public abstract void doSomething();
}
public abstract class AbCreator {
    public abstract AbfactoryA createA();
    public abstract AbfactoryB createB();
}

抽象类的实现类(这里只写A)

public class FactoryA1 extends AbfactoryA {

    @Override
    public void doSomething() {
        System.out.println("A1的方法");
    }
}

public class FactoryA2 extends AbfactoryA {
    @Override
    public void doSomething() {
        System.out.println("A2的方法");
    }
}
public class A1B2Creator extends AbCreator {
    @Override
    public AbfactoryA createA() {
        return new FactoryA1();
    }

    @Override
    public AbfactoryB createB() {
        return new FactoryB2();
    }
}