设计模式之创建新模式一(保姆级讲解，通俗易懂）

1 简单工厂模式

简述：所有对象创建实例化都放在同个工厂类中。

缺点：当新增子类的时候，需要修改工厂类代码。

代码示例：

抽象类

public abstract class BrieFactoryAbstractTest01 {
​
    //做测试A操作
    public void Test1(){
    }
}

实现抽象类—01

public class BrieFactoryClassTest01 extends BrieFactoryAbstractTest01 {
​
    //我们可以重写工厂类 抽象类 的测试A操作
​
    //也可以不实现
}

实现抽象类—02

public class BrieFactoryClassTest02 extends BrieFactoryAbstractTest01 {
​
    //我们可以重写工厂类 抽象类 的测试A操作
​
    //也可以不实现
}

工厂类

public class BrieFactoryTest01 {
​
    public BrieFactoryAbstractTest01 Test01(String type) {
        //当我们实现的抽象类后，我们需要对他进行创建操作，这个时候创建我们是交给工厂类创建的
        BrieFactoryAbstractTest01 test = null;
        if (type.equals("1")) {
            test = new BrieFactoryClassTest01();
        } else if (type.equals("2")) {
            test = new BrieFactoryClassTest02();
        }
        return test;
    }
}

测试类

public class BrieFactoryMainTest01 {
    public static void main(String[] args) {
        BrieFactoryTest01 brieFactoryTest01 = new BrieFactoryTest01();
        brieFactoryTest01.Test01("1");
    }
}

2 工厂方法模式

简述：由子类自己决定哪些对象创建实例化。

缺点：子类自己创建工厂类增加复杂性，而且当工厂类的代码发生改变那么调用该工厂类的类也需要进行修改。

代码示例：

抽象类:创建个抽象方法

public abstract class ComplexFactoryAbstractTest01 {
    public abstract ComplexFactoryAbstractTest01 test01();
}

工厂类—01

public class ComplexFactoryTest01 extends ComplexFactoryAbstractTest01 {
​
    //我们自己子类实现这个抽象类方法，直接创建一个子类工厂。
    @Override
    public ComplexFactoryAbstractTest01 test01() {
        ComplexFactoryAbstractTest01 test= null;
        test = new ComplexFactoryTest01();
        return test;
    }
}

工厂类—02

public class ComplexFactoryTest02 extends ComplexFactoryAbstractTest01 {
​
    //我们自己子类实现这个抽象类方法，直接创建一个子类工厂。
    @Override
    public ComplexFactoryAbstractTest01 test01() {
        ComplexFactoryAbstractTest01 test= null;
        test = new ComplexFactoryTest02();
        return test;
    }
}

​

测试类

public class ComplexFactoryMainTest01 {
​
    public static void main(String[] args) {
        ComplexFactoryTest01 test01 = new ComplexFactoryTest01();
        test01.test01();
        ComplexFactoryTest02 test02 = new ComplexFactoryTest02();
        test02.test01();
    }
}

3 抽象工厂模式

简述：创建抽象方法的接口，通过入参来判断对工厂类内部对象实例化操作，方便拓展。

代码示例：

抽象类：创建抽象方法

public abstract class AbstractFactoryAbstractTest01 {
    public abstract AbstractFactoryAbstractTest01 test01();
}

抽象方法接口：

public interface AbstractFactoryInterfaceTest01 {
    //我们通过接口方法实现抽象类
    AbstractFactoryAbstractTest01 createTest01(String name);
}

​

实现抽象类型—01

public class AbstractFactoryClassTest01 extends AbstractFactoryAbstractTest01 {
​
    //实现抽象方法
    @Override
    public AbstractFactoryAbstractTest01 test01() {
        return null;
    }
}

实现抽象类型—02

public class AbstractFactoryClassTest02 extends AbstractFactoryAbstractTest01 {
​
    //实现抽象方法
    @Override
    public AbstractFactoryAbstractTest01 test01() {
        return null;
    }
}

实现抽象类型—03

public class AbstractFactoryClassTest03 extends AbstractFactoryAbstractTest01 {
​
    //实现抽象方法
    @Override
    public AbstractFactoryAbstractTest01 test01() {
        return null;
    }
}

实现抽象类型—04

public class AbstractFactoryClassTest04 extends AbstractFactoryAbstractTest01 {
​
    //实现抽象方法
    @Override
    public AbstractFactoryAbstractTest01 test01() {
        return null;
    }
}

工厂类—01

public class AbstractFactoryTest01 implements AbstractFactoryInterfaceTest01 {
    @Override
    public AbstractFactoryAbstractTest01 createTest01(String name) {
        AbstractFactoryAbstractTest01 test = null;
        if (name.equals("1")) {
            test = new AbstractFactoryClassTest01();
        } else if (name.equals("2")) {
            test = new AbstractFactoryClassTest02();
        }
        return test;
    }
}

工厂类-02

public class AbstractFactoryTest02 implements AbstractFactoryInterfaceTest01 {
    @Override
    public AbstractFactoryAbstractTest01 createTest01(String name) {
        AbstractFactoryAbstractTest01 test = null;
        if (name.equals("3")) {
            test = new AbstractFactoryClassTest03();
        } else if (name.equals("4")) {
            test = new AbstractFactoryClassTest04();
        }
        return test;
    }
}

测试类

public class AbstractFactoryMainTest01 {
    public static void main(String[] args) {
        AbstractFactoryTest01 abstractFactoryTest01 = new AbstractFactoryTest01();
        abstractFactoryTest01.createTest01("1");
        AbstractFactoryTest02 abstractFactoryTest02 = new AbstractFactoryTest02();
        abstractFactoryTest02.createTest01("3");
    }
}