Java创建型设计模式之工厂方法模式深入详解

2022-11-13 17:11:56 模式工厂详解

简单工厂模式

简单工厂模式(Simple Factory Pattern)是指由一个工厂对象决定创建出哪一种产品类的实例，但是它不属于设计模式。

简单工厂适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。

定义产品对象

public interface ICar {
    void create();
}
public class BMCar implements ICar{
    @Override
    public void create(){
        System.out.println("制造BM车");
    }
}
public class ADCar implements ICar {
    @Override
    public void create() {
        System.out.println("制造AD车");
    }
}

创建工厂类

创建一个实现工厂类，所有的对象交由该工厂类创建

public class CarFactory {
    public ICar create(ICar car) {
        if (car instanceof BMCar) {
            return new BMCar();
        } else if (car instanceof ADCar) {
            return new ADCar();
        } else {
            return null;
        }
    }
}
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        ICar bm = carFactory.create(new BMCar());
        bm.create();
        ICar ad = carFactory.create(new ADCar());
        ad.create();
    }

工厂使用反射

上述方式随着业务扩展，就需要修改createAnimal方法中的逻辑代码，不符合开闭原则。

可使用反射技术，即使业务变化扩展，也不需要修改AnimalFactory中的逻辑代码

public class CarFactory {
    public ICar create(String className) {
        try {
            if (!(null == className || "".equals(className))) {
                return (ICar) Class.forName(className).newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        ICar bm = carFactory.create("cn.ybzy.demo.BMCar");
        bm.create();
    }

上述方式的缺点是方法参数是字符串，有着不可控的风险。可进一步优化，使用强制类型限制，控制参数传递

public class CarFactory {
    public ICar create(Class<? extends ICar> clazz) {
        try {
            if (!(null == clazz)) {
                return clazz.newInstance();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        ICar bm = carFactory.create(BMCar.class);
        bm.create();
    }

工厂方法模式

概述

工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。工厂方法模式属于创建型模式。

工厂模式(Factory Pattern)是Java中最常用的设计模式之一。它提供了一种创建对象的最佳方式。

它定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

在工厂方法模式中只需要关心所需产品对应的工厂，无须关心创建细节，而且加入新的产品符合开闭原则。

应用场景

1.创建对象需要大量重复的代码。

2.客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。

3.一个类通过其子类来指定创建哪个对象。

优缺点

优点：

1.一个调用者想创建一个对象，只需要知道其名称就可以

2.扩展性高，如果想增加一个产品，只需要扩展一个工厂类

3.屏蔽产品的具体实现，调用者只关心产品的接口

缺点：

1.每增加一个产品时，都需要增加一个具体类和对象实现工厂，使系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

主要角色

1.抽象产品角色(Product)

工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。

2.具体产品角色(Concrete Product)

这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

3.抽象工厂角色(Creator)

是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

4.具体工厂角色(Concrete Creator)

这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。

工厂方法模式的基本使用

创建抽象产品

创建抽象产品角色，工厂类所创建的产品的父类，封装了产品对象的公共方法

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

创建具体产品

public class Car extends AbstractCar {
    public void run() {
        System.out.println("Car run");
    }
}

创建抽象工厂

public abstract class ICarFactory {
    public abstract <T> T create(Class<T> clazz);
}

创建具体工厂

创建多个实现抽象工厂接口的具体工厂类。负责实现创建产品的内部逻辑，该工厂类可以被直接调用，创建所需的具体对象。

public class CarFactory extends ICarFactory {
    @Override
    public <T> T create(Class<T> clazz) {
        Car car;
        try {
            car = (Car) Class.forName(clazz.getName()).getConstructor().newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return (T) car;
    }
}

客户端执行

通过一个工厂类，对实现了同一接口的一些类进行实例的创建

    public static void main(String[] args) {
        ICarFactory factory = new CarFactory();
        Car car = factory.create(Car.class);
        car.run();
    }

Car run

到此这篇关于Java创建型设计模式之工厂方法模式深入详解的文章就介绍到这了,更多相关Java工厂方法模式内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

相关文章