在学习设计模式过程中，因为比较灰色难懂，期间遇到很多问题，因此结合网上的一些说明，做了如下总结，希望对大家有帮助。

生活实例

假如你正计划购买一辆汽车。在这个场景中：

• 客户（Client）：你自己，准备买车。
• 汽车工厂（Factory）：汽车制造厂商，负责生产汽车。
• 汽车产品（Product）：不同品牌和型号的汽车。
• 订单请求：你向汽车厂商提出购车需求。
• 获取汽车对象：汽车厂商根据你的需求生产汽车并提供给你。

购车过程就像使用了工厂模式：

1. 你作为客户，选择汽车的品牌、型号、颜色等。
2. 你向汽车厂商（工厂）发送订单请求。
3. 汽车厂商根据你的需求，生产对应的汽车（产品）。
4. 你获得所需的汽车对象。

这个过程体现了工厂模式的核心思想：将对象的创建和使用分离，提高了系统的灵活性和可维护性。

工厂模式的分类

工厂模式旨在提供一种统一的方式来创建对象，而不需要在客户端直接使用new关键字来实例化具体的对象。有三种类型：简单工厂模式 、工厂模式 、抽象工厂模式。

1. 简单工厂模式：通过一个共同的工厂类来根据不同的参数来创建不同类的实例。

汽车生产通过简单工厂模式实现JAVA代码如下：

// 定义汽车接口  
interface Car {  
    void drive();  
}  
  
// 具体汽车类  
class SedanCar implements Car {  
    @Override  
    public void drive() {  
        System.out.println("Driving a sedan car");  
    }  
}  
  
class SUVCar implements Car {  
    @Override  
    public void drive() {  
        System.out.println("Driving an SUV car");  
    }  
}  
  
// 汽车工厂类  
class CarFactory {  
    public Car createCar(String type) {  
        if (type.equalsIgnoreCase("Sedan")) {  
            return new SedanCar();  
        } else if (type.equalsIgnoreCase("SUV")) {  
            return new SUVCar();  
        } else {  
            return "The car model does not exist.";  
        }  
    }  
}  
  
// 客户端  
public class Main {  
    public static void main(String[] args) {  
        CarFactory carFactory = new CarFactory();  
        Car sedan = carFactory.createCar("Sedan");  
        sedan.drive();  
        Car suv = carFactory.createCar("SUV");  
        suv.drive();  
    }  
}

上述代码展示了简单工厂模式的实现。在这个例子中：

• 定义了一个汽车接口 Car，以及两个具体汽车类 SedanCar 和 SUVCar，它们都实现了 Car 接口并且实现了 drive() 方法。
• 创建了一个汽车工厂类 CarFactory（共同的工厂类），其中包含一个 createCar(String type) 方法，根据传入的参数 type 来实例化不同类型的汽车对象。
• 在客户端 Main 类中，通过实例化 CarFactory，并分别使用"sedan"和"SUV"作为参数调用 createCar() 方法来创建 SedanCar 和 SUVCar 对象，然后调用 drive() 方法来驾驶这两种汽车。

通过汽车工厂类来封装实例化对象的逻辑，客户端只需要关注如何获取实例，而不需要了解具体的实例化过程。这样可以降低耦合度，提高代码的可维护性和扩展性。

2. 工厂模式：定义一个创建对象的接口，但是让子类决定实例化哪个类。

汽车生产通过工厂模式实现JAVA代码如下：

// 定义汽车接口  
interface Car {  
    void drive();  
}  
  
// 具体汽车类  
class SedanCar implements Car {  
    @Override  
    public void drive() {  
        System.out.println("Driving a sedan car");  
    }  
}  
  
class SUVCar implements Car {  
    @Override  
    public void drive() {  
        System.out.println("Driving an SUV car");  
    }  
}  

//定义工厂接口
public interface CarFactoryInterFace {
    Car concreateCar();
}

//具体的工厂类
public class CarFactorySedan implements CarFactoryInterFace{

    @Override
    public Car concreateCar() {
        return new SedanCar();
    }
}

public class CarFactorySUV implements CarFactoryInterFace{
    @Override
    public Car concreateCar() {
        return new SUVCar();
    }
}

public class Main {

    public static void main(String[] args) {
    
        //工厂模式
        CarFactoryInterFace carFactoryInterFace = new CarFactorySedan();
        Car car = carFactoryInterFace.concreateCar();
        car.drive();

       //更换工厂，生产不同的产品
        carFactoryInterFace = new CarFactorySUV();
        car = carFactoryInterFace.concreateCar();
        car.drive();
    }
}

上述代码展示了工厂模式的实现，其中包括了工厂接口和具体的工厂类：

• 定义了汽车接口 Car，以及两个具体汽车类 SedanCar 和 SUVCar，它们都实现了 Car 接口并且实现了 drive() 方法。
• 定义了工厂接口 CarFactoryInterface，该接口包含一个用于创建汽车对象的方法 concreateCar()。
• 实现了两个具体的工厂类 CarFactorySedan 和 CarFactorySUV，它们分别实现了 CarFactoryInterface 接口，并在 concreateCar() 方法中创建了 SedanCar 和 SUVCar 对象。
• 在客户端 Main 类中，通过实例化不同的工厂对象，可以生产不同类型的汽车对象，并调用 drive() 方法来驾驶这些汽车。

通过定义工厂接口和具体工厂类来实现对象的创建过程，客户端只需与工厂接口打交道，从而将具体的对象创建过程封装起来，提高了系统的灵活性和可维护性。同时，通过更换不同的工厂对象，可以创建不同类型的产品对象，实现了对象的解耦和灵活扩展

3. 抽象工厂模式：提供一个接口用于创建一系列相关或相互依赖的对象，而无需指定其具体类。抽象工厂模式可以创建多个产品族，在产品族中都有多个产品，可以提供不同产品之间的兼容性。

汽车生产通过抽象工厂模式实现JAVA代码如下：

// 定义汽车接口
interface Car {
    void drive();
}

// 具体汽车类
class SedanCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving a sedan car");
    }
}

class SUVCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving an SUV car");
    }
}

// 定义抽象工厂接口
interface CarAbstractFactory {
    Car createSedanCar();
    Car createSUVCar();
}

// 具体的工厂类
class CarFactory implements CarAbstractFactory {
    @Override
    public Car createSedanCar() {
        return new SedanCar();
    }

    @Override
    public Car createSUVCar() {
        return new SUVCar();
    }
}

public class Main {
    public static void main(String[] args) {
        CarAbstractFactory carFactory = new CarFactory();

        // 生产 SedanCar
        Car sedanCar = carFactory.createSedanCar();
        sedanCar.drive();

        // 生产 SUVCar
        Car suvCar = carFactory.createSUVCar();
        suvCar.drive();
    }
}

上述代码中通过定义抽象工厂接口 CarAbstractFactory，其中包含创建 SedanCar 和 SUVCar 的方法。具体的工厂类 CarFactory 实现了抽象工厂接口，并分别创建了 SedanCar 和 SUVCar 对象。在客户端 Main 类中，通过实例化 CarFactory 对象，可以生产不同类型的汽车对象，并调用 drive() 方法来驾驶这些汽车。

抽象工厂模式适用于需要提供一组相关对象的情况，每个具体工厂类负责创建一整套相关的产品对象，从而保持产品族的一致性。这种模式有助于降低系统耦合度，同时提供了灵活性，可以方便地替换整个产品族。