设计模式概览

简单工厂模式

简单工厂模式(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车");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

创建工厂类

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

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();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

工厂使用反射

上述方式随着业务扩展，就需要修改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();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

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();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

工厂方法模式

概述

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

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

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

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

应用场景

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

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

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

优缺点

优点：

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

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

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

缺点：

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

主要角色

1.抽象产品角色(Product)

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

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

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

3.抽象工厂角色(Creator)

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

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

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

工厂方法模式的基本使用

创建抽象产品

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

public abstract class AbstractCar {

    public abstract void run();
}
1
2
3
4

创建具体产品

public class Car extends AbstractCar {

    public void run() {
        System.out.println("Car run");
    }
}
1
2
3
4
5
6

创建抽象工厂

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

创建具体工厂

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

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

客户端执行

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

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

Car run
1