Java设计模式：工厂模式

什么是工厂模式？

工厂模式属于创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们不会直接实例化对象，而是通过工厂来创建所需的对象。这样做的好处之一是将对象的创建和使用分离，使代码更易于维护和扩展。

工厂模式的类型

简单工厂模式

简单工厂模式是最基本的工厂模式之一，我们通过下一个简单例子结合解释

/**
 * 手机
 * @author LGC
 */
public interface Phone {
    void call();
}

/**
 * 华为手机
 * @author LGC
 */
public class HuaWeiPhone implements Phone {
    @Override
    public void call() {
        System.out.println("用华为手机打电话");
    }
}

/**
 * 小米手机
 * @author LGC
 */
public class XiaomiPhone implements Phone {
    @Override
    public void call() {
        System.out.println("用小米手机打电话");
    }
}

/**
 * 简单工厂模式
 * 单一职责，开闭原则，接口隔离原则，里氏替换原则，迪米特法则，依赖倒置原则
 * @author LGC
 */
public class SimplePhoneFactory {

    public Phone create(String type) {
        if (type.equals("huawei")) {
            return new HuaWeiPhone();
        } else {
            return new XiaomiPhone();
        }
    }
}

/**
 * 通过简单工厂获取小米手机
 */
@Test
public void simpleFactory() {
    PhoneFactory phoneFactory = new PhoneFactory();
    Phone phone = phoneFactory.create("xiaomi");
    phone.call();
}

通过代码可知，该手机工厂可以生产不同品牌手机（小米和华为品牌手机），假如需要生产三星品牌的手机，则需要修改工厂类 SimplePhoneFactory 类，显然这就违反了开闭原则。在我们的使用过程中，如果是单一的固定几个品牌（类型，种类等等），而且后期不会新增，我们可以使用简单工厂模式进行创建一个对象。

工厂方法模式

通过上面代码我们知道，假如我们需要生产其它品牌的手机就需要修改工厂类，那我们有没有办法做到不修改工厂类，其实我们可以改造成工厂方法模式，不同的品牌手机使用不同品牌手机工厂，我们改造一下手机工厂类，创建不同品牌的工厂

/**
 * 工厂方法

 * 手机工厂
 * 将不同品牌手机工厂拆分为不同工厂
 * 如需生产三星手机，新建一个三星品牌手机工厂
 * @author LGC
 */
public interface PhoneFactory {
    Phone create();
}


/**
 * 小米品牌手机工厂
 *
 * @author LGC
 */
public class XiaomiPhoneFactory implements PhoneFactory {

    @Override
    public Phone create() {
        return new XiaomiPhone();
    }
}

/**
 * 华为品牌手机工厂
 *
 * @author LGC
 */
public class HuaweiPhoneFactory implements PhoneFactory {

    @Override
    public Phone create() {
        return new HuaWeiPhone();
    }
}

// 假如我们还要创建新的品牌手机只需要添加一个品牌手机工厂如：

/**
 * 三星品牌手机工厂
 *
 * @author LGC
 */
public class SanxingPhoneFactory implements PhoneFactory {

    @Override
    public Phone create() {
        return new SanxingPhone();
    }
}

/**
 * 通过工厂方法获取华为手机工厂，然后创建手机
 */
@Test
public void methodFactory() {
      PhoneFactory phoneFactory = new HuaweiPhoneFactory();
      Phone phone = phoneFactory.create();
      phone.call();
}

工厂方法模式引入了抽象工厂接口，每个具体的产品都有对应的工厂类来创建。这样可以实现不同产品的独立扩展，符合开闭原则。

抽象工厂模式

我们观察到上面的工厂方法模式，只能创建某个产品对应的工厂，假如我有一个超级工厂，该工厂不仅可以创建手机产品，也能创建电脑、电视等一系列产品族，那我们该如何创建我们的工厂呢？其实我们可以把每个产品的工厂抽象出来，交给超级工厂来统一管理。比如下面一个超级工厂不仅生产手机也可以生产电脑

/**
 * @author LGC
 * @date 2023/8/10 14:07
 */
public interface Compute {

    /**
     * 上网
     */
    void online();
}
/**
 * @author LGC
 */
public class HuaWeiCompute implements Compute {
    @Override
    public void online() {
        System.out.println("用华为电脑上网");
    }
}
/**
 * @author LGC
 */
public class XiaomiCompute implements Compute {
    @Override
    public void online() {
        System.out.println("用小米电脑上网");
    }
}

/**
 * 工厂方法
 * <p>
 * 电脑工厂
 * 将不同品牌电脑工厂拆分为不同工厂
 * 如需生产三星电脑，新建一个三星品牌电脑
 *
 * @author LGC
 */
public interface ComputeFactory {

    Compute create();

}
/**
 * 华为品牌电脑工厂
 *
 * @author LGC
 */
public class HuaweiComputeFactory implements ComputeFactory {

    @Override
    public Compute create() {
        return new HuaWeiCompute();
    }
}

/**
 * 小米品牌电脑工厂
 *
 * @author LGC
 */
public class XiaomiComputeFactory implements ComputeFactory {

    @Override
    public Compute create() {
        return new XiaomiCompute();
    }
}

/**
 * 抽象工厂-超级工厂，不仅可以生产手机，也可以生产电脑
 * <p>
 * 手机工厂
 * 电脑工厂
 * 还可其它产品，如耳机，电池等等
 * <p>
 * 可以把不同产品同一品牌的放在品牌族里
 *
 * @author LGC
 */
public interface Factory {

    /**
     * 手机工厂
     *
     * @return
     */
    PhoneFactory createPhoneFactory();

    /**
     * 电脑工厂
     *
     * @return
     */
    ComputeFactory createComputeFactory();

}

/**
 * 华为品牌族工厂
 *
 * @author LGC
 */
public class HuaweiFactory implements Factory {

    /**
     * 华为手机工厂
     *
     * @return
     */
    @Override
    public PhoneFactory createPhoneFactory() {
        return new HuaweiPhoneFactory();
    }

    /**
     * 华为电脑工厂
     *
     * @return
     */
    @Override
    public ComputeFactory createComputeFactory() {
        return new HuaweiComputeFactory();
    }

}

/**
 * 小米品牌族工厂
 *
 * @author LGC
 */
public class XiaomiFactory implements Factory {

    /**
     * 小米手机工厂
     *
     * @return
     */
    @Override
    public PhoneFactory createPhoneFactory() {
        return new XiaomiPhoneFactory();
    }

    /**
     * 小米电脑工厂
     *
     * @return
     */
    @Override
    public ComputeFactory createComputeFactory() {
        return new XiaomiComputeFactory();
    }

}

 @Test
 public void abstractFactory() {
     //华为品牌族
     Factory factory = new HuaweiFactory();
     PhoneFactory phoneFactory = factory.createPhoneFactory();
     Phone phone = phoneFactory.create();
     phone.call();

    ComputeFactory computeFactory = factory.createComputeFactory();
    Compute compute = computeFactory.create();
    compute.online();

    //小米品牌族
    factory = new XiaomiFactory();
    phoneFactory = factory.createPhoneFactory();
    phone = phoneFactory.create();
    phone.call();

    computeFactory = factory.createComputeFactory();
    compute = computeFactory.create();
    compute.online();

}

抽象工厂模式是工厂方法模式的扩展，它通过提供一个创建一系列相关或相互依赖对象的接口，实现了一组产品族的创建。

结语

工厂模式是面向对象编程中极为重要的设计模式之一，在 Java 开发中有着广泛的应用。通过合理地运用工厂模式，我们能够提高代码的灵活性、可维护性和可扩展性