GoF23—工厂模式

什么是工厂模式：

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

工厂模式的核心本质：

• 实例化对象不适用new,用工厂方法代替
• 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

三种模式：

简单工厂模式(Simple Factory)（5颗星）

• 用来生产统一等级结构中的任意产品（对于增加新的产品，需要修改原有的代码,代码量虽少，维护性较差！）
• 虽然某种程度上不符合设计原则，但实际上使用最多！

工厂方法模式(Factory Method)（4颗星）

• 用来生产同一等级结构中的固定产品（支持增加任意产品，代码量虽大，但维护性较好！）
• 横向扩展，不影响操作！

抽象工厂模式(Abstract Factory)（4颗星）

• 围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
• 不可以增加产品，可以增加产品族,扩展新的产品非常困难！

简单工厂模式 : (又叫静态工厂模式)

package factory.simple;
//接口
public interface Car {
    void name();
}

1
2
3
4
5
6

package factory.simple;

public class DaZhong implements Car{
    @Override
    public void name() {
        System.out.println("大众");
    }
}

1
2
3
4
5
6
7
8
9

package factory.simple;

public class Tesla implements Car{
    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}

1
2
3
4
5
6
7
8
9

package factory.simple;

public class WuLing implements Car{
    @Override
    public void name() {
        System.out.println("五菱宏光！");
    }
}

1
2
3
4
5
6
7
8
9

package factory.simple;

/**静态工厂模式（简单工厂模式）
 * 缺点：增加一个新的产品，如果你不修改代码，做不到!
 * 没有满足开闭原则
*/

public class CarFactory {

    public static Car getWuLing(){
        return new WuLing();
    }
    public static Car getTesla(){
        return new Tesla();
    }
    public static Car getDaZhong(){
        return new DaZhong();
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

package factory.simple;

//接口的所有实现类！
public class Consumer {
    public static void main(String[] args) {

        CarFactory.getTesla().name();
        CarFactory.getWuLing().name();
        CarFactory.getDaZhong().name();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

工厂方法模式：

package factory.method;

public interface Car {
    void name();
}

1
2
3
4
5
6

package factory.method;

//工厂方法模式
public interface CarFactory {
    Car getCar();
}

1
2
3
4
5
6
7

package factory.method;

public class WuLing implements Car {
    @Override
    public void name() {
        System.out.println("五菱宏光！");
    }
}

1
2
3
4
5
6
7
8
9

package factory.method;

public class WuLingFactory implements CarFactory{
    @Override
    public Car getCar() {
        return  new WuLing();
    }
}

```java
package factory.method;


public class Tesla implements Car {
    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package factory.method;

public class TeslaFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Tesla();
    }
}

1
2
3
4
5
6
7
8
9

package factory.method;

public class MoBai implements Car{
    @Override
    public void name() {
        System.out.println("摩拜单车");
    }
}

1
2
3
4
5
6
7
8
9

package factory.method;

public class MoBaiFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new MoBai();
    }
}

1
2
3
4
5
6
7
8
9

package factory.method;


//接口的所有实现类！
public class Consumer {
    public static void main(String[] args) {

        new WuLingFactory().getCar().name();

        new TeslaFactory().getCar().name();

        new MoBaiFactory().getCar().name();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

抽象工厂模式：

package factory.abstract1;
//手机产品接口
public interface PhoneProduct {
    void start();
    void music();
    void code();
    void shutdown();
}

1
2
3
4
5
6
7
8
9

package factory.abstract1;
//路由器产品接口
public interface RouterProduct {
    void start();
    void openWife();
    void watchTv();
    void shutdown();
}

1
2
3
4
5
6
7
8
9

package factory.abstract1;
//抽象产品工厂
public interface ProductFactory {
    //生产手机
    PhoneProduct phoneProduct();

    //生产路由器
    RouterProduct routerProduct();
    
}

1
2
3
4
5
6
7
8
9
10
11

package factory.abstract1;
//小米手机
public class XiaoMiPhone implements PhoneProduct{
    @Override
    public void start() {
        System.out.println("开启小米手机");
    }

    @Override
    public void music() {
        System.out.println("用小米手机听音乐");
    }

    @Override
    public void code() {
        System.out.println("用小米手机敲代码");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭小米手机");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package factory.abstract1;
//华为手机
public class HuaWeiPhone implements PhoneProduct{
    @Override
    public void start() {
        System.out.println("开启华为手机");
    }

    @Override
    public void music() {
        System.out.println("使用华为手机听音乐");
    }

    @Override
    public void code() {
        System.out.println("使用华为手机敲代码");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭华为手机");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package factory.abstract1;
//小米路由器
public class XiaoMiRouter implements RouterProduct{
    @Override
    public void start() {
        System.out.println("开启小米路由器");
    }

    @Override
    public void openWife() {
        System.out.println("使用小米路由器打开wife");
    }

    @Override
    public void watchTv() {
        System.out.println("使用小米路由器看电视");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭小米路由器");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package factory.abstract1;
//华为路由器
public class HuaWeiRouter implements RouterProduct{
    @Override
    public void start() {
        System.out.println("开启华为路由器");
    }

    @Override
    public void openWife() {
        System.out.println("使用华为路由器打开Wife");
    }

    @Override
    public void watchTv() {
        System.out.println("使用华为路由器看电视");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭华为路由器");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package factory.abstract1;
//小米工厂
public class XiaoMiFactory implements ProductFactory{
    @Override
    public PhoneProduct phoneProduct() {
        return new XiaoMiPhone();
    }

    @Override
    public RouterProduct routerProduct() {
        return new XiaoMiRouter();
    }

    @Override
    public Laptop laptop() {
        return new XiaoMiLaptop();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package factory.abstract1;
//华为工厂
public class HuaWeiFactory implements ProductFactory{
    @Override
    public PhoneProduct phoneProduct() {
        return new HuaWeiPhone();
    }

    @Override
    public RouterProduct routerProduct() {
        return new HuaWeiRouter();
    }

    @Override
    public Laptop laptop() {
        return new HuaWeiLaptop();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package factory.abstract1;
//客户端
public class Client {
    public static void main(String[] args) {
        System.out.println("------------------小米系列产品------------------");
        //小米工厂
        XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();
        PhoneProduct phoneProduct = xiaoMiFactory.phoneProduct();
        phoneProduct.music();
        phoneProduct.code();

        XiaoMiRouter xiaoMiRouter = new XiaoMiRouter();
        xiaoMiRouter.openWife();
        xiaoMiRouter.watchTv();

        System.out.println("------------------华为系列产品------------------");
        HuaWeiFactory huaWeiFactory = new HuaWeiFactory();
        //华为工厂里面的手机产品
        PhoneProduct product = huaWeiFactory.phoneProduct();
        product.code();
        product.music();

        //华为工厂里面的路由器产品
        RouterProduct routerProduct = huaWeiFactory.routerProduct();
        routerProduct.openWife();
        routerProduct.watchTv();

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30