Java23中设计模式之-工厂模式

本文参考其他文章，原文内容更丰富。想详细了解的小伙伴可以去原创作者：

参考文章: https://www.runoob.com/design-pattern/factory-pattern.html

参考文章: https://blog.csdn.net/zhangerqing/article/details/8194653

什么是工厂模式

工厂模式（Factory Pattern）

是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

**缺点：**每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

**注意事项：**作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

工厂模式分为三类:

简单工厂模式（Simple Factory）

工厂方法模式（Factory Method）

抽象工厂模式（Abstract Factory）

目的

定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

一、简单工厂模式

以下例子为汽车工厂

• 步骤一: 创建一个 汽车接口 car

public interface Car {
   void getCar();
}

• 步骤二: 创建 接口 实现类 负责造车

// 奥迪汽车
public class Aodi implements Car {

    @Override
    public void getCar() {
        System.out.println("奥迪");
    }
}

// 特斯拉
public class Tesla implements Car {
    @Override
    public void getCar() {
        System.out.println("特斯拉");
    }
}

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

• 步骤三: 创建一个工厂，生成基于给定信息的实体类的对象。

//汽车工厂，需要什么汽车 返回什么汽车
public class CarFactory {

    public Car getCar(String name){

        if(name=="aodi"){
            return new Aodi();
        }else if(name == "wulin"){
            return  new Wulin();
        }else if(name == "tesla"){
            return  new Tesla();
        }else{
            System.out.println("没有你要的"+name);
        }
        return null;
    }

}

• 步骤四：测试

//测试代码
class Test{
    public static void main(String[] args) {

        // 获得工厂
        CarFactory carFactory  =  new CarFactory();

        // 由工厂根据需要的对象来创建对象
        Car car = carFactory.getCar("aodi");
        car.getCar();

        Car car2 = carFactory.getCar("tesla");
        car2.getCar();

        Car car3 = carFactory.getCar("wulin");
        car3.getCar();

   
    }
}

输出结果：

奥迪
特斯拉
五菱宏光

Process finished with exit code 0

二、工厂方法模式

1. 普通工厂方法

• 步骤一、步骤二 代码同简单工厂代码相同, 下面是 步骤三的代码

public class CarFactoryMethod {

    public  Aodi getAodi(){
        return  new Aodi();
    }

    public  Wulin getWulin(){
        return  new Wulin();
    }

    public  Tesla getTesla(){
        return  new Tesla();
    }

}

• 步骤四: 测试

class CarMethodTest{
    public static void main(String[] args) {
        // 创建工厂实例
        CarFactoryMethod carFactoryMethod = new CarFactoryMethod();
        // 根据工厂里的方法 获得汽车
        Car aoDiCar  =  carFactoryMethod.getAodi();
        Car wuLinCar  =  carFactoryMethod.getWulin();
        Car teslaCar  =  carFactoryMethod.getTesla();


        aoDiCar.getCar();
        wuLinCar.getCar();
        teslaCar.getCar();
    }
}

2. 静态工厂方法

​ 将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

• 只需修改 步骤三 代码

public class CarFactoryMethod {
    
	// 添加static 关键字 将方法置为静态
    public static  Aodi getAodi(){
        return  new Aodi();
    }

    public static Wulin getWulin(){
        return  new Wulin();
    }

    public static Tesla getTesla(){
        return  new Tesla();
    }

}

• 步骤四 :测试

class CarMethodTest{
    public static void main(String[] args) {
        // 无需创建工厂实例
      	// CarFactoryMethod carFactoryMethod = new CarFactoryMethod();
        // 根据工厂里的方法 获得汽车
        Car aoDiCar  =  CarFactoryMethod.getAodi();
        Car wuLinCar  =  CarFactoryMethod.getWulin();
        Car teslaCar  =  CarFactoryMethod.getTesla();


        aoDiCar.getCar();
        wuLinCar.getCar();
        teslaCar.getCar();
    }
}

三、抽象工厂模式

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

• 步骤一、步骤二 代码同简单工厂代码相同

• 步骤三 ： 创建 工厂类接口

  // 只提供获得车工厂的接口，只获得车工厂，不提供车对象
  public interface AbstractFactory {
      public Car getCarFactory();
  }
  

• 步骤四: 创建各个车工厂 实现车工厂接口

  // 子类负责实现创建汽车对象
  // 车工厂一
  public class AodiFactory implements AbstractFactory{
      @Override
      public Car getCarFactory() {
          return new Aodi();
      }
  }
  
  // 车工厂二
  public class TeslaFactory implements AbstractFactory {
      @Override
      public Car getCarFactory() {
          return new Tesla();
      }
  }
  
  // 车工厂三
  public class WulinFactory implements AbstractFactory{
      @Override
      public Car getCarFactory() {
          return new Wulin();
      }
  }
  
  
  
  

• 步骤五 :测试

class AbstractFactoryTest{
    public static void main(String[] args) {

        // 获得车工厂
        AbstractFactory aodiAbstractFactory = new AodiFactory();
        // 通过车工厂 获得对象
        Car aodiCar = aodiAbstractFactory.getCarFactory();
        aodiCar.getCar();


        AbstractFactory wulinAbstractFactory = new WulinFactory();
        Car wulinCar = wulinAbstractFactory.getCarFactory();
        wulinCar.getCar();

    }
}

这个模式的好处就是，如果你现在想增加一个功能：增加其他的车，则只需做其他车的实现类，实现Car接口，

同时做一个工厂类，实现AbstractFactory接口，就可以了，无需去改动现成的代码，拓展性较好！