彻底理解工厂设计模式

工厂设计模式

1. 概述

  • 在java中,万物皆对象,这些对象都需要创建,如果创建的时候直接new该对象,就会对该对象耦合严重,假如我们要更换对象,所有new对象的地方都需要修改一遍,这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象,我们就只和工厂打交道就可以了,彻底和对象解耦,如果要更换对象,直接在工厂里更换该对象即可,达到了与对象解耦的目的;所以说,工厂模式最大的优点就是:解耦

  • 常用的三种工厂模式:

    • 简单工厂模式 :用来生产同一等级结构中的任意产品。(不支持拓展增加产品)
    • 工厂方法模式:用来生产同一等级结构中的固定产品。(支持拓展增加产品)
    • 抽象工厂模式 :用来生产不同产品族的全部产品。(不支持拓展增加产品;支持增加产品族

2. 简单工厂模式

2.1 概念

  • 简单工厂不是一种设计模式,类似于一种编程习惯。简单工厂模式的实现就是在工厂实现类上新建实例,完成各种业务逻辑

2.2 结构

  • 简单工厂结构:(抽象可以是抽象类也可以是接口)
    • 抽象产品 :定义了产品的规范,描述了产品的主要特性和功能。
    • 具体产品 :实现或者继承抽象产品的子类
    • 具体工厂 :提供了创建产品的方法,调用者通过该方法来获取产品。

2.3 优点与缺点

  • 优点:
    • 封装了创建对象的过程,可以通过参数直接获取对象。把对象的创建和业务逻辑层分开,这样以后就避免了修改客户代码,如果要实现新产品直接修改工厂类,而不需要在原代码中修改,这样就降低了客户代码修改的可能性,更加容易扩展。
  • 缺点:
    • 增加新产品时还是需要修改工厂类的代码,违背了"开闭原则"

2.4 扩展

  • 静态工厂:在开发中也有一部分人将工厂类中的创建对象的功能定义为静态的,这个就是静态工厂模式,它也不是23种设计模式中的。

3. 工厂方法模式

3.1 概念

  • 提供一个用于创建对象的接口(工厂接口),让其实现类(工厂实现类)决定实例化哪一个类(产品类),并且由该实现类创建对应类的实例

3.2 结构

  • 工厂方法模式的主要角色:(抽象可以是抽象类也可以是接口)
    • 抽象工厂(Abstract Factory):提供了创建产品的接口,调用者通过它访问具体工厂的工厂方法来创建产品。
    • 具体工厂(ConcreteFactory):主要是实现抽象工厂中的抽象方法,完成具体产品的创建。
    • 抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能。
    • 具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间一一对应。

3.3 实现案例

  • 抽象产品(接口)

    public interface Car {
        void makeCar();
    }
    
  • 具体产品(实现类)

    public class AodiCar implements Car{
        @Override
        public void makeCar() {
            System.out.println("生产了奥迪车");
        }
    }
    
    public class BaomaCar implements Car{
        @Override
        public void makeCar() {
            System.out.println("生产了宝马车");
        }
    }
    
  • 抽象工厂(接口)

    public interface CarFactory {
        Car makeCars(String type);
    }
    
  • 具体工厂(实现类)

    public class CarFactoryImpl implements CarFactory{
        @Override
        public Car makeCars(String type) {
            Car car = null;
            if (type.equals("Aodi")){
                car = new AodiCar();
            }else if (type.equals("Baoma")){
                car = new BaomaCar();
            }else {
                new RuntimeException("没有该类车!");
            }
            return car;
        }
    }
    
  • 主程序(消费者)

    public class Customer {
        public static void main(String[] args) {
            //消费者通过汽车工厂买车
            CarFactory factory = new CarFactoryImpl();
            //消费者只提出买车的需求,不需要知道车如何生产,实现解耦合
            Car car = factory.makeCars("Aodi");
            car.makeCar();//生产了奥迪车
        }
    }
    

3.4 优点与缺点

  • 优点:

    • 用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程;
    • 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类,无须对原工厂进行任何修改,满足开闭原则;

    缺点:

    • 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类,这增加了系统的复杂度。

4. 抽象工厂模式

4.1 概念

  • 抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

  • 抽象工厂模式是工厂方法模式的升级版本,工厂方法模式只生产一个等级的产品,而抽象工厂模式可生产多个等级的产品

4.2 结构

  • 抽象工厂模式的主要角色如下:
    • 抽象工厂(Abstract Factory):提供了创建产品的接口,它包含多个创建产品的方法,可以创建多个不同等级的产品。
    • 具体工厂(Concrete Factory):主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建。
    • 抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品。
    • 具体产品(Concrete Product):实现了抽象产品角色所定义的接口,由具体工厂来创建,它 同具体工厂之间是多对一的关系。

4.3 实现案例

  • 产品

    • 汽车接口(抽象)

      public interface Car {
          void makeCar();
      }
      
    • 宝马汽车(具体)

      public class BaomaCar implements Car {
          @Override
          public void makeCar() {
              System.out.println("这是宝马牌的汽车");
          }
      }
      
    • 奥迪汽车(具体)

      public class AodiCar implements Car {
          @Override
          public void makeCar() {
              System.out.println("这是奥迪牌的汽车");
          }
      }
      
    • 摩托接口(抽象)

      public interface Motor {
          void makeMotor();
      }
      
    • 宝马摩托(具体)

      public class BaomaMotor implements Motor {
          @Override
          public void makeMotor() {
              System.out.println("这个宝马牌的摩托");
          }
      }
      
    • 奥迪摩托(具体)

      public class AodiMotor implements Motor {
          @Override
          public void makeMotor() {
              System.out.println("生产了奥迪摩托车");
          }
      }
      
  • 工厂

    • 超级工厂(抽象)

      public interface Factory {
          Car makeCars();
      
          Motor makeMotors();
      
      }
      
    • 宝马工厂(具体)

      public class BaomaFactory implements Factory {
      
          @Override
          public Car makeCars() {
              return new BaomaCar();
          }
      
          @Override
          public Motor makeMotors() {
              return new BaomaMotor();
          }
      }
      
    • 奥迪工厂(具体)

      public class AodiFactory implements Factory{
      
          @Override
          public Car makeCars() {
              return new AodiCar();
          }
      
          @Override
          public Motor makeMotors() {
              return new AodiMotor();
          }
      }
      
  • 消费者

    • 顾客

      public class Customer {
          public static void main(String[] args) {
              //创建宝马工厂
              Factory baomaFactory = new BaomaFactory();
              baomaFactory.makeCars().makeCar();
              baomaFactory.makeMotors().makeMotor();
      
              //创建奥迪工厂
              Factory aodiFactory = new AodiFactory();
              aodiFactory.makeCars().makeCar();
              aodiFactory.makeMotors().makeMotor();
          }
      }
      
  • 如果还需要添加产品族的话,只需要添加对应的产品类和工厂即可,如奔驰工厂和奔驰牌汽车、奔驰牌摩托,不需要修改其他类。

4.4 优点与缺点

  • 优点:

    • 抽象工厂模式隔离了具体类的生产,使得客户并不需要知道什么被创建。
    • 当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。
    • 增加新的具体工厂和产品族很方便,无须修改已有系统,符合"开闭原则"
  • 缺点:

    • 如果新增加的产品等级结构很复杂,需要修改抽象工厂和所有的具体工厂类,对"开闭原则"的支持呈现倾斜性

你可能感兴趣的:(设计模式,设计模式,java,面试)