用种蔬菜的例子来说明事实，最初的时候，由于规模小，只种植一种蔬菜，根菜类蔬菜，这个时候由于种植方式比较简单，采用简单工厂模式即可，主要目的是让工人轻松，下达工厂种植即可，但是随着种植厂的发展以及市场的需求，要增加一种蔬菜类型种植了，茎菜，由于茎菜与根菜种植方式不一致，就需要两个专门的种植工厂来进行管理，那么久采用工厂模式来管理，一个工厂负责一种作物的种植，这个时候产品可以理解为仍然在一个层次。
但是随着科技的发展，我们逐步要种植转基因与非转基因食品了，在以前的蔬菜种类上又增加了一个层次，这个时候无法将其作为一个层次来解决，所以必须采用抽象工厂的方式来解决。我用UML图表示三种结构：
简单工厂模式UML
简单工厂实现代码
蔬菜接口
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
|
public interface Greenstuff {
void sowing();
void growUp();
void fruit();
}
|
具体蔬菜胡萝卜的实现
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
|
public class CarotaImpl implements Greenstuff {
@Override
public void sowing() {
System.out.println("正在播种胡萝卜");
}
@Override
public void growUp() {
System.out.println("胡萝卜努力成长中");
}
@Override
public void fruit() {
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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
public class PotatoImpl implements Greenstuff {
@Override
public void sowing() {
System.out.println("正在播种土豆");
}
@Override
public void growUp() {
System.out.println("土豆，豆类正在成长");
}
@Override
public void fruit() {
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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
public class RadishImpl implements Greenstuff {
@Override
public void sowing() {
System.out.println("正在播种萝卜");
}
@Override
public void growUp() {
System.out.println("萝卜正在成长中");
}
@Override
public void fruit() {
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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
public class TurnipImpl implements Greenstuff {
@Override
public void sowing() {
System.out.println("正在播种大头菜");
}
@Override
public void growUp() {
System.out.println("大头菜正在成长");
}
@Override
public void fruit() {
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
25
26
27
28
29
30
31
32
33
34
35
|
public class CultivateFactory {
public Greenstuff getGreestuff(String type) {
if(type.equalsIgnoreCase("turnip")) {
return new TurnipImpl();
}
if(type.equalsIgnoreCase("radish")) {
return new RadishImpl();
}
if(type.equalsIgnoreCase("potato")) {
return new PotatoImpl();
}
if(type.equalsIgnoreCase("carota")) {
return new CarotaImpl();
}
return null;
}
}
|
蔬菜简单工厂测试代码
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
|
public class TestGreenstuff {
public static void main(String[] args) {
CultivateFactory cultivateFactory = new CultivateFactory();
Greenstuff turnipGreenstuff = cultivateFactory.getGreestuff("turnip");
turnipGreenstuff.sowing();
turnipGreenstuff.growUp();
turnipGreenstuff.fruit();
System.out.println("==========================================");
Greenstuff radishGreenstuff = cultivateFactory.getGreestuff("radish");
radishGreenstuff.sowing();
radishGreenstuff.growUp();
radishGreenstuff.fruit();
System.out.println("==========================================");
Greenstuff potatoGreenstuff = cultivateFactory.getGreestuff("potato");
potatoGreenstuff.sowing();
potatoGreenstuff.growUp();
potatoGreenstuff.fruit();
System.out.println("==========================================");
Greenstuff carotaGreenstuff = cultivateFactory.getGreestuff("carota");
carotaGreenstuff.sowing();
carotaGreenstuff.growUp();
carotaGreenstuff.fruit();
System.out.println("==========================================");
}
}
|
工厂方法UML
工厂方法模式实现代码
蔬菜接口
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
|
public interface Greenstuff {
void sowing();
void growUp();
void fruit();
}
|
具体实现-根菜蔬菜
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
|
public class RootGreenstuff implements Greenstuff {
@Override
public void sowing() {
System.out.println("正在种植根菜蔬菜");
}
@Override
public void growUp() {
System.out.println("种植的根菜蔬菜正在成长中");
}
@Override
public void fruit() {
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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
public class StemGreenstuff implements Greenstuff {
@Override
public void sowing() {
System.out.println("正在播种茎菜蔬菜");
}
@Override
public void growUp() {
System.out.println("播种的茎菜蔬菜种植茁壮成长");
}
@Override
public void fruit() {
System.out.println("成长的茎菜蔬菜，成熟得到果实");
}
}
|
蔬菜工厂方法接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public interface GreenstuffFactory {
Greenstuff getGreenstuff();
}
|
具体实现-根菜工厂方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public class RootGreenstuffFactory implements GreenstuffFactory {
@Override
public Greenstuff getGreenstuff() {
return new RootGreenstuff();
}
}
|
具体实现-茎菜工厂方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public class StemGreenstuffFactory implements GreenstuffFactory {
@Override
public Greenstuff getGreenstuff() {
return new StemGreenstuff();
}
}
|
工厂方法模式测试代码
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
|
public class TestGreenstuff {
public static void main(String[] args) {
GreenstuffFactory rootGreenstuffFactory = new RootGreenstuffFactory();
Greenstuff rootGreenstuff = rootGreenstuffFactory.getGreenstuff();
GreenstuffFactory stemGreenstuffFactory = new StemGreenstuffFactory();
Greenstuff stemGreenstuff = stemGreenstuffFactory.getGreenstuff();
rootGreenstuff.sowing();
rootGreenstuff.growUp();
rootGreenstuff.fruit();
System.out.println("===============================");
stemGreenstuff.sowing();
stemGreenstuff.growUp();
stemGreenstuff.fruit();
}
}
|
抽象工厂模式UML
抽象工厂模式实现代码
蔬菜接口
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
|
public interface Greenstuff {
void sowing();
void growUp();
void fruit();
}
|
根菜实现蔬菜接口
1
2
3
4
5
6
7
8
9
10
11
|
public interface RootGreenstuff extends Greenstuff {
}
|
茎菜实现蔬菜接口
1
2
3
4
5
6
7
8
9
10
11
|
public interface StemGreenstuff extends Greenstuff {
}
|
具体实现根菜接口-转基因根菜蔬菜
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
|
public class TransgenosisRootGreenstuff implements RootGreenstuff {
@Override
public void sowing() {
System.out.println("播种转基因根菜蔬菜");
}
@Override
public void growUp() {
System.out.println("播种的转基因根菜已经在成长中");
}
@Override
public void fruit() {
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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
public class NotTransgenosisRootGreenstuff implements RootGreenstuff {
@Override
public void sowing() {
System.out.println("非转基因根菜正在播种");
}
@Override
public void growUp() {
System.out.println("播种的非转基因根菜已经在成长中");
}
@Override
public void fruit() {
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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
public class TransgenosisStemGreenstuff implements RootGreenstuff {
@Override
public void sowing() {
System.out.println("播种转基因茎菜蔬菜");
}
@Override
public void growUp() {
System.out.println("播种的转基因茎菜已经在成长中");
}
@Override
public void fruit() {
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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
public class NotTransgenosisStemGreenstuff implements RootGreenstuff {
@Override
public void sowing() {
System.out.println("非转基因茎菜正在播种");
}
@Override
public void growUp() {
System.out.println("播种的非转基因茎菜已经在成长中");
}
@Override
public void fruit() {
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
25
26
27
28
29
|
public interface GreenstuffFactory {
Greenstuff getRootGreebstuff();
Greenstuff getStemGreenstuff();
}
|
具体实现工厂-转基因工厂
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
|
public class TransgenosisFactory implements GreenstuffFactory {
@Override
public Greenstuff getRootGreebstuff() {
return new TransgenosisRootGreenstuff();
}
@Override
public Greenstuff getStemGreenstuff() {
return new TransgenosisStemGreenstuff();
}
}
|
具体实现工厂-非转基因工厂
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
|
public class NotTransgenosisFactory implements GreenstuffFactory {
@Override
public Greenstuff getRootGreebstuff() {
return new NotTransgenosisRootGreenstuff();
}
@Override
public Greenstuff getStemGreenstuff() {
return new NotTransgenosisStemGreenstuff();
}
}
|
抽象工厂测试蔬菜种植
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
|
public class TestGreenstuff {
public static void main(String[] args) {
GreenstuffFactory transgenosisFactory = new TransgenosisFactory();
Greenstuff transgenosisRootGreenstuff = transgenosisFactory.getRootGreebstuff();
Greenstuff transgenosisStemGreenstuff = transgenosisFactory.getStemGreenstuff();
GreenstuffFactory notTransgenosisFactory = new NotTransgenosisFactory();
Greenstuff notTransgenosisRootGreebstuff = notTransgenosisFactory.getRootGreebstuff();
Greenstuff notTransgenosisStemGreenstuff = notTransgenosisFactory.getStemGreenstuff();
transgenosisRootGreenstuff.sowing();
transgenosisRootGreenstuff.growUp();
transgenosisRootGreenstuff.fruit();
System.out.println("==============================");
transgenosisStemGreenstuff.sowing();
transgenosisStemGreenstuff.growUp();
transgenosisStemGreenstuff.fruit();
System.out.println("==============================");
notTransgenosisRootGreebstuff.sowing();
notTransgenosisRootGreebstuff.growUp();
notTransgenosisRootGreebstuff.fruit();
System.out.println("==============================");
notTransgenosisStemGreenstuff.sowing();
notTransgenosisStemGreenstuff.growUp();
notTransgenosisStemGreenstuff.fruit();
}
}
|
上面的的UML图很明显的就看出来了，抽象工厂可以创建多个产品类对象，如在种菜工厂中，有种根菜，种茎菜。工厂模式与抽象工厂模式以及简单工厂模式只有在具体应用的时候，分析具体的产品层级，然后选择相应的设计模式。
种菜工人所关心的对象也不一样，在简单工厂模式下，工人要想到种植萝卜还是白菜，在工厂模式下，工人想到是种植根菜还是茎菜，而在抽象工厂模式下，则关心种植基因菜还是非基因菜
实现代码本文作者原创 完整案例实现代码Git地址
