抽象工厂模式和工厂方法模式区别

用种蔬菜的例子来说明事实,最初的时候,由于规模小,只种植一种蔬菜,根菜类蔬菜,这个时候由于种植方式比较简单,采用简单工厂模式即可,主要目的是让工人轻松,下达工厂种植即可,但是随着种植厂的发展以及市场的需求,要增加一种蔬菜类型种植了,茎菜,由于茎菜与根菜种植方式不一致,就需要两个专门的种植工厂来进行管理,那么久采用工厂模式来管理,一个工厂负责一种作物的种植,这个时候产品可以理解为仍然在一个层次。

但是随着科技的发展,我们逐步要种植转基因与非转基因食品了,在以前的蔬菜种类上又增加了一个层次,这个时候无法将其作为一个层次来解决,所以必须采用抽象工厂的方式来解决。我用UML图表示三种结构:

简单工厂模式UML

img

点击并拖拽以移动

简单工厂实现代码

蔬菜接口

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
/**  
* <p> 根菜类蔬菜接口 </p>
* @ClassName:Greenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 16:31
* @since: JDK1.8
* @version V1.0.0
*/
public interface Greenstuff {

/**
* <p> 播种 </p></br>
* @Title: sowing
* @date: 2021-04-01 16:33 void
* @since: 1.0.0
*/
void sowing();

/**
* <p> 成长 </p></br>
* @Title: sowing
* @date: 2021-04-01 16:33 void
* @since: 1.0.0
*/
void growUp();

/**
* <p> 果实 </p></br>
* @Title: sowing
* @date: 2021-04-01 16:33 void
* @since: 1.0.0
*/
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
/**  
* <p> 胡萝卜 </p>
* 1.实现根菜蔬菜接口
* 2.实现根菜蔬菜中的具体方法
* @ClassName:CarotaImpl
* @author: WEI.ZHOU
* @date: 2021-04-01 16:43
* @since: JDK1.8
* @version V1.0.0
*/
public class CarotaImpl implements Greenstuff {

/**
* <p> 播种 </p></br>
* <p>Title: sowing</p>
* @date: 2021-04-01 16:43
* @see club.xiaoandx.experiment3.assignment1.test1.greenstuff.Greenstuff#sowing()
*/
@Override
public void sowing() {
System.out.println("正在播种胡萝卜");
}

/**
* <p> 成长 </p></br>
* <p>Title: growUp</p>
* @date: 2021-04-01 16:43
* @see club.xiaoandx.experiment3.assignment1.test1.greenstuff.Greenstuff#growUp()
*/
@Override
public void growUp() {
System.out.println("胡萝卜努力成长中");
}

/**
* <p> 果实 </p></br>
* <p>Title: fruit</p>
* @date: 2021-04-01 16:43
* @see club.xiaoandx.experiment3.assignment1.test1.greenstuff.Greenstuff#fruit()
*/
@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
/**  
* <p> 土豆 </p>
* 1.实现根菜蔬菜接口
* 2.实现根菜蔬菜中的具体方法
* @ClassName:PotatoImpl
* @author: WEI.ZHOU
* @date: 2021-04-01 16:35
* @since: JDK1.8
* @version V1.0.0
*/
public class PotatoImpl implements Greenstuff {

/**
* <p> 豆类播种 </p></br>
* <p>Title: sowing</p>
* @date: 2021-04-01 16:35
* @see club.xiaoandx.experiment3.assignment1.test1.greenstuff.Greenstuff#sowing()
*/
@Override
public void sowing() {
System.out.println("正在播种土豆");
}

/**
* <p> 成长 </p></br>
* <p>Title: growUp</p>
* @date: 2021-04-01 16:35
* @see club.xiaoandx.experiment3.assignment1.test1.greenstuff.Greenstuff#growUp()
*/
@Override
public void growUp() {
System.out.println("土豆,豆类正在成长");
}

/**
* <p> 果实 </p></br>
* <p>Title: fruit</p>
* @date: 2021-04-01 16:35
* @see club.xiaoandx.experiment3.assignment1.test1.greenstuff.Greenstuff#fruit()
*/
@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
/**  
* <p> 萝卜 </p>
* 1.实现根菜蔬菜接口
* 2.实现根菜蔬菜中的具体方法
* @ClassName:RadishImpl
* @author: WEI.ZHOU
* @date: 2021-04-01 16:45
* @since: JDK1.8
* @version V1.0.0
*/
public class RadishImpl implements Greenstuff {

/**
* <p> 播种 </p></br>
* <p>Title: sowing</p>
* @date: 2021-04-01 16:45
* @see club.xiaoandx.experiment3.assignment1.test1.greenstuff.Greenstuff#sowing()
*/
@Override
public void sowing() {
System.out.println("正在播种萝卜");
}

/**
* <p> 成长 </p></br>
* <p>Title: growUp</p>
* @date: 2021-04-01 16:45
* @see club.xiaoandx.experiment3.assignment1.test1.greenstuff.Greenstuff#growUp()
*/
@Override
public void growUp() {
System.out.println("萝卜正在成长中");
}

/**
* <p> 果实 </p></br>
* <p>Title: fruit</p>
* @date: 2021-04-01 16:45
* @see club.xiaoandx.experiment3.assignment1.test1.greenstuff.Greenstuff#fruit()
*/
@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
/**  
* <p> 大头菜 </p>
* 1.实现根菜蔬菜接口
* 2.实现根菜蔬菜中的具体方法
* @ClassName:TurnipImpl
* @author: WEI.ZHOU
* @date: 2021-04-01 16:39
* @since: JDK1.8
* @version V1.0.0
*/
public class TurnipImpl implements Greenstuff {

/**
* <p> 播种 </p></br>
* <p>Title: sowing</p>
* @date: 2021-04-01 16:39
* @see club.xiaoandx.experiment3.assignment1.test1.greenstuff.Greenstuff#sowing()
*/
@Override
public void sowing() {
System.out.println("正在播种大头菜");
}

/**
* <p> 成长 </p></br>
* <p>Title: growUp</p>
* @date: 2021-04-01 16:39
* @see club.xiaoandx.experiment3.assignment1.test1.greenstuff.Greenstuff#growUp()
*/
@Override
public void growUp() {
System.out.println("大头菜正在成长");
}

/**
* <p> 果实 </p></br>
* <p>Title: fruit</p>
* @date: 2021-04-01 16:39
* @see club.xiaoandx.experiment3.assignment1.test1.greenstuff.Greenstuff#fruit()
*/
@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
/**  
* <p> 种植蔬菜工厂 </p>
* 1.通过种植方法得到具体需要种植蔬菜的对象
* @ClassName:CultivateFactory
* @author: WEI.ZHOU
* @date: 2021-04-01 16:48
* @since: JDK1.8
* @version V1.0.0
*/
public class CultivateFactory {

/**
* <p> 获取需要种植蔬菜对象 </p></br>
* @Title: getGreestuff
* @date: 2021-04-01 16:53
* @param type 蔬菜名称
* @return Greenstuff 种植蔬菜对象
* @since: 1.0.0
*/
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
/**  
* <p> 种植根菜蔬菜测试类 </p>
* 1. 通过根菜蔬菜工厂获取需要种植的蔬菜对象
* 2. 调用对象中的方法进行种植
* @ClassName:TestGreenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 16:54
* @since: JDK1.8
* @version V1.0.0
*/
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

img

点击并拖拽以移动

工厂方法模式实现代码

蔬菜接口

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
/**  
* <p> 蔬菜 </p>
* @ClassName:Greenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 16:31
* @since: JDK1.8
* @version V1.0.0
*/
public interface Greenstuff {

/**
* <p> 播种 </p></br>
* @Title: sowing
* @date: 2021-04-01 16:33 void
* @since: 1.0.0
*/
void sowing();

/**
* <p> 成长 </p></br>
* @Title: sowing
* @date: 2021-04-01 16:33 void
* @since: 1.0.0
*/
void growUp();

/**
* <p> 果实 </p></br>
* @Title: sowing
* @date: 2021-04-01 16:33 void
* @since: 1.0.0
*/
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
/**  
* <p> 根菜蔬菜 </p>
* 1. 实现蔬菜的具体种植方法
* @ClassName:RootGreenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 17:10
* @since: JDK1.8
* @version V1.0.0
*/
public class RootGreenstuff implements Greenstuff {

/**
* <p> 播种 </p></br>
* <p>Title: sowing</p>
* @date: 2021-04-01 17:10
* @see club.xiaoandx.experiment3.assignment1.test2.greenstuff.Greenstuff#sowing()
*/
@Override
public void sowing() {
System.out.println("正在种植根菜蔬菜");
}

/**
* <p> 成长 </p></br>
* <p>Title: growUp</p>
* @date: 2021-04-01 17:10
* @see club.xiaoandx.experiment3.assignment1.test2.greenstuff.Greenstuff#growUp()
*/
@Override
public void growUp() {
System.out.println("种植的根菜蔬菜正在成长中");
}

/**
* <p> 果实 </p></br>
* <p>Title: fruit</p>
* @date: 2021-04-01 17:10
* @see club.xiaoandx.experiment3.assignment1.test2.greenstuff.Greenstuff#fruit()
*/
@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
/**  
* <p> 茎菜蔬菜 </p>
* 1. 实现蔬菜接口的全部方法
* @ClassName:StemGreenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 17:18
* @since: JDK1.8
* @version V1.0.0
*/
public class StemGreenstuff implements Greenstuff {

/**
* <p> 播种 </p></br>
* <p>Title: sowing</p>
* @date: 2021-04-01 17:18
* @see club.xiaoandx.experiment3.assignment1.test2.greenstuff.Greenstuff#sowing()
*/
@Override
public void sowing() {
System.out.println("正在播种茎菜蔬菜");
}

/**
* <p> 成长 </p></br>
* <p>Title: growUp</p>
* @date: 2021-04-01 17:18
* @see club.xiaoandx.experiment3.assignment1.test2.greenstuff.Greenstuff#growUp()
*/
@Override
public void growUp() {
System.out.println("播种的茎菜蔬菜种植茁壮成长");
}

/**
* <p> 果实 </p></br>
* <p>Title: fruit</p>
* @date: 2021-04-01 17:18
* @see club.xiaoandx.experiment3.assignment1.test2.greenstuff.Greenstuff#fruit()
*/
@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
/**  
* <p> 蔬菜种植工厂方法 </p>
* 1. 具体蔬菜类别的工厂方法需要实现本接口
* @ClassName:GreenstuffFactory
* @author: WEI.ZHOU
* @date: 2021-04-01 17:21
* @since: JDK1.8
* @version V1.0.0
*/
public interface GreenstuffFactory {

/**
* <p> 获取种植蔬菜对象 </p></br>
* @Title: getGreenstuff
* @date: 2021-04-01 17:22
* @return Greenstuff
* @since: 1.0.0
* @throws
*/
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
/**  
* <p> 根菜蔬菜创建工厂 </p>
* @ClassName:RootGreenstuffFactory
* @author: WEI.ZHOU
* @date: 2021-04-01 17:24
* @since: JDK1.8
* @version V1.0.0
*/
public class RootGreenstuffFactory implements GreenstuffFactory {

/**
* <p> 获取根菜蔬菜种植对象 </p></br>
* <p>Title: getGreenstuff</p>
* @date: 2021-04-01 17:24
* @return Greenstuff 蔬菜种植对象
* @see club.xiaoandx.experiment3.assignment1.test2.factory.GreenstuffFactory#getGreenstuff()
*/
@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
/**  
* <p> 茎菜蔬菜创建工厂 </p>
*
* @ClassName:StemGreenstuffFactory
* @author: WEI.ZHOU
* @date: 2021-04-01 17:28
* @since: JDK1.8
* @version V1.0.0
*/
public class StemGreenstuffFactory implements GreenstuffFactory {

/**
* <p> 获取茎菜蔬菜种植对象 </p></br>
* <p>Title: getGreenstuff</p>
* @date: 2021-04-01 17:28
* @return Greenstuff 蔬菜种植对象
* @see club.xiaoandx.experiment3.assignment1.test2.factory.GreenstuffFactory#getGreenstuff()
*/
@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
/**  
* <p> 蔬菜种植工厂方法测试类 </p>
* 1. 通过蔬菜工厂接口具体实现的蔬菜类别工厂获取需要种植的蔬菜对象
* 2. 调用蔬菜对象的种植方法进行种植
* @ClassName:TestGreenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 17:30
* @since: JDK1.8
* @version V1.0.0
*/
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

img

点击并拖拽以移动

抽象工厂模式实现代码

蔬菜接口

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
/**  
* <p> 蔬菜 </p>
*
* @ClassName:Greenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 19:33
* @since: JDK1.8
* @version V1.0.0
*/
public interface Greenstuff {

/**
* <p> 播种 </p></br>
* @Title: sowing
* @date: 2021-04-01 16:33 void
* @since: 1.0.0
*/
void sowing();

/**
* <p> 成长 </p></br>
* @Title: sowing
* @date: 2021-04-01 16:33 void
* @since: 1.0.0
*/
void growUp();

/**
* <p> 果实 </p></br>
* @Title: sowing
* @date: 2021-04-01 16:33 void
* @since: 1.0.0
*/
void fruit();
}

点击并拖拽以移动

根菜实现蔬菜接口

1
2
3
4
5
6
7
8
9
10
11
/**  
* <p> 根菜蔬菜 </p>
* @ClassName:RootGreenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 19:34
* @since: JDK1.8
* @version V1.0.0
*/
public interface RootGreenstuff extends Greenstuff {

}

点击并拖拽以移动

茎菜实现蔬菜接口

1
2
3
4
5
6
7
8
9
10
11
/**  
* <p> 茎菜蔬菜 </p>
* @ClassName:StemGreenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 19:35
* @since: JDK1.8
* @version V1.0.0
*/
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
/**  
* <p> 转基因 根菜 蔬菜 </p>
* @ClassName:TransgenosisRootGreenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 19:37
* @since: JDK1.8
* @version V1.0.0
*/
public class TransgenosisRootGreenstuff implements RootGreenstuff {

/**
* <p> 播种 </p></br>
* <p>Title: sowing</p>
* @date: 2021-04-01 19:37
* @see club.xiaoandx.experiment3.assignment1.test3.greenstuff.Greenstuff#sowing()
*/
@Override
public void sowing() {
System.out.println("播种转基因根菜蔬菜");
}

/**
* <p> 成长 </p></br>
* <p>Title: growUp</p>
* @date: 2021-04-01 19:37
* @see club.xiaoandx.experiment3.assignment1.test3.greenstuff.Greenstuff#growUp()
*/
@Override
public void growUp() {
System.out.println("播种的转基因根菜已经在成长中");
}

/**
* <p> 果实 </p></br>
* <p>Title: fruit</p>
* @date: 2021-04-01 19:37
* @see club.xiaoandx.experiment3.assignment1.test3.greenstuff.Greenstuff#fruit()
*/
@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
/**  
* <p> 非转基因根菜蔬菜 </p>
*
* @ClassName:NotTransgenosisRootGreenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 19:40
* @since: JDK1.8
* @version V1.0.0
*/
public class NotTransgenosisRootGreenstuff implements RootGreenstuff {

/**
* <p> 播种 </p></br>
* <p>Title: sowing</p>
* @date: 2021-04-01 19:40
* @see club.xiaoandx.experiment3.assignment1.test3.greenstuff.Greenstuff#sowing()
*/
@Override
public void sowing() {
System.out.println("非转基因根菜正在播种");
}

/**
* <p> 成长 </p></br>
* <p>Title: growUp</p>
* @date: 2021-04-01 19:40
* @see club.xiaoandx.experiment3.assignment1.test3.greenstuff.Greenstuff#growUp()
*/
@Override
public void growUp() {
System.out.println("播种的非转基因根菜已经在成长中");
}

/**
* <p>果实 </p></br>
* <p>Title: fruit</p>
* @date: 2021-04-01 19:40
* @see club.xiaoandx.experiment3.assignment1.test3.greenstuff.Greenstuff#fruit()
*/
@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
/**  
* <p> 转基因 茎菜 蔬菜 </p>
* @ClassName:TransgenosisStemGreenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 19:37
* @since: JDK1.8
* @version V1.0.0
*/
public class TransgenosisStemGreenstuff implements RootGreenstuff {

/**
* <p> 播种 </p></br>
* <p>Title: sowing</p>
* @date: 2021-04-01 19:37
* @see club.xiaoandx.experiment3.assignment1.test3.greenstuff.Greenstuff#sowing()
*/
@Override
public void sowing() {
System.out.println("播种转基因茎菜蔬菜");
}

/**
* <p> 成长 </p></br>
* <p>Title: growUp</p>
* @date: 2021-04-01 19:37
* @see club.xiaoandx.experiment3.assignment1.test3.greenstuff.Greenstuff#growUp()
*/
@Override
public void growUp() {
System.out.println("播种的转基因茎菜已经在成长中");
}

/**
* <p> 果实 </p></br>
* <p>Title: fruit</p>
* @date: 2021-04-01 19:37
* @see club.xiaoandx.experiment3.assignment1.test3.greenstuff.Greenstuff#fruit()
*/
@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
/**  
* <p> 非转基因茎菜蔬菜 </p>
* @ClassName:NotTransgenosisStemGreenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 19:40
* @since: JDK1.8
* @version V1.0.0
*/
public class NotTransgenosisStemGreenstuff implements RootGreenstuff {

/**
* <p> 播种 </p></br>
* <p>Title: sowing</p>
* @date: 2021-04-01 19:40
* @see club.xiaoandx.experiment3.assignment1.test3.greenstuff.Greenstuff#sowing()
*/
@Override
public void sowing() {
System.out.println("非转基因茎菜正在播种");
}

/**
* <p> 成长 </p></br>
* <p>Title: growUp</p>
* @date: 2021-04-01 19:40
* @see club.xiaoandx.experiment3.assignment1.test3.greenstuff.Greenstuff#growUp()
*/
@Override
public void growUp() {
System.out.println("播种的非转基因茎菜已经在成长中");
}

/**
* <p>果实 </p></br>
* <p>Title: fruit</p>
* @date: 2021-04-01 19:40
* @see club.xiaoandx.experiment3.assignment1.test3.greenstuff.Greenstuff#fruit()
*/
@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
/**  
* <p> 蔬菜工厂 </p>
* 1. 提供种根菜与种茎菜方法
* @ClassName:GreenstuffFactory
* @author: WEI.ZHOU
* @date: 2021-04-01 19:45
* @since: JDK1.8
* @version V1.0.0
*/
public interface GreenstuffFactory {

/**
* <p> 根菜蔬菜 </p></br>
* @Title: getRootGreebstuff
* @date: 2021-04-01 19:47
* @return: Greenstuff 种植的蔬菜
* @since: 1.0.0
*/
Greenstuff getRootGreebstuff();

/**
* <p> 茎菜蔬菜 </p></br>
* @Title: getStemGreenstuff
* @date: 2021-04-01 19:47
* @return: Greenstuff 种植的蔬菜
* @since: 1.0.0
*/
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
/**  
* <p> 种植转基因工厂 </p>
* 1. 转基因工厂实现蔬菜工作
* 2. 转基因工厂可以种植->转基因根菜蔬菜 or 转基因茎菜蔬菜
* @ClassName:TransgenosisFactory
* @author: WEI.ZHOU
* @date: 2021-04-01 19:49
* @since: JDK1.8
* @version V1.0.0
*/
public class TransgenosisFactory implements GreenstuffFactory {

/**
* <p> 转基因根菜蔬菜 </p></br>
* <p>Title: getRootGreebstuff</p>
* @return: Greenstuff 种植转基因根菜蔬菜
* @date: 2021-04-01 19:49
* @see club.xiaoandx.experiment3.assignment1.test3.factory.GreenstuffFactory#getRootGreebstuff()
*/
@Override
public Greenstuff getRootGreebstuff() {
return new TransgenosisRootGreenstuff();
}

/**
* <p> 转基因茎菜蔬菜 </p></br>
* <p>Title: getStemGreenstuff</p>
* @return: Greenstuff 种植转基因茎菜蔬菜
* @date: 2021-04-01 19:49
* @see club.xiaoandx.experiment3.assignment1.test3.factory.GreenstuffFactory#getStemGreenstuff()
*/
@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
/**  
* <p> 种植非转基因工厂 </p>
* 1. 转基因工厂实现蔬菜工作
* 2. 转基因工厂可以种植->非转基因根菜蔬菜 or 非转基因茎菜蔬菜
* @ClassName:NotTransgenosisFactory
* @author: WEI.ZHOU
* @date: 2021-04-01 19:49
* @since: JDK1.8
* @version V1.0.0
*/
public class NotTransgenosisFactory implements GreenstuffFactory {

/**
* <p> 非转基因根菜蔬菜 </p></br>
* <p>Title: getRootGreebstuff</p>
* @return: Greenstuff 种植非转基因根菜蔬菜
* @date: 2021-04-01 19:49
* @see club.xiaoandx.experiment3.assignment1.test3.factory.GreenstuffFactory#getRootGreebstuff()
*/
@Override
public Greenstuff getRootGreebstuff() {
return new NotTransgenosisRootGreenstuff();
}

/**
* <p> 非转基因茎菜蔬菜 </p></br>
* <p>Title: getStemGreenstuff</p>
* @return: Greenstuff 种植非转基因茎菜蔬菜
* @date: 2021-04-01 19:49
* @see club.xiaoandx.experiment3.assignment1.test3.factory.GreenstuffFactory#getStemGreenstuff()
*/
@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
/**  
* <p> 抽象工厂模式种植蔬菜测试类 </p>
* 1. 向声明创建蔬菜工厂接口
* 2. 在通过实现蔬菜工厂接口的转基因与非转基因类进行种植指定的蔬菜
* 3. 得到需要种植蔬菜对象调用方法进行种植成长收获
* @ClassName:TestGreenstuff
* @author: WEI.ZHOU
* @date: 2021-04-01 19:56
* @since: JDK1.8
* @version V1.0.0
*/
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地址