设计模式-工厂模式分析摘要

首先出现一个生动的例子:

大众汽车的MQB平台现已成为非常著名的卧式发动机模块化生产平台. 通过这个平台，诞生了许多知名的汽车模型，例如奥迪TT，大众Polo，高尔夫等. 抽象地思考，这些汽车都是来自生产平台，而不是每辆汽车都拥有一个平台移动设计模式，那么问题是，如何制造一个平台来生产多种车型？

以上述三种模型为例，我们首先定义三种类型的车辆

public class AudiTT {
    public void run() {
        System.out.println("AudiTT run...");
    }
}
public class Polo {
    public void run() {
        System.out.println("Polo run...");
    }
}
public class Golf {
    public void run() {
        System.out.println("Golf run...");
    }
}

如何使平台产生三种模型？有些学生会提出这样的方法，让平台实现每种模型的生产方法，所以我有以下代码

public class Factory {
    public AudiTT produceAudiTT() {
        return new AudiTT();
    }
    public Polo producePolo() {
        return new Polo();
    }
    public Golf produceGolf() {
        return new Golf();
    }
}

编写场景类测试

public class Test {
    public static void main(String[] args) {
        Factory factory = new Factory();
        AudiTT audiTT = factory.produceAudiTT();
        Polo polo = factory.producePolo();
        audiTT.run();
        polo.run();
    }
}

输出结果

AudiTT运行...

马球跑...

这样做似乎是可行的，但是我们注意到这个工厂类实际上没有任何作用，这等效于我们自己创建了一个特定的汽车对象，并且在接收工厂生产的对象时不能使用它. 要接收一个统一的类，并且每次添加汽车类时，都需要修改工厂类. 工厂类和汽车类之间的耦合非常强，增加了出错的风险，并且代码重用率不高，这与设计不符. 有原则的.

为了增强类之间的分离，我们引入了一个抽象类来定义产品的公共行为. 在此示例中，它是run（）方法. 我们将Car类定义为car类的公共父类.

public abstract class Car {
    public abstract void run();
}

这时，这三个car类相应地继承了Car类并覆盖run（）方法

public class AudiTT extends Car{
    @Override
    public void run() {
        System.out.println("AudiTT run...");
    }
}
public class Polo extends Car {
    @Override
    public void run() {
        System.out.println("Polo run...");
    }
}
public class Golf extends Car{
    @Override
    public void run() {
        System.out.println("Golf run...");
    }
}

这时，工厂类可能会发生重大变化，我们引入了抽象工厂类

public abstract class AbsFactory {
    public abstract <T extends Car> T produce(Class<T> clazz);
}

引入具体工厂类以继承抽象工厂，重写生产方法

public class Factory extends AbsFactory{
    @Override
    public <T extends Car> T produce(Class<T> clazz) {
        Car car = null;
        try {
            car = (Car)Class.forName(clazz.getName()).getDeclaredConstructor().newInstance();
        }catch (Exception e) {
            e.printStackTrace();
        }
        return (T)car;
    }
}

编写场景类进行实验

public class Test {
    public static void main(String[] args) {
        AbsFactory factory = new Factory();
        Car audiTT = factory.produce(AudiTT.class);
        Car polo = factory.produce(Polo.class);
        audiTT.run();
        polo.run();
    }
}

输出结果:

AudiTT运行...

马球跑...

现在，每次添加汽车类时，我们都不再需要修改工厂类. 只要传递特定类别的对象信息，工厂类别就可以根据需要生成相应的汽车对象，并且汽车类别和工厂类别是分离的. 增加代码重用.

我们注意到，在测试类中，我们都使用父类对象来接收子类对象，这在Java中是可行的，使用Java中子类的向上转换来实现接收变量的统一，也是利用Java的反射功能的具体工厂类.

还可以将所有特定产品类的公共属性和方法添加到抽象产品类中以进行扩展. 同时，抽象工厂类也可以具有多个不同的子类，以实现不同产品（例如汽车工厂）的多种生产. ，计算机工厂和其他性质不同的产品工厂进行扩展.

将类的实例化延迟到子类，实现类之间的解耦，屏蔽产品类，并增强代码重用性.

如果您使用JDBC连接到移动设计模式，并且从MySQL更改为Oracle，则唯一要做的就是更改驱动程序名称，而无需进行其他更改

我们可以轻松地从上述代码中提取通用模板

抽象产品类别

public abstract class AbsProduct {
    //产品类的公共方法
    public void method1() {
        
    }
    //具体产品类的具体方法，留给子类具体实现
    public abstract void method2();
}

特定产品类别

public class ConcreteProduct extends AbsProduct {
    @Override
    public void method2() {
        
    }
}

一个特定的产品类别可以不止一个，更多的可以体现出工厂模型的优势

抽象工厂类

public abstract class AbsFactory {
    public abstract <T extends AbsProduct> T produce(Class<T> c);
}

特定工厂类

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/tongxinshuyu/article-248047-1.html