设计模式--工厂模式 （工厂方法、简单工厂、抽象工厂）

设计模式--工厂模式 （工厂方法、简单工厂、抽象工厂）

 

 

    工厂方法模式：定义一个用于创建对象的接口，让子类来决定实例化那一个类。工厂方法使一个类的实例化延迟到其子类。

       在了解工厂方法前，我们要先了解什么是工厂。现实生活中工厂是生产产品的地方，我们身边的电脑、鼠标、电视等等，都是从各个工厂生产出来的。

 

 

 

    如果你对这个图看不明白，那么我们一步步来解释。

 ----------------------------------------------简单工厂-------------------------------------------------------------------------

  

  就拿我们面前的电脑来说，电脑可以上网。如果只是一台电脑，我们建立一个类就行了，当用到的时候就创建一台电脑就行了。

 

public class 台式机电脑 {   
 //上网方法
    public void 上网(){
        System.out.println("浏览网页");
    }
}

 

 

public class 电脑测试 {
    public static void main(String[] args) {
        //创建电脑
台式机电脑 我的电脑 = new 台式机电脑();
        我的电脑.上网();
    }
}

 

 

     如果有一天电脑公司要生产笔记本电脑了、

   平板电脑、超级本了，这时就需要建立一个工厂，让工厂来完成电脑的创建。

   先看看代码：

 

public class 电脑工厂 {
    public 台式机电脑 制造台式机(){
//       返回一台新的台式机电脑
        return new 台式机电脑();
    }
    public 笔记本电脑 制造笔记本电脑(){
//      返回一台新的笔记本电脑
        return new 笔记本电脑();
    }
    public 平板电脑 制造平板电脑(){
//      返回一台新的平板电脑
        return new 平板电脑();
    }
    public 超级本电脑 制造超级本电脑(){
//      返回一台新的笔记本电脑
        return new 超级本电脑();
    }
}

 

 

 

 

public class 台式机电脑 {
    public void 上网(){
        System.out.println("浏览网页");
    }
}

 

 

 

public class 笔记本电脑 {
    public void 上网() {
        System.out.println("浏览网页"); 
    }
}

 

 

 

public class 超级本电脑 {
    public void 上网() {
        System.out.println("浏览网页"); 
    }
}

 

 

 

public class 平板电脑 {
    public void 上网() {
        System.out.println("浏览网页"); 
    }
}

 

 

 

public class 电脑测试 {
    public static void main(String[] args) {
        台式机电脑 台式机 = new 台式机电脑();
        台式机.上网();
        笔记本电脑 笔记本 = new 笔记本电脑();
        笔记本.上网();
        平板电脑  平板   = new 平板电脑();
        平板.上网();
        超级本电脑 超级本 = new 超级本电脑();
        超级本.上网();
    }
}

 

 

 

我们看到，这样做后，创建太麻烦了，我们应该把这些变化封装起来，让用户调用的时候，只需要根据需要让工厂创建就行

先创建一个电脑工厂：

 

public class 电脑工厂 {
    public 电脑 制造电脑(String 电脑类型){
        if(电脑类型.equals("台式机电脑")){
            return new 台式机电脑();
        }else if(电脑类型.equals("笔记本电脑")){
            return new 笔记本电脑();
        }else if(电脑类型.equals("平板电脑")){
            return new 笔记本电脑();
        }else if(电脑类型.equals("超级本电脑")){
            return new 笔记本电脑();
        }else{
            return null;
        }
    }
}

 

电脑工厂根据有一个制造电脑的方法，根据传入的电脑类型创建

然后抽象一个电脑接口，所有类型的电脑都实现这个电脑接口；

 

 

public interface 电脑 {
    public void 上网();
}

 

 

 

public class 笔记本电脑  implements 电脑{
    public void 上网() {
        System.out.println("浏览网页"); 
    }
}


public class 超级本电脑  implements 电脑{
    public void 上网() {
        System.out.println("浏览网页"); 
    }
}


public class 台式机电脑 implements 电脑{
    public void 上网(){
        System.out.println("浏览网页");
    }
}


public class 平板电脑  implements 电脑{
    public void 上网() {
        System.out.println("浏览网页"); 
    }
}

 

 

