设计模式之工厂模式

工厂模式

工厂模式是一种创建型设计模式，它提供了一种在不指定具体类的情况下创建对象的方法。在Java中，工厂模式通常通过创建一个工厂类来实现，该类负责根据传入的参数创建并返回相应的对象实例。

• 核心本质：
  • 实例化对象不使用new，用工厂方式代替。这是将对象的创建过程抽象化的重要途经。
  • 选择实体类，创建对象统一管理和控制，从而将调用者跟我们的实体类解耦。这样可以使得客户端不需要关系对象是如何创建的，只需要关心如何通过接口来使用对象。
  • 工厂模式子啊实际开发过程中是使用频率很高的一种模式，明确了各个类的职责，如果有新的对象需要添加，只需要添加一个具体的类和具体的工厂类即可，从而简化了对象的创建和管理过程。
  • 工厂模式可以将对象的创建和使用解耦，从而提高系统的灵活性和可维护性。工厂模式可以影藏对象的创建细节，使得客户端只关心对象得使用。
• 三种模式：
  • 简单工厂模式：
    • 是一种最简单的工厂模式，它提供了一个用于创建对象的接口，但子类必须实现该接口
  • 工厂设计模式
    • 是一种将对象的创建过程抽象化的模式，它提供了一种用于创建对象的接口，但由子类决定实例化哪个类。
  • 抽象工厂模式
    • 是一种更复杂的工厂模式，它提供了一组用于创建对象的接口，允许创建多个产品族中的产品对象。

简单工厂模式

1，没用工厂模式之前

/**
 * 宝马车1
 */
public class BMW1 {
    public BMW1(){
        System.out.println("setter--->BMW1");
    }
}

/**
 * 宝马车2
 *
 */
public class BMW2 {
    public BMW2(){
        System.out.println("setter--->BMW2");
    }
}

public class Customer {
    public static void main(String[] args) {
        BMW1 bmw1 = new BMW1();
        BMW2 bmw2 = new BMW2();
    }
}

2，用了工厂之后

/**
 * 产品类
 */
public class BMW {
    public BMW() {
    }
}

public class BMW01 extends BMW{
    public BMW01(){
        System.out.println("setter------BMW01");
    }
}

public class BMW02 extends BMW{
    public BMW02(){
        System.out.println("setter------BMW02");
    }
}

/**
 * 工厂类
 *
 */
public class Factory {
    public BMW createBMW(int type){
        switch (type){
            case 01:
                return new BMW01();

            case 02:
                return new BMW02();

            default:
                break;
        }
        return null;
    }
}

/**
 * 客户类
 */
public class Customer01 {
    public static void main(String[] args) {
        Factory factory = new Factory();
        BMW bmw01 = factory.createBMW(01);
        BMW bmw02 = factory.createBMW(02);
    }
}

3，简单工厂模式的优缺点：

? 优点：

• 简单工厂模式提供专门的工厂类用于创建对象，实现了对象创建和使用的职责分离，客户端不需要知道所创建的具体实现和类名以及创建过程，只需要知道具体产品类所对应的参数即可，通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加的具体产品类，在一定程度上提高了系统的灵活性。

  ? 缺点：

• 不符合“开闭原则”，每次添加新产品就需要修改工厂类，在产品类型较多时，有可能造成工厂逻辑复杂，不利于系统的扩展维护，并且工厂类集中了所有的产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。

  ? 为了解决简单工厂模式的问题，出现了工厂方法模式。

工厂方法模式

? 工厂方法模式将工厂模式抽象化，并定义一个创建对象的接口，每增加产品，只需要增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品时哪个，将对象的创建于实例化延迟到子类，这样工厂的是设计就符合了“开闭原则”,扩展时不必区修改原来的代码，在使用时，用于只需要知道产品对具体工厂，关注具体的创建过程，甚至不需要知道具体产品类的类名，当为什么选择哪个具体工厂时，就已经决定了实际创建的产品是哪个。

? 缺点

? 每增加一个产品都需要增加一个具体产品类和实现工厂类，是的系统中类的个数成倍增加，在一定程度上系统的复杂度，同时也增加了系统具体类的依赖。

/**
 * 产品类
 */
public class BMW {
    public BMW() {
    }
}

public class BMW01 extends BMW{
    public BMW01(){
        System.out.println("setter------BMW01");
    }
}

public class BMW02 extends BMW{
    public BMW02(){
        System.out.println("setter------BMW02");
    }
}

/**\
 * 工厂类
 */
public interface FactoryBMW {
    BMW createBMW();
}
public class FacotyBMW01 implements FactoryBMW{
    @Override
    public BMW01 createBMW() {
        return new BMW01();
    }
}
public class FactoryBMW02 implements FactoryBMW{
    @Override
    public BMW02 createBMW() {
        return new BMW02();
    }
}

/**
 * 客户类
 */
