工厂模式
抽象工厂模式的缺点
不太容易扩展新的产品
如果需要给整个产品族添加一个新的产品,那么就需要修改抽象工厂,这样就会导致修改所有的工厂实现类。
===================
工厂 其实就是抽象出事物的共性或者相似之处,定义共同的接口,实现交给具体的子类处理的过程。
理解 产品族和等级的概念:
1.抽象工厂:定义工厂接口,包含生产原味和草莓味的酸奶的方法;
2.定义工厂的实现类:蒙牛工厂和伊利工厂,并实现接口的方法;
3.抽象工厂:定义口味接口,包含原味接口和草莓味接口,每个接口包含该口味酸奶的价格的方法;
4.定义口味接口的实现类:每个工厂都能生产原味和草莓味酸奶,因此每个工厂分别包含原味接口的实现类和草莓味接口的实现类,实现类中给出该口味酸奶的价格。
5.顾客类:顾客购买酸奶,只要说明要买酸奶的厂家,既得到该厂家下不同口味酸奶的价格信息;
代码如下:
定义 草莓味接口:
1
2
3
4
5
6
|
package iv.factory.feidanyi.yuanshi.interfaces; public interface CaoMeiWei { void getPrice(); } |
定义草莓味的实现类:蒙牛草莓味
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package iv.factory.feidanyi.yuanshi.classes; import iv.factory.feidanyi.yuanshi.interfaces.CaoMeiWei; public class MengNiuCmw implements CaoMeiWei { private int price = 0 ; public MengNiuCmw( int price){ this .price = price; } public void getPrice() { // TODO Auto-generated method stub System.out.println(蒙牛草莓味价格:+ this .price); } } |
定义草莓味的实现类:伊利草莓味
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package iv.factory.feidanyi.yuanshi.classes; import iv.factory.feidanyi.yuanshi.interfaces.CaoMeiWei; public class YiLiCmw implements CaoMeiWei { private int price = 0 ; public YiLiCmw( int price){ this .price = price; } public void getPrice() { // TODO Auto-generated method stub System.out.println(伊利草莓味价格:+ this .price); } } |
定义原味接口:
1
2
3
4
5
6
|
package iv.factory.feidanyi.yuanshi.interfaces; public interface YuanWei { void getPrice(); } |
定义原味接口的实现类:蒙牛原味:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package iv.factory.feidanyi.yuanshi.classes; import iv.factory.feidanyi.yuanshi.interfaces.YuanWei; public class MengNiuYw implements YuanWei{ private short price = 0 ; private String brand =; public MengNiuYw( int price){ this .price = ( short ) price; } public void getPrice() { // TODO Auto-generated method stub System.out.println(原味价格:+ this .price); } public void getBrand() { // TODO Auto-generated method stub System.out.println(品牌:+ this .brand); } } |
定义原味接口的实现类:伊利原味:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package iv.factory.feidanyi.yuanshi.classes; import iv.factory.feidanyi.yuanshi.interfaces.YuanWei; public class YiLiYw implements YuanWei{ private int price = 0 ; private String brand = ; public YiLiYw( int price){ this .price = price; } public void getPrice() { // TODO Auto-generated method stub System.out.println(原味价格:+ this .price); } } |
定义厂家的接口:
1
2
3
4
5
6
7
|
package iv.factory.feidanyi.yuanshi.interfaces; public interface AbstractFactory { YuanWei createYuanWei(); CaoMeiWei createCaoMeiWei(); } |
定义厂家的接口的实现类:蒙牛厂家:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
package iv.factory.feidanyi.yuanshi.classes; import iv.factory.feidanyi.yuanshi.interfaces.AbstractBrandFactory; import iv.factory.feidanyi.yuanshi.interfaces.AbstractFactory; import iv.factory.feidanyi.yuanshi.interfaces.CaoMeiWei; import iv.factory.feidanyi.yuanshi.interfaces.YuanWei; public class MengNiuFactory implements AbstractFactory,AbstractBrandFactory { public CaoMeiWei createCaoMeiWei() { // TODO Auto-generated method stub return new MengNiuCmw( 14 ); } public YuanWei createYuanWei() { // TODO Auto-generated method stub return new MengNiuYw( 15 ); } public String getBrand() { // TODO Auto-generated method stub return new MengNiu().getBrand(); } } |
定义厂家的接口的实现类:伊利厂家:
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 iv.factory.feidanyi.yuanshi.classes; import iv.factory.feidanyi.yuanshi.interfaces.AbstractBrandFactory; import iv.factory.feidanyi.yuanshi.interfaces.AbstractFactory; import iv.factory.feidanyi.yuanshi.interfaces.CaoMeiWei; import iv.factory.feidanyi.yuanshi.interfaces.YuanWei; public class YiLiFactory implements AbstractFactory,AbstractBrandFactory { public CaoMeiWei createCaoMeiWei() { // TODO Auto-generated method stub return new YiLiCmw( 11 ); } public YuanWei createYuanWei() { // TODO Auto-generated method stub return new YiLiYw( 12 ); } public String getBrand() { // TODO Auto-generated method stub return new YiLi().getBrand(); } } |
定义顾客类:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package iv.factory.feidanyi.yuanshi.classes; import iv.factory.feidanyi.yuanshi.interfaces.AbstractFactory; import iv.factory.feidanyi.yuanshi.interfaces.CaoMeiWei; import iv.factory.feidanyi.yuanshi.interfaces.YuanWei; public class Customer { private YuanWei yw = null ; private CaoMeiWei cmw = null ; public void buyMilk(AbstractFactory af){ yw = af.createYuanWei(); cmw = af.createCaoMeiWei(); yw.getPrice(); cmw.getPrice(); } } |
定义main方法类:
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
|
package iv.factory.feidanyi.yuanshi.classes; import iv.factory.feidanyi.yuanshi.interfaces.AbstractBrandFactory; import iv.factory.feidanyi.yuanshi.interfaces.AbstractFactory; public class client { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Customer cus = new Customer(); AbstractBrandFactory af0 = new MengNiuFactory(); AbstractFactory af = new MengNiuFactory(); System.out.println(af0.getBrand()); cus.buyMilk(af); AbstractBrandFactory af11 = new YiLiFactory(); AbstractFactory af1 = new YiLiFactory(); System.out.println(af11.getBrand()); cus.buyMilk(af1); } } |
完毕。
动态装载类:
Class.forName(String类型的类的包路径).newInstance();
==================
封装“改变”是设计模式的原则.
什么时候使用工厂模式:如果在项目中有很多地方都需要生产某个对象的实例的话,则可以考虑使用工厂模式,让工厂来生产实例,当需要修改生产实例的方式时,只需要修改工程即可,不用到处修改。
在什么情况下应当使用抽象工厂模式
1.一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有形态的工厂模式都是重要的。
2.这个系统的产品有多于一个的产品族,而系统只消费其中某一族的产品。
3.同属于同一个产品族的产品是在一起使用的,这一约束必须在系统的设计中体现出来。(比如:Intel主板必须使用Intel CPU、Intel芯片组)
4.系统提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于实现。
抽象工厂模式的优点
分离接口和实现
客户端使用抽象工厂来创建需要的对象,而客户端根本就不知道具体的实现是谁,客户端只是面向产品的接口编程而已。也就是说,客户端从具体的产品实现中解耦。
使切换产品族变得容易
因为一个具体的工厂实现代表的是一个产品族,比如上面例子的从Intel系列到AMD系列只需要切换一下具体工厂。
抽象工厂模式的缺点
不太容易扩展新的产品
如果需要给整个产品族添加一个新的产品,那么就需要修改抽象工厂,这样就会导致修改所有的工厂实现类。