设计模式-工厂设计模式_请介绍一下·工厂设计模式·

特点

工厂模式属于创建型，是生成创建复杂对象的一种设计模式。通常情况下，工厂模式被分为工厂模式和抽象工厂模式。其中工厂模式也被称为简单工厂模式，它的每一个工厂都是一个单例。抽象工厂模式即为将每个工厂的一些步骤抽象化，达到代码复用的目的。

工厂模式

假使存在一个制造手机的工厂，工厂存在2条生产线，一条制造MiPhone，1条制造HuaPhone；手机存在拨打电话和发送短信的功能。

手机功能接口类

public interface Phone {

    void call();

    void send();

}
1
2
3
4
5
6
7

手机制造工厂类

public class PhoneFactory {

    public Phone makeMiPhone(){
        return new MiPhone();
    }

    public Phone makeHuaPhone(){
        return new HuaPhone();
    }
}
1
2
3
4
5
6
7
8
9
10

MiPhone 生产 （具体实现类）

@Log4j2
public class MiPhone implements Phone{
    @Override
    public void call() {
        log.info("使用MiPhone拨打电话.");
    }

    @Override
    public void send() {
        log.info("使用MiPhone发送短信");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

测试代码

	@Test
    public void testSimpleFactory(){
        PhoneFactory phoneFactory = new PhoneFactory();

        Phone miPhone = phoneFactory.makeMiPhone();
        miPhone.call();
        miPhone.send();

        Phone huaPhone = phoneFactory.makeHuaPhone();
        huaPhone.call();
        huaPhone.send();
    }
1
2
3
4
5
6
7
8
9
10
11
12

测试结果

2021-03-09 10:13:50.998  INFO 66368 --- [           main] org.example.factory.simple.MiPhone       : 使用MiPhone拨打电话.
2021-03-09 10:13:51.000  INFO 66368 --- [           main] org.example.factory.simple.MiPhone       : 使用MiPhone发送短信
2021-03-09 10:13:51.001  INFO 66368 --- [           main] org.example.factory.simple.HuaPhone      : 使用HuaPhone拨打电话.
2021-03-09 10:13:51.001  INFO 66368 --- [           main] org.example.factory.simple.HuaPhone      : 使用HuaPhone发送短信
1
2
3
4

若需要增加另外一条生产线，则只需对工厂类进行扩展即可，符合里式替换原则。

抽象工厂模式

抽象工厂模式是将工厂类抽象化，支持对工厂类的扩展；还是以手机制造为例：2个工厂分别存在一条生产线，1个工厂制造MiPhone，1个工厂制造HuaPhone，当需要获取某个最终产品时，需要选择某个工厂；

手机功能接口类

public interface Phone {

    void call();

    void send();

}
1
2
3
4
5
6
7

工厂抽象接口类

public interface PhoneFactory {

    Phone make();
}
1
2
3
4

MiFactory工厂实现类

@Log4j2
public class MiFactory implements PhoneFactory{

    @Override
    public Phone make() {
        log.info("制造了一个MiPhone.");
        return new MiPhone();
    }
}
1
2
3
4
5
6
7
8
9

Mi工厂生产的手机实现类

@Log4j2
public class MiPhone implements Phone{
    @Override
    public void call() {
        log.info("使用MiPhone拨打电话.");
    }

    @Override
    public void send() {
        log.info("使用MiPhone发送短信");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

HuaFactory工厂实现类

@Log4j2
public class HuaFactory implements PhoneFactory{
    @Override
    public Phone make() {
        log.info("制造了一个HuaPhone.");
        return new HuaPhone();
    }
}
1
2
3
4
5
6
7
8

Hua工厂生产的手机实现类

@Log4j2
public class HuaPhone implements Phone{
    @Override
    public void call() {
        log.info("使用HuaPhone拨打电话.");
    }

    @Override
    public void send() {
        log.info("使用HuaPhone发送短信");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

测试代码

@Test
public void testAbsFactory(){
    PhoneFactory miFactory = new MiFactory();
    Phone miPhone = miFactory.make();
    miPhone.call();
    miPhone.send();

    PhoneFactory huaFactory = new HuaFactory();
    Phone huaPhone = huaFactory.make();
    huaPhone.call();
    huaPhone.send();
}
1
2
3
4
5
6
7
8
9
10
11
12

日志信息

2021-03-09 11:02:51.020  INFO 72896 --- [           main] org.example.factory.abs.MiFactory        : 制造了一个MiPhone.
2021-03-09 11:02:51.024  INFO 72896 --- [           main] org.example.factory.abs.MiPhone          : 使用MiPhone拨打电话.
2021-03-09 11:02:51.024  INFO 72896 --- [           main] org.example.factory.abs.MiPhone          : 使用MiPhone发送短信
2021-03-09 11:02:51.025  INFO 72896 --- [           main] org.example.factory.abs.HuaFactory       : 制造了一个HuaPhone.
2021-03-09 11:02:51.025  INFO 72896 --- [           main] org.example.factory.abs.HuaPhone         : 使用HuaPhone拨打电话.
2021-03-09 11:02:51.025  INFO 72896 --- [           main] org.example.factory.abs.HuaPhone         : 使用HuaPhone发送短信
1
2
3
4
5
6

结论

两种类型的的工厂模式都为了解决创建对像的代码封装的问题，让使用方无须知道对象创建的的具体步骤；