深入解析Java工厂模式：简单工厂、工厂方法和抽象工厂分析

Java工厂模式详解：简单工厂、工厂方法和抽象工厂

工厂模式是一种常用的设计模式，它用于根据不同的需求动态创建对象，将对象的创建与使用分离，提高代码的可复用性和可扩展性。在Java中，工厂模式主要有三种形式：简单工厂、工厂方法和抽象工厂。

一、简单工厂模式
简单工厂模式是最基本的工厂模式，也是最简单的一种形式。它通过一个工厂类来创建对象，根据不同的参数来决定创建哪种类型的对象。

首先，定义一个抽象的产品类，所有具体产品类都继承自该抽象类。然后，创建一个工厂类，该类包含一个静态方法，根据不同的参数返回相应的具体产品。

下面是一个示例代码，模拟汽车生产的过程：

// 定义抽象产品类
abstract class Car {
    public abstract void produce();
}

// 定义具体产品类
class BenzCar extends Car {
    public void produce() {
        System.out.println("生产奔驰汽车");
    }
}

class BMWCar extends Car {
    public void produce() {
        System.out.println("生产宝马汽车");
    }
}

// 实现工厂类
class CarFactory {
    public static Car createCar(String brand) {
        if (brand.equals("Benz")) {
            return new BenzCar();
        } else if (brand.equals("BMW")) {
            return new BMWCar();
        } else {
            throw new IllegalArgumentException("Unsupported brand:" + brand);
        }
    }
}

// 测试代码
public class SimpleFactoryPatternDemo {
    public static void main(String[] args) {
        Car benz = CarFactory.createCar("Benz");
        benz.produce();

        Car bmw = CarFactory.createCar("BMW");
        bmw.produce();
    }
}

通过调用CarFactory.createCar方法，根据不同的参数可以创建不同品牌的汽车对象。

简单工厂模式的优点是简单易懂，适用于简单的场景。但是缺点是违背了开放封闭原则，当新增一种产品时，需要修改工厂类的代码。

二、工厂方法模式
工厂方法模式是简单工厂模式的扩展，它引入了一个抽象的工厂类来定义方法，具体的产品创建由子类工厂类实现。每个具体工厂类只负责创建一种类型的产品。

首先，定义一个抽象的产品类，同样由所有具体产品类继承。然后，创建一个抽象的工厂类，该类包含一个抽象的创建产品的方法。每个具体的工厂类负责创建一种产品。

下面是一个示例代码，模拟手机生产的过程：

// 定义抽象产品类
abstract class Phone {
    public abstract void produce();
}

// 定义具体产品类
class ApplePhone extends Phone {
    public void produce() {
        System.out.println("生产苹果手机");
    }
}

class HuaweiPhone extends Phone {
    public void produce() {
        System.out.println("生产华为手机");
    }
}

// 定义抽象工厂类
abstract class PhoneFactory {
    public abstract Phone createPhone();
}

// 定义具体工厂类
class ApplePhoneFactory extends PhoneFactory {
    public Phone createPhone() {
        return new ApplePhone();
    }
}

class HuaweiPhoneFactory extends PhoneFactory {
    public Phone createPhone() {
        return new HuaweiPhone();
    }
}

// 测试代码
public class FactoryMethodPatternDemo {
    public static void main(String[] args) {
        PhoneFactory appleFactory = new ApplePhoneFactory();
        Phone applePhone = appleFactory.createPhone();
        applePhone.produce();

        PhoneFactory huaweiFactory = new HuaweiPhoneFactory();
        Phone huaweiPhone = huaweiFactory.createPhone();
        huaweiPhone.produce();
    }
}

通过实现不同的具体工厂类，每个工厂类负责创建一种类型的手机对象。使用工厂方法模式，可以方便地新增更多的产品系列，而不需要修改已有的代码。

工厂方法模式的优点是符合开放封闭原则，每个具体工厂类只负责创建一种产品，易于扩展。但缺点是增加了系统的复杂度，需要为每个产品定义一个具体工厂类。

三、抽象工厂模式
抽象工厂模式是工厂方法模式的继续扩展，它引入了一个抽象的工厂类来定义一组方法，每个方法负责创建一个产品系列。每个具体工厂类负责创建一种产品系列。

首先，定义抽象的产品类和抽象的工厂类，每个抽象工厂类包含多个抽象的创建产品的方法。然后，创建具体的产品类和具体的工厂类，分别实现抽象的产品类和工厂类。

下面是一个示例代码，模拟电视和冰箱生产的过程：

// 定义抽象产品类
abstract class TV {
    public abstract void produce();
}

abstract class Refrigerator {
    public abstract void produce();
}

// 定义具体产品类
class SamsungTV extends TV {
    public void produce() {
        System.out.println("生产三星电视");
    }
}

class TCLTV extends TV {
    public void produce() {
        System.out.println("生产TCL电视");
    }
}

class HaierRefrigerator extends Refrigerator {
    public void produce() {
        System.out.println("生产海尔冰箱");
    }
}

class GreeRefrigerator extends Refrigerator {
    public void produce() {
        System.out.println("生产格力冰箱");
    }
}

// 定义抽象工厂类
abstract class ApplianceFactory {
    public abstract TV createTV();
    public abstract Refrigerator createRefrigerator();
}

// 定义具体工厂类
class SamsungFactory extends ApplianceFactory {
    public TV createTV() {
        return new SamsungTV();
    }

    public Refrigerator createRefrigerator() {
        return new HaierRefrigerator();
    }
}

class TCLFactory extends ApplianceFactory {
    public TV createTV() {
        return new TCLTV();
    }

    public Refrigerator createRefrigerator() {
        return new GreeRefrigerator();
    }
}

// 测试代码
public class AbstractFactoryPatternDemo {
    public static void main(String[] args) {
        ApplianceFactory samsungFactory = new SamsungFactory();
        TV samsungTV = samsungFactory.createTV();
        Refrigerator haierRefrigerator = samsungFactory.createRefrigerator();
        samsungTV.produce();
        haierRefrigerator.produce();

        ApplianceFactory tclFactory = new TCLFactory();
        TV tclTV = tclFactory.createTV();
        Refrigerator greeRefrigerator = tclFactory.createRefrigerator();
        tclTV.produce();
        greeRefrigerator.produce();
    }
}

通过实现不同的具体工厂类，每个具体工厂类负责创建一种产品系列。使用抽象工厂模式，可以非常方便地新增更多的产品系列，而不需要修改已有的代码。

抽象工厂模式的优点是符合开放封闭原则，易于扩展，同时可以保持产品之间的相关性。但缺点是当新增产品系列时，需要修改抽象工厂类的代码。

总结：
工厂模式是一种常用的设计模式，用于根据不同的需求动态创建对象。Java中主要有三种工厂模式：简单工厂、工厂方法和抽象工厂。简单工厂模式是最基本的一种形式，工厂方法模式在其基础上引入了抽象工厂类，抽象工厂模式则扩展了工厂方法模式，引入了一组方法来创建产品系列。根据具体的应用场景和需求，选择合适的工厂模式可以提高代码的可复用性和可扩展性。