Java工厂模式优雅地创建对象以及提高代码复用率和灵活性

什么是工厂模式

在面向对象编程中，将对象的创建过程和处理过程分离开来就是一种算法模式。这种算法模式就是工厂模式。简单来说，工厂模式就是将对象的创建过程进行封装和统一管理，使得代码更加灵活和便于维护和修改。工厂模式主要有两种形式：简单工厂模式和抽象工厂模式。

简单工厂模式

简单工厂模式是工厂模式中最简单的一种形式，它将产品的实现类的创建过程进行封装，通过向工厂传入不同的参数来创建不同的产品实例。

示例：汽车制造工厂

例如，一个汽车制造工厂需要根据不同的订单来生产不同的汽车，其中不同类型的汽车都拥有相同的基本属性和方法，如车轮数、马力、加速度和刹车等。根据订单生产汽车的过程可以使用简单工厂模式进行封装，使得代码更加灵活和易于维护。

首先，我们定义一个接口类 Car，其中包括了汽车的基本属性和方法：

public interface Car {
    void run();
    void stop();
    void description();
}

然后，我们定义不同类型汽车的实现类，并实现上述接口：

public class SportsCar implements Car {
    public void run() {
        System.out.println("Sports car is running...");
    }
    public void stop() {
        System.out.println("Sports car is stopping...");
    }
    public void description() {
        System.out.println("This is a sports car.");
    }
}

public class SUV implements Car {
    public void run() {
        System.out.println("SUV is running...");
    }
    public void stop() {
        System.out.println("SUV is stopping...");
    }
    public void description() {
        System.out.println("This is a SUV.");
    }
}

最后，我们定义一个工厂类 CarFactory，通过传入车辆类型来创建不同的车型实例：

public class CarFactory {
    public static Car createCar(String type) {
        if (type.equals("SportsCar")) {
            return new SportsCar();
        } else if (type.equals("SUV")) {
            return new SUV();
        } else {
            return null;
        }
    }
}

使用简单工厂模式，客户端代码只需要传入不同类型的车辆类型，即可创建不同类型的车辆实例：

public class Client {
   public static void main(String[] args) {
      Car sportsCar = CarFactory.createCar("SportsCar");
      sportsCar.run();
      sportsCar.stop();
      sportsCar.description();

      Car suv = CarFactory.createCar("SUV");
      suv.run();
      suv.stop();
      suv.description();
   }
}

输出结果为：

Sports car is running...
Sports car is stopping...
This is a sports car.
SUV is running...
SUV is stopping...
This is a SUV.

抽象工厂模式

抽象工厂模式是工厂模式中最常用的一种形式，它通过一个抽象工厂和多个具体的工厂来实现对不同产品族的对象的创建。

示例：电器制造工厂

例如，一个电器制造工厂需要同时生产电视机、冰箱和空调等不同的产品。不同类型的电器都有不同的属性和方法。使用抽象工厂模式可以实现对不同类型的电器进行封装，便于代码的维护和扩展。

首先，我们定义一个接口类 TV，Refrigerator和AirConditioner，其中包括了电器的基本属性和方法：

public interface TV {
    void powerOn();
    void powerOff();
}

public interface Refrigerator {
    void turnOn();
    void turnOff();
}

public interface AirConditioner {
    void start();
    void stop();
}

然后，我们定义不同产品族之间相互关联的产品实现类，如 HaierTV、HaierRefrigerator、HaierAirConditioner、TCLTV、TCLRefrigerator、TCLAirConditioner：

public class HaierTV implements TV {
    public void powerOn() {
        System.out.println("Haier TV is powered on.");
    }
    public void powerOff() {
        System.out.println("Haier TV is powered off.");
    }
}

public class HaierRefrigerator implements Refrigerator {
    public void turnOn() {
        System.out.println("Haier refrigerator is turned on.");
    }
    public void turnOff() {
        System.out.println("Haier refrigerator is turned off.");
    }
}

public class HaierAirConditioner implements AirConditioner {
    public void start() {
        System.out.println("Haier air conditioner is started.");
    }
    public void stop() {
        System.out.println("Haier air conditioner is stopped.");
    }
}

public class TCLTV implements TV {
    public void powerOn() {
        System.out.println("TCL TV is powered on.");
    }
    public void powerOff() {
        System.out.println("TCL TV is powered off.");
    }
}

public class TCLRefrigerator implements Refrigerator {
    public void turnOn() {
        System.out.println("TCL refrigerator is turned on.");
    }
    public void turnOff() {
        System.out.println("TCL refrigerator is turned off.");
    }
}

public class TCLAirConditioner implements AirConditioner {
    public void start() {
        System.out.println("TCL air conditioner is started.");
    }
    public void stop() {
        System.out.println("TCL air conditioner is stopped.");
    }
}

接着，我们定义一个抽象工厂 ApplianceFactory，其中定义了不同产品族之间的关联关系，如Haier工厂生产Haier电视机、Haier冰箱和Haier空调等：

public interface ApplianceFactory {
    TV createTV();
    Refrigerator createRefrigerator();
    AirConditioner createAirConditioner();
}

public class HaierApplianceFactory implements ApplianceFactory {
    public TV createTV() {
        return new HaierTV();
    }
    public Refrigerator createRefrigerator() {
        return new HaierRefrigerator();
    }
    public AirConditioner createAirConditioner() {
        return new HaierAirConditioner();
    }
}

public class TCLApplianceFactory implements ApplianceFactory {
    public TV createTV() {
        return new TCLTV();
    }
    public Refrigerator createRefrigerator() {
        return new TCLRefrigerator();
    }
    public AirConditioner createAirConditioner() {
        return new TCLAirConditioner();
    }
}

使用抽象工厂模式，客户端代码可以根据不同的工厂类型创建相应的对象，如创建Haier工厂生产的电器：

public class Client {
    public static void main(String[] args) {
        ApplianceFactory factory = new HaierApplianceFactory();
        TV tv = factory.createTV();
        tv.powerOn();
        tv.powerOff();
        Refrigerator refrigerator = factory.createRefrigerator();
        refrigerator.turnOn();
        refrigerator.turnOff();
        AirConditioner airConditioner = factory.createAirConditioner();
        airConditioner.start();
        airConditioner.stop();
    }
}

输出结果为：

Haier TV is powered on.
Haier TV is powered off.
Haier refrigerator is turned on.
Haier refrigerator is turned off.
Haier air conditioner is started.
Haier air conditioner is stopped.

总之，工厂模式可以极大地提高代码的可维护性、可扩展性和可复用性。它能帮助我们用较少的代码完成较多功能，并且在开发过程中也能更好地进行分层和组织代码。