4. 设计模式——工厂模式

一只空梦呀
300 阅读5分钟

1. 概述

工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建，是一种创建型模式。本文从一个具体的例子逐步深入分析，来体会三种工厂模式的应用场景和利弊。

2. 简单工厂模式

此模式对对象的创建方式管理最为简单，它仅仅是对对象的创建进行了一层简单的封装，通过向工厂传递类型来指定要创建的对象

2.1 UML图

2.2 角色

此模式有3个角色，分别是：

  1. Product(抽象产品)：工厂所创建的所有对象的父类，封装了产品对象的功用方法，所有的具体产品为其子类对象
  2. ConcreteProduct(具体产品): 简单工厂模式创建的目标，所有被创建的对象都是某个具体类的实例，它要实现抽象产品中声明的抽象方法
  3. Factory(工厂)：负责实现创建所有产品的内部逻辑，工厂类可以被外界直接调用，创建所需对象

2.3 代码实战

我们通过一个汽车实例来讲解该模式，每个汽车都有一个跑的方法，我们顶一个接口，其中有一个run方法：

ICar

public interface ICar {
    void run();
}

现在我们定义两种不同品牌的车来实现这个接口：

BMWCar

public class BMWCar implements ICar {
    public void run() {
        System.out.println("BMW Car running ...");
    }
}

MercedesCar

public class MercedesCar implements ICar {
    public void run() {
        System.out.println("Mercedes Car running ...");
    }
}

定义一个工厂来获取不同的车：

CarFactory

public class CarFactory {
    public ICar getCar(String carType) {
        if (carType.equalsIgnoreCase("BMW")) {
            return new BMWCar();
        } else if(carType.equalsIgnoreCase("Mercedes")) {
            return new MercedesCar();
        }
        return null;
    }
}

演示：

public class Demo {
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        BMWCar bmwCar = (BMWCar) carFactory.getCar("BMW");
        MercedesCar mercedesCar = (MercedesCar) carFactory.getCar("Mercedes");
        ICar bmw = carFactory.getCar("BMW");

        bmwCar.run();
        mercedesCar.run();
        bmw.run();
    }
}

输出：

BMW Car running ...
Mercedes Car running ...
BMW Car running ...

3. 工厂方法模式 Factory Method

和简单工厂中的工厂负责生产所有产品相比，工厂方法模式将生产具体产品的任务分发给具体的产品工厂

3.1 UML图

3.2 角色

此模式有4个角色，分别是：

  1. Product(抽象产品)：工厂所创建的所有对象的父类，封装了产品对象的功用方法，所有的具体产品为其子类对象
  2. ConcreteProduct(具体产品): 简单工厂模式创建的目标，所有被创建的对象都是某个具体类的实例，它要实现抽象产品中声明的抽象方法
  3. Factory(抽象工厂)：在抽象工厂类中声明了工厂方法( Factory Method),用于返回一个产品。抽象工厂是工厂方法模式的核心,所有创建对象的工厂类都必须实现该接口
  4. ConcreteFactory(具体工厂)：它是抽象工厂类的子类,实现了在抽象工厂中声明的工厂方法,并可由客户端调用,返回一个具体产品类的实例

3.3 代码实战

ICar, BMWCar, MercedesCar参考简单工厂代码

ICarFactory

public interface ICarFactory {
    ICar getCar();
}

BMWCarFactory

public class BMWCarFactory implements ICarFactory {
    public ICar getCar() {
        return new BMWCar();
    }
}

MercedesCarFactory

public class MercedesCarFactory implements ICarFactory {
    public ICar getCar() {
        return new MercedesCar();
    }
}

演示：

public class Demo {
    public static void main(String[] args) {
        BMWCarFactory bmwCarFactory = new BMWCarFactory();
        BMWCar bmwCar = (BMWCar) bmwCarFactory.getCar();
        bmwCar.run();
        MercedesCarFactory mercedesCarFactory = new MercedesCarFactory();
        MercedesCar mercedesCar = (MercedesCar) mercedesCarFactory.getCar();
        mercedesCar.run();
    }
}

输出：

BMW Car running ...
Mercedes Car running ...

4. 抽象工厂模式

4.1 概念

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式，是工厂方法模式的升级版，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

4.2 UML图

4.3 角色

  1. AbstractFactory：用于声明生成抽象产品的方法
  2. ConcreteFactory：实现了抽象工厂声明的生成抽象产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中；
  3. AbstractProduct：为每种产品声明接口，在抽象产品中定义了产品的抽象业务方法；
  4. Product：定义具体工厂生产的具体产品对象，实现抽象产品接口中定义的业务方法。

4.4 代码实战

定义两个产品族的抽象类，其中有共用方法，也有自定义方法 AbstractCar

public abstract class AbstractCar {
    public abstract void bell();
    public void run() {
        System.out.println("car is running ...");
    }
}

AbstractBike

public abstract class AbstractBike {
    public abstract void bell();
    public void run() {
        System.out.println("bike is running ...");
    }
}

现在我们定义2个不同品牌都有car和bike产品

BMWCar

public class BMWCar extends AbstractCar {
    public void bell() {
        System.out.println("bmw car didi ing ...");
    }
}

BMWBike

public class BMWBike extends AbstractBike{
    public void bell() {
        System.out.println("bmw bike ling ling ing ...");
    }
}

MercedesCar

public class MercedesCar extends AbstractCar{
    public void bell() {
        System.out.println("Mercedes car didi ing ...");
    }
}

MercedesBike

public class MercedesBike extends AbstractBike {
    public void bell() {
        System.out.println("Mercedes car didi ing ...");
    }
}

接下来我们定义个抽象工厂类，这个抽象工厂类可以生产多个产品

AbstractFactory

public abstract class AbstractFactory {
    public abstract AbstractCar createCar();
    public abstract AbstractBike createBike();
}

分别实现不同品牌的工厂类

BMWFactory

public class BMWFactory extends AbstractFactory {
    public AbstractCar createCar() {
        return new BMWCar();
    }

    public AbstractBike createBike() {
        return new BMWBike();
    }
}

MercedesFactory

public class MercedesFactory extends AbstractFactory{
    public AbstractCar createCar() {
        return new MercedesCar();
    }

    public AbstractBike createBike() {
        return new MercedesBike();
    }
}

演示：

public class Demo {
    public static void main(String[] args) {
        AbstractFactory bmwFactory = new BMWFactory();
        AbstractFactory mercedesFactory = new MercedesFactory();
        BMWCar bmwCar = (BMWCar) bmwFactory.createCar();
        BMWBike bmwBike = (BMWBike) bmwFactory.createBike();
        MercedesCar mercedesCar = (MercedesCar) mercedesFactory.createCar();
        MercedesBike mercedesBike = (MercedesBike) mercedesFactory.createBike();

        bmwCar.run();
        bmwCar.bell();
        bmwBike.run();
        bmwBike.bell();
        mercedesCar.run();
        mercedesCar.bell();
        mercedesBike.run();
        mercedesBike.bell();
    }
}

输出：

car is running ...
bmw car didi ing ...
bike is running ...
bmw bike ling ling ing ...
car is running ...
Mercedes car didi ing ...
bike is running ...
Mercedes car didi ing ...
avatar
文章
阅读
粉丝