工厂方法设计模式

前言

工厂方法模式又被称为多态工厂模式,通俗的讲就是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中,因此,也属于创建型模式

Alt text
这里Jungle的每个具体类都对应一个具体工厂
下面就是以工厂方法创建它们,通过抽象工厂选择不同的具体子工厂,从而产生不同的具体打野类

打野接口

1
2
3
4
5
6
7
8
9
10
11
12
13
//打野英雄
public interface Jungle {
//gank能力强
public void gankenemy();
//本身足够灵活
public void flexible();
//打野不太伤
public void killbeast();
}

工厂接口

1
2
3
4
public interface junglefactor {
//产生打野
public Jungle createjungle();
}

盲僧

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class LeeSin implements Jungle {
@Override
public void gankenemy() {
System.out.println("盲僧正在gank");
}
@Override
public void flexible() {
System.out.println("盲僧太灵活了");
}
@Override
public void killbeast() {
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 class Js implements Jungle {
@Override
public void gankenemy() {
System.out.println("剑圣正在gank");
}
@Override
public void flexible() {
System.out.println("js也灵活");
}
@Override
public void killbeast() {
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
public class LeeSinFactory implements junglefactor {
@Override
public Jungle createjungle() {
return new LeeSin();
}
}
```
剑圣工厂
``` stylus
public class JsFactory implements junglefactor {
@Override
public Jungle createjungle() {
return new Js();
}
}
```
测试类:
``` stylus
public static void main(String[] args) {
// Jungle jungle= JungleFactory.createJungle("LeeSin");
// jungle.gankenemy();
junglefactor factory=new LeeSinFactory();
Jungle jubjle=factory.createjungle();
jubjle.flexible();
}

这里通过多态,产生不同的工厂,从而产生不同的打野

工厂方法比较简单工厂模式

现在我们要是把打野对象由盲僧换成剑圣的话,利用简单工厂,那就要

1
2
3
4
5
6
7
Jungle jungle= JungleFactory.createJungle("Js");
```
如果是100或者更多的话,那就要重复上述代码那么多次
但是如果采用工厂方法,只需要改一处
```stylus
junglefactor factory=new JsFactory();

显然对外扩展开放,对内修改关闭更好。而简单工厂则违背了该原则

热评文章