public class 电脑测试 {
    public static void main(String[] args) {
        电脑工厂 工厂 = new 电脑工厂();
        电脑 台式机 = 工厂.制造电脑("台式机电脑");
        台式机.上网();
        电脑 笔记本 = 工厂.制造电脑("笔记本电脑");
        笔记本.上网();
        电脑  平板   = 工厂.制造电脑("平板电脑");
        平板.上网();
        电脑 超级本  = 工厂.制造电脑("超级本电脑");
        超级本.上网();
    }
}

 

 

再看看类图；

 

        【简单工厂】这种模式叫简单工厂模式，它先创建一个产品接口，然后让所有具体产品实现它，然后创建一个产品工厂，在产品工厂中有一个创建产品的方法，在创建产品的方法里，通过传入的产品名称，来返回具体的产品。

工厂方法适用产品比较固定的情况下，也就是产品不会增加或者减少。

如果产品系列可能发生变化，就不适合简单工厂模式了。

       

 ----------------------------------------------工厂方法-------------------------------------------------------------------------

如果现在电脑工厂开始生产上网本了，那么，是不是让上网本来实现电脑接口，然后在电脑工厂的创建电脑方法中去修改判断语句呢？

         这样就违反面向对象的设计原则—--对修改关闭，对扩展开放。

         【对修改关闭，对扩展开发】指的是程序设计时，应该考虑到变化，并将变化的部分给出接口，当新的变化需求来了后，只需要扩展系统的功能就行了，不需要去修改原有代码。只有遵循这样的设计，才能算是优秀的设计。

         如何应对产品线的变化呢？工厂方法就是解决这一问题的关键！让我们回头看看工厂方法的类图，然后想想我们如何设计电脑公司产品线！

  先看看类图：

 

public interface 电脑 {
    public void 上网();
}

 

 

public interface 电脑工厂 {
    public 电脑 制造电脑();
}

 

 

public class 台式机电脑 implements 电脑{
    public void 上网(){
        System.out.println("浏览网页");
    }
}

 

 

public class 上网本电脑  implements 电脑{
    public void 上网() {
        System.out.println("浏览网页"); 
    }
}

 

 

public class 台式机工厂  implements 电脑工厂{
    public 电脑 制造电脑() {
        return new 台式机电脑();
    }
}

 

 

public class 上网本工厂  implements 电脑工厂{
    public 电脑 制造电脑() {
        return new 上网本电脑();
    }
}

 

 

public class 电脑测试 {
    public static void main(String[] args) {
        电脑工厂 台式机工厂 = new 台式机工厂();
        电脑 台式机 = 台式机工厂.制造电脑();
        台式机.上网();
        
        电脑工厂 上网本工厂 = new 上网本工厂();
        电脑 上网本 =  上网本工厂.制造电脑();
        上网本.上网();
    }
}

 

 

     根据上面的类图和代码，我们再想想，如果再增加一个电脑类型，那么，不需要去修改任何代码，只需要在原有的基础上扩展代码就行了。我们只需要建立一个新电脑类型的工厂，建一个实现了电脑的产品类。就可以了，然后告诉用户，我们有这个产品了，你买的话，我就让工厂给你制造。是不是很简单！

         【工厂方法模式】 定义了制造具体产品的接口，然后让子类的具体产品工厂在自己的方法中创建具体的产品。工厂的方法让产品的创建延迟到子类的具体产品工厂中执行。

工厂方法模式适合产品变化的情况，如果产品会发生变化，使用工厂方法模式可以应对这种变化。

但是，如果有多条产品线（产品族），而且产品线或者产品类型会经常变化，那么就不能用工厂方法模式了。

        

 ----------------------------------------------抽象工厂-------------------------------------------------------------------------