public class Customer03 {
    public static void main(String[] args) {
        FacotyBMW01 facotyBMW01 = new FacotyBMW01();
        BMW01 bmw01 = facotyBMW01.createBMW();

        FactoryBMW02 facotyBMW02 = new FactoryBMW02();
        BMW01 bmw02 = facotyBMW01.createBMW();
    }
}

抽象工厂模式

? 抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们的具体的类。

优缺点

• 优点：
  • 具体产品在应用层的代码隔离，无需关心创建的细节。
  • 将一个系列的产品统一到一起创建。
• 缺点
  • 指定了所有可能被创建的产品集合，产品族中扩展新的产品。
  • 增加了系统的抽象性和理解难度。

使用场景：

1，客户端（应用层），不依赖于产品类示例如何被创建，实现等细节。

2，强调一系列相关的产品对象（数据统一产品族）一起使用创建对象需要大量的重复代码

3，提供一个产品类的库，所有的产品一同样的接口出现，使得客户端不依赖于具体实现。

/**
 * 创建手机工厂
 */
public interface IpnoneProduct {
    void sendEamil();
    void trunOff();
    void trunOn();
    void callUp();
}

/**
 * 模拟手机厂家华为制造手机
 */
public class HuaWePhone implements IpnoneProduct {
    @Override
    public void sendEamil() {
        System.out.println("HuaWe---Eamil");
    }

    @Override
    public void trunOff() {
        System.out.println("HuaWe---off");
    }

    @Override
    public void trunOn() {
        System.out.println("HuaWe---ON");
    }

    @Override
    public void callUp() {
        System.out.println("HuaWe---UP");
    }
}

/**
 * 模拟手机厂家小米制造手机
 */
public class XiaoMiPhone implements IpnoneProduct {

    @Override
    public void sendEamil() {
        System.out.println("XiaoMi---input---Eamil");
    }

    @Override
    public void trunOff() {
        System.out.println("XiaoMi---Off");
    }

    @Override
    public void trunOn() {
        System.out.println("XiaoMi---ON");
    }

    @Override
    public void callUp() {
        System.out.println("XiaoMi---Up");
    }
}

/**
 * 模拟路由器工厂
 */
public interface IRouterProduct {
    void start();
    void shutdown();
    void openWife();
    void Setting();

}

/**
 * 模拟华为路由器
 */
public class HuaWeRouter implements IRouterProduct {
    @Override
    public void start() {
        System.out.println("start---huawei---router");
    }

    @Override
    public void shutdown() {
        System.out.println("start---huawei---router");
    }

    @Override
    public void openWife() {
        System.out.println("start---huawei---router");
    }

    @Override
    public void Setting() {
        System.out.println("start---huawei---router");
    }
}

/**
 * 模拟小米路由器
 */
public class XiaomiRouter implements IRouterProduct {
    @Override
    public void start() {
        System.out.println("start---xiaomi---router");
    }

    @Override
    public void shutdown() {
        System.out.println("stop---xiaomi---router");
    }

    @Override
    public void openWife() {
        System.out.println("open---xiaomi---router");
    }

    @Override
    public void Setting() {
        System.out.println("set---xiaomi---router");
    }
}

/**
 * 创建抽象产品工厂
 */
public interface IProductFactory {
    //生产手机
    IpnoneProduct ipnoneProduct();
    //生产路由器
    IRouterProduct iRouterProduct();
}

/**
 * 创建华为工厂
 */
public class HuaWeFactroy implements IProductFactory{

    @Override
    public IpnoneProduct ipnoneProduct() {
        return new HuaWePhone();
    }

    @Override
    public IRouterProduct iRouterProduct() {
        return new HuaWeRouter();
    }
}

/**
 * 创建小米工厂
 */
public class XiaoMiFactroy implements IProductFactory{

    @Override
    public IpnoneProduct ipnoneProduct() {
        return new XiaoMiPhone();
    }

    @Override
    public IRouterProduct iRouterProduct() {
        return new XiaomiRouter();
    }
}

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        System.out.println("=========================xiaomi=======================");
        //小米工厂
        XiaoMiFactroy xiaoMiFactroy = new XiaoMiFactroy();

        IpnoneProduct ipnoneProduct = xiaoMiFactroy.ipnoneProduct();
        ipnoneProduct.callUp();
        ipnoneProduct.sendEamil();
        IRouterProduct iRouterProduct = xiaoMiFactroy.iRouterProduct();
        iRouterProduct.openWife();

        System.out.println("=========================huawei=======================");
        //华为工厂
        HuaWeFactroy huaWeFactroy = new HuaWeFactroy();

        ipnoneProduct = huaWeFactroy.ipnoneProduct();
        ipnoneProduct.callUp();
        ipnoneProduct.sendEamil();
        iRouterProduct = huaWeFactroy.iRouterProduct();
        iRouterProduct.openWife();

    }
}