设计模式(三):抽象工厂模式

一.工厂模式与抽象工厂模式:

  对于工厂模式只能生产单一等级的产品或功能。无法生产出其他类型的产品或者功能。当创建单一等级产品时,工厂模式适用。

     对于抽象工厂模式改进了工厂模式的不足,使之可以创建多种不同等级的产品或者功能。。但对于新增产品时,所有工厂都需要进行改动。对多产品族时,适用于抽象工厂模式。

  

 二.类图

三.代码及类名

 interface:

electronics: 电子产品抽象接口类

 1 package com.cllover.factory.product;
 2 
 3 /*
 4 * 电子产品接口
 5 * */
 6 public interface electronics {
 7     //名称
 8     public void name();
 9     //运行时状况
10     public void run();
11     //价位
12     public void price();
13     //整机颜色
14     public void color();
15 
16 }
electronics

electronicsFactory: 电子产品工厂抽象接口类

 1 package com.cllover.factory.factory;
 2 
 3 import com.cllover.factory.product.Tv;
 4 import com.cllover.factory.product.air;
 5 import com.cllover.factory.product.phone;
 6 
 7 /*
 8 * 电子产品工厂接口
 9 * */
10 public interface electronicsFactory {
11     //品牌名
12     public void brandName();
13     //创建空调air
14     public air createAir();
15     //创建Tv
16     public Tv createTv();
17     //创建手机phone
18     public phone createPhone();
19 }
electronicsFactory

 具体产品class:

Tv(): 电视产品

 1 package com.cllover.factory.product;
 2 
 3 /*
 4 * 电视机
 5 * */
 6 public class Tv implements electronics {
 7 
 8 
 9     @Override
10     public void name() {
11         System.out.println("我是电视");
12     }
13 
14     @Override
15     public void run() {
16         System.out.println("很清晰");
17     }
18     @Override
19     public void price() {
20         System.out.println("价格昂贵");
21 
22     }
23     @Override
24     public void color() {
25         System.out.println("颜色为灰色");
26 
27     }
28 }
Tv

air(): 空调产品

 1 package com.cllover.factory.product;
 2 
 3 /*
 4 * 空调接口
 5 * */
 6 public  class air implements electronics {
 7 
 8 
 9     @Override
10     public void name() {
11         System.out.println("我是空调");
12     }
13 
14     @Override
15     public void run() {
16         System.out.println("空调很凉爽");
17     }
18     @Override
19     public void price() {
20         System.out.println("价格不高");
21 
22     }
23     @Override
24     public void color() {
25         System.out.println("颜色为白色");
26 
27     }
28 
29 
30 }
air

phone(): 手机产品

 1 package com.cllover.factory.product;
 2 
 3 public class phone implements electronics {
 4 
 5     @Override
 6     public void name() {
 7         System.out.println("我是手机");
 8     }
 9 
10     @Override
11     public void run() {
12         System.out.println("运行流畅");
13     }
14 
15     @Override
16     public void price() {
17         System.out.println("价格不贵");
18     }
19 
20     @Override
21     public void color() {
22 
23         System.out.println("我是黑色");
24     }
25 }
phone

品牌工厂实现class:

ABrandFactory: A品牌

 1 package com.cllover.factory.factory;
 2 
 3 import com.cllover.factory.product.Tv;
 4 import com.cllover.factory.product.air;
 5 import com.cllover.factory.product.phone;
 6 
 7 public class ABrandFactory implements electronicsFactory {
 8     @Override
 9     public void brandName() {
10         System.out.println("A品牌");
11     }
12 
13     @Override
14     public air createAir() {
15         return  new air();
16     }
17 
18     @Override
19     public Tv createTv() {
20         return new Tv();
21     }
22 
23     @Override
24     public phone createPhone() {
25         return new phone();
26     }
27 
28 
29 }
ABrandFactory

BBrandFactory: B品牌

 1 package com.cllover.factory.factory;
 2 
 3 import com.cllover.factory.product.Tv;
 4 import com.cllover.factory.product.air;
 5 import com.cllover.factory.product.phone;
 6 
 7 public class BBrandFactory implements electronicsFactory {
 8 
 9 
10     @Override
11     public void brandName() {
12         System.out.println("B品牌");
13     }
14 
15     @Override
16     public air createAir() {
17         return null;
18     }
19 
20     @Override
21     public Tv createTv() {
22         return null;
23     }
24 
25     @Override
26     public phone createPhone() {
27         return null;
28     }
29 }
BBrandFactory

client客户端调用:

 1 package com.cllover.factory;
 2 
 3 import com.cllover.factory.factory.ABrandFactory;
 4 import com.cllover.factory.factory.BBrandFactory;
 5 import com.cllover.factory.factory.electronicsFactory;
 6 import com.cllover.factory.product.electronics;
 7 
 8 /*
 9 *
10 * 调用客户端
11 * */
12 public class client {
13     public static void main(String[] args) {
14         //向上转型,面向接口
15         //A品牌
16         electronicsFactory aBrandFactory = new ABrandFactory();
17         aBrandFactory.brandName();
18         electronics air = aBrandFactory.createAir();
19         air.name();
20         air.color();
21         air.price();
22         air.run();
23         System.out.println("============================");
24         //B品牌
25         electronicsFactory aBrandFactory1 = new BBrandFactory();
26         aBrandFactory1.brandName();
27         electronics phone = aBrandFactory.createPhone();
28         phone.name();
29         phone.color();
30         phone.price();
31         phone.run();
32         System.out.println("============================");
33 
34     }
35 }
client

四.总结

  • 工厂模式

  1. 对于同产品级,工厂模式具有良好的扩展性,具有良好的封装性,代码结构清晰,无需知道内部的具体情况,只需要调用相关接口

  2. 对于扩展一个新产品时只需要添加相应的“具体产品类”和“具体的工厂类”便可。

  3. 一个产品的具体生产由工厂决定。

  缺点:

  1. 但在对内部的属性进行扩展时需要修改接口和相应的类,修改过于复杂。

  2. 不适用与不同产品族中。

  • 抽象工厂模式

  1. 只需要知道工厂类便可创建一个需要的对象,不用关心具体对象如何创建,只关心接口或抽象。

  2. 对于多种产品族,抽象工厂模式可以进行定义。

  缺点:

  1. 对于产品族的扩展具有一定的困难,抽象工厂将会必须去create一个新的产品,其子类也必须同时进行修改。违反了开闭原则。

原文地址:https://www.cnblogs.com/CllOVER/p/13345662.html