随着时间的推移，电脑公司的发展越来越大，开始考虑多产品线、精细化发展，电脑公司董事会决定制造手机了！而且装备自己建配件厂，生产外壳的工厂和生产主板的工厂负责各自的产品，然后根据不同的需求送到具体产品工厂去生产产品，这样有利于控制成本和管理。可是新的问题来了，产品工厂与外壳、主板这些配件工厂如何关联呢？

         这就要用抽象工厂来处理了。

         【抽象工厂】提供一个创建一系列相关相互依赖对象的接口，而无需指定他们具体类。

         产品工厂都有一个配件装配流程，流程中的配件都是大体相同的，就点子产品来讲，都会从装主板、显示屏、装外壳这个流程来走，因为这个流程中的主板就是电路板，只有专业的电路板工厂才能制造出来，不能与制造外壳的工厂放到一起，因为技术含量和原料都不同，也不能把手机主板和电脑主板分开，因为这样就不能体现出资源的整合，成本、技术、人才的控制了。所以对于产品工厂来讲，声明装配主板、外壳这个流程中需要（依赖）的对象（外壳、主板），不需要指定具体那个产品类型的产品。当用户的产品那一天发生变化的时候，只需要让用户可以自动配置具体用那个类型的产品。

 

 

 

 

 

代码：

 

//主板接口
public interface 主板 {
}

 

 

//手机主板
public class 手机主板  implements 主板{
    public void 检测(){
        System.out.println("检测手机主板成功");
    } 
}

 //电脑主板

public class 电脑主板 implements 主板{
    public void 检测(){
        System.out.println("检测电脑主板成功");
    } 
}

 

 

//外壳接口
public interface 外壳 {
}

 

 

//手机外壳
public class 手机外壳  implements 外壳{
    public void 检测(){
        System.out.println("检测手机外壳成功");
    } 
}

 

 

//电脑外壳
public class 电脑外壳  implements 外壳{
    public void 检测() {
        System.out.println("检测电脑外壳成功"); 
    }
}

 

 

//主板接口
public interface 产品工厂 {
    主板 装主板();
    外壳 装外壳();
}

 

 

//手机工厂
public class 手机工厂 implements 产品工厂 {
    public 主板 装主板() {
        return new 手机主板();
    }
    public 外壳 装外壳() {
        return new 手机外壳();
    }
}

 

 

//电脑工厂
public class 电脑工厂 implements 产品工厂{
    public 主板 装主板() {
        return new 电脑主板();
    }
    public 外壳 装外壳() {
        return new 电脑外壳();
    }
}

 

 

//手机类
public class 手机 {
    private 外壳 手机外壳;
    private 主板 手机主板;
    public void 显示(){
        System.out.println("手机做好了，配件有:"+
this.手机主板 + "," + this.手机外壳);
    }
    // getter  &  setter
    public 外壳 get手机外壳() {
        return 手机外壳;
    }
    public void set手机外壳(外壳 手机外壳) {
        this.手机外壳 = 手机外壳;
    }
    public 主板 get手机主板() {
        return 手机主板;
    }
    public void set手机主板(主板 手机主板) {
        this.手机主板 = 手机主板;
    }
}

 

 

public class 产品测试 {
    public static void main(String[] args) {
        手机 我的手机 = new 手机();
        手机工厂 我的手机工厂 = new 手机工厂();
        主板 手机主板 = 我的手机工厂.装主板();
        外壳 手机外壳 = 我的手机工厂.装外壳();
        我的手机.set手机主板(手机主板);
        我的手机.set手机外壳(手机外壳);
        我的手机.显示();
    }
}

 

    这样的设计最大的好处是易于交换产品系列，比如那天手机主板或者外壳有变化，我们不需要去修改原有代码，只要通过实现主板或者外壳接口，然后在用户调用时传入新添加的主板或者外壳就可以解决问题。在一个应用中只需要在初始化的石化出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。这中模式就是让具体的创建实例过程与客户端分离，客户端是通过他们的抽象接口操纵实例，产品的具体类名也被具体工厂实现分离，不会出现在客户端代码中了。

就像下面的服饰代码，当我们出门时，需要搭配服饰，那么男人和女人会有不同风格的衣服，但是产品系列是一样的，比如上衣，比如裤子，在配衣服的时候不需要去关心具体用什么上衣，只关心某种风格的、或者某种性别的衣服搭配，不需要指定具体衣服。上衣类型增加或者减少都不会影响衣服的搭配。

    如果那天觉得男装或者女装不能满足需求，需要添加另外的类型，比如中性服装，这样就可以不修改代码的情况下解决问题：只需要继承服饰类，然后配各种上衣或者裤子就可以了。

    是不是超级灵活！