23种设计模式-工厂模式

工厂模式

作用：

• 实现了创建者和调用者的分离
• 详细分类
  • 简单工厂模式
  • 工厂方法模式
  • 抽象工厂模式

核心方式：

• 实例化对象不适用new，使用工厂方法代替
• 将选择实现类，创建对象统一管理和控制，从而将调用者跟我们的实现类解耦

简单工厂模式

用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码）

public interface Car {
    void name();
}

public class Lamborghin implements Car {
    @Override
    public void name() {
        System.out.println("兰博基尼");
    }
}

public class Wuling implements Car{
    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

public class SimpleFactory {
    public static void main(String[] args) {
        // 使用工厂类创建
        Car car = CarFactory.getCar("五菱宏光");
        car.name();
        Car car1 = CarFactory.getCar("兰博基尼");
        car1.name();
    }
}

// 工厂类
public class CarFactory {
    public static Car getCar(String Car) {
        if (Car.equals("五菱宏光")) {
            return new Wuling();
        } else if (Car.equals("兰博基尼")) {
            return new Lamborghin();
        } else {
            return null;
        }
    }
}

到这里我们可以发现，工厂类中的方法都是静态方法，所以简单工厂模式也被称作为静态工厂模式，但会存在一些问题：如果你新增加一个车类，在不修改工厂类的情况下，是做不到的，这并不符合OOP七大原则中的开闭原则（对扩展开放，对修改关闭），不过在大部分情况下，我们都会使用简单工厂模式，因为遵守开闭原则需要付出许多代价。

工厂方法模式

用来生产同一等级结构中的任意产品（支持增加任意产品）

public interface Car {
    void name();
}

// 工厂类接口
public interface CarFactory {
    Car getCar();
}

public class Lamborghin implements Car {
    @Override
    public void name() {
        System.out.println("兰博基尼");
    }
}

public class LamborghiniFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new Lamborghini();
    }
}

public class FactoryMethod {
    public static void main(String[] args) {
        Car car = new LamborghiniFactory().getCar();
        car.name();
    }
}

在这种模式下，我们每新增一个车类，都可以继承工厂类接口，新增对应车类的工厂类即可，并不需要修改其他工厂类的代码，完全符合开闭原则，但这样也会带来一个问题：类太多了！如果新增的大量的车类，那也会对应增加大量的工厂类，会让类的总量极其庞大！这个时候有小朋友就会问了：既然从修改工厂类变成了增加类，还更费功夫了，为什么不直接修改工厂类就行了呢？

然而，在现实里，一个项目带来的数据与参数是非常庞大的，也就是说，新增的Car类会有大量的参数，甚至有一堆方法，这就会让工厂类的修改变得及其繁琐且困难！

但是！从结构复杂度、代码复杂度、编程复杂度等方面上分析，简单工厂模式仍然是完胜的，虽然说，根据设计原则出发，应当选择工厂方法模式，但是在实际开发上，简单工厂模式的使用会更加频繁且广泛。

抽象工厂模式

如果在实际开发上，真的遇到了大量的数据和参数，例如车类接口里，有大量的零件参数，并且车的种类繁多，这个时候普通的工厂模式就难以解决了，于是就有了抽象工厂模式：围绕着一个超级工厂创建其他工厂的模式！

该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

定义：抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类

适用场景：

• 客户端（应用层）不依赖于产品实例如何被创建、实现等细节
• 强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码
• 提供一个产品类的库，所有的产品以相同的接口出现，从而使得客户端不依赖于具体的实现

// 手机工厂类
public interface IPhoneFactory {
    void open();
    void shutdown();
}

// 路由器工厂类
public interface IRouterFactory {
    void open();
    void shutdown();
}

// 小米手机
public class XiaomiPhone implements IPhoneFactory {
    @Override
    public void open() {
        System.out.println("小米手机已开机");
    }

    @Override
    public void shutdown() {
        System.out.println("小米手机已关机");
    }
}

// 华为路由器
public class HuaweiRouter implements IRouterFactory {
    @Override
    public void open() {
        System.out.println("华为路由器已开机");
    }

    @Override
    public void shutdown() {
        System.out.println("华为路由器已关机");
    }
}

// 抽象工厂类
public interface IProductFactory {
    IPhoneFactory phone();
    IRouterFactory router();
}

// 小米工厂类
public class XiaomiFactory implements IProductFactory {
    @Override
    public IPhoneFactory phone() {
        return new XiaomiPhone();
    }

    @Override
    public IRouterFactory router() {
        return new HuaweiRouter();
    }
}

// 华为工厂类
public class HuaweiFactory implements IProductFactory {
    @Override
    public IPhoneFactory phone() {
        return new HuaweiPhone();
    }

    @Override
    public IRouterFactory router() {
        return new HuaweiRouter();
    }
}

测试类：

public class Client {
    public static void main(String[] args) {
        System.out.println("========Xiaomi========");
        XiaomiFactory xiaomiFactory = new XiaomiFactory();
        IPhoneFactory iPhoneFactory = xiaomiFactory.phone();
        iPhoneFactory.open();
        iPhoneFactory.shutdown();
        System.out.println("========Huawei========");
        HuaweiFactory huaweiFactory = new HuaweiFactory();
        IRouterFactory iRouterFactory = huaweiFactory.router();
        iRouterFactory.open();
        iRouterFactory.shutdown();
    }
}

类关系图展示：

抽象工厂模式的优点：

• 具体产品在应用层的代码隔离，无需关心创建的细节
• 将一个系列的产品统一到一起创建

抽象工厂模式的缺点：

• 规定了所有可能被创建的产品集合，产品簇中扩展新的产品困难
• 增加了系统的抽象性和理解难度