工厂模式概述

简单工厂模式

---

1. 工厂角色：负责创建所有产品。一个具体的类实现。

2. 抽象产品角色：负责所有产品的定义。接口或抽象类实现。

3. 具体产品角色：负责单个产品的细节。一个具体的类实现。

//抽象产品角色
public interface Tesla{
    public void createTesla();
}

//具体产品角色
public class Model3 implement Tesla{
    @Override
    public void createTesla(){
        System.out.println("create a model3..."); 
    }
}
public class Modely implement Tesla{
    @Override
    public void createTesla(){
        System.out.println("create a model y..."); 
    }
}

//工厂角色
public class TeslaFactory{
　　//创建所需的类实例
　　public static Tesla getTesla(String model){
　　　　if ("3".equals(model)){
　　　　　　return new Model3();
　　　　}else if ("y".equals(model)){
　　　　　　return new Modely();
　　　　}
　　}
}

//客户端
public class Customer{
　　public static void main(String[] args){　　　　
　　　　Tesla tesla = getTesla("3");
　　　　tesla.createTesla();
　　}
}
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
31
32
33
34
35
36
37
38

简单工厂优点：实现简单；客户端使用产品时不用自己去创建（new产品实例），只需告诉工厂我需要使用什么产品，即可得到产品。

简单工厂缺点：如果新增一个产品的话会对工厂类代码进行重写，不符合开闭原则（扩展开放，修改关闭）。

工厂方法模式

---

1）抽象工厂角色：负责所有工厂的定义。抽象类或者接口来实现。

2）具体工厂角色：单个具体的工厂，负责生产单个对应的产品。一个具体的类来实现。

3）抽象产品角色：负责所有产品的定义。接口或抽象类实现。

4）具体产品角色：负责单个产品的细节。一个具体的类

工厂方法的主要特点：一个工厂只能生产一种产品，

//抽象产品角色
public interface Tesla{
    public void createTesla();
}

//具体产品角色
public class Model3 implement Tesla{
    @Override
    public void createTesla(){
        System.out.println("create a model3..."); 
    }
}
public class Modely implement Tesla{
    @Override
    public void createTesla(){
        System.out.println("create a model y..."); 
    }
}

//抽象工厂角色
public interface TeslaFactory{
　　public Tesla getTesla();
}

//具体工厂角色
public class Model3Factory implement TeslaFactory{
    @Override
    public Tesla getTesla(){
        return new Model3(); 
    }
}
public class ModelyFactory implement TeslaFactory{
    @Override
    public Tesla getTesla(){
        return new Modely(); 
    }
}
//客户端
public class Customer{
　　public static void main(String[] args){　　　　
　　　　Tesla tesla = new Model3Factory().getTesla();
　　　　tesla.createTesla();
　　}
}
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44

工厂方法优点：符合开闭原则，增加⼀个产品类，只需要实现其他具体的产品类和具体的⼯⼚类；符合单⼀职责原则，每个⼯⼚只负责⽣产对应的产品。

工厂方法缺点：每个产品需要有对应的具体⼯⼚和具体产品类；类的个数容易过多，增加复杂度。

---

抽象工厂模式

1）抽象工厂角色：负责所有工厂的定义，并包含所有产品的定义。抽象类或者接口来实现。

2）具体工厂角色：负责生产对应的产品族。一个具体的类来实现。

3）抽象产品角色：负责单个产品的定义。接口或抽象类实现。

4）具体产品角色：负责单个产品的细节。一个具体的类

抽象工厂和工厂方法的主要区别是：工厂方法一个工厂只有一条产品，抽象工厂一个工厂有多条产品。

/**
 * 抽象产品智能手机
 */
public interface ISmartPhone {

    void printInfo();

}
/**
 * 抽象产品智能汽车
 */
public interface ISmartCar {
    void printInfo();
}




/**
 * @date 2023/5/17 上午11:19
 * @desc 具体产品 华为智能汽车
 * Created with IntelliJ IDEA
 */
public class HuaweiSmartCar implements ISmartCar {
    @Override
    public void printInfo() {
        System.out.println("华为智能汽车");
    }
}

/**
 * @author guogq
 * @date 2023/5/17 上午11:19
 * @desc  具体产品 华为智能手机
 * Created with IntelliJ IDEA
 */
public class HuaweiSmartPhone implements ISmartPhone {
    @Override
    public void printInfo() {
        System.out.println("华为智能手机");
    }
}

/**
 * 智能产品抽象工厂
 */
public interface SmartProductFactory {

    ISmartPhone createSmartPhone();

    ISmartCar createSmartCar();

}


/**
 * @date 2023/5/17 上午11:18
 * @desc  具体工厂 华为工厂
 * Created with IntelliJ IDEA
 */
public class HuaweiFactory implements SmartProductFactory {
    @Override
    public ISmartPhone createSmartPhone() {
        return new HuaweiSmartPhone();
    }

    @Override
    public ISmartCar createSmartCar() {
        return new HuaweiSmartCar();
    }
}

//客户端调用
public static void main(String[] args) {
        HuaweiFactory huaweiFactory = new HuaweiFactory();
        huaweiFactory.createSmartPhone().printInfo();
        huaweiFactory.createSmartCar().printInfo();
    }







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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85