Java常用设计模式—工厂模式

1|0工厂模式

它提供了⼀种创建对象的最佳⽅式，我们在创建对象时 不会对客户端暴露创建逻辑，并且是通过使⽤⼀个共同 的接⼝来指向新创建的对象。

工厂模式有 3 种不同的实现⽅式：

• 简单工厂模式（静态工厂）：通过传⼊相关的类型来返回相应的类，这种方式比较单一，可扩展性相对较差。
• 工厂方法模式：通过实现类实现相应的⽅法来决定相应的返回结果，这种方式的可扩展性比较强。
• 抽象工厂模式：基于上述两种模式的拓展，且⽀持细化产品。

应⽤场景：

• 解耦：分离职责，把复杂对象的创建和使⽤的过程分开。
• 复⽤代码 降低维护成本：如果对象创建复杂且多处需⽤到，如果每处都进⾏编写，则很多重复代码，如果业务逻辑发⽣了改 变，需⽤四处修改；使⽤⼯⼚模式统⼀创建，则只要修改⼯⼚类即可， 降低成本。

1|11、简单工厂模式

• ⼜称静态工厂⽅法，可以根据参数的不同返回不同类的实例 ，专⻔定义⼀个类来负责创建其他类的实例，被创建的实例通常都具有共同的⽗类。由于⼯⼚⽅法是静态⽅法，可通过类名直接调⽤，⽽且只需要传⼊简单的参数即可。

核心组成

• Factory：工厂类，简单工厂模式的核心，它负责实现 创建所有实例的内部逻辑。
• IProduct：抽象产品类，简单工厂模式所创建的所有对象的⽗类，描述所有实例所共有的公共接⼝。
• Product：具体产品类，是简单工厂模式的创建⽬标。

实现案例

1、创建 Product 具体产品类

public interface Car {
    void name() ;
}

2、创建 Product 具体产品类—Tesla、Wuling

• Tesla.java

public class Tesla implements Car {
    @Override
    public void name() {
        System.out.println("特斯拉Model3");
    }
}

• Wuling.java

public class Wuling implements Car {
    @Override
    public void name() {
        System.out.println("五菱之光");
    }
}

3、创建Factory工厂类

public class CarFactory {
    /**
     * 根据请求参数，返回指定对象！
     * @param name
     * @return
     */
    public static Car getCar(String name){
         if ("五菱".equals(name)){
             return new Wuling() ;
         }else if("特斯拉".equals(name)){
             return new Tesla() ;
         }else{
             return null ;
         }
     }
}

上述就是工厂设计模式——简单工程(静态工厂的一个简单使用例子)，那么我们来分析下其缺点与不足之处：

• 简单工厂模式，实现简单，但是不满足开闭原则（扩展开放，修改关闭）；
• 我们无法在不改动源代码的基础上实现扩展，但是实际开发比较常用 ；

比如：我们想要在工厂增加一个Dazhong（大众）类，就必须改动现有的逻辑结构，因此，引入工厂方法模式解决此问题！

1|22、工厂方法模式

是对简单⼯⼚模式的进⼀步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满⾜开闭原则。

• 相⽐简单⼯⼚⽽⾔，此种⽅法具有更多的可扩展性和复⽤性，同时也增强了代码的可读性。

核心组成：

• IProduct：抽象产品接口，描述所有实例所共有的公共接⼝。
• Product：具体产品类，实现抽象产品类的接⼝，⼯⼚ 类创建对象，如果有多个需要定义多个。
• IFactory：抽象⼯⼚接口，描述具体⼯⼚的公共接⼝。
• Factory：具体⼯⼚类，实现创建产品类对象，实现抽 象⼯⼚类的接⼝，如果有多个需要定义多个。

要实现工厂方法模式，只需要在原来的简单工厂模式基础上，做出改进，我们Tesla、Wuling两个具体产品类不变

实现案例

1、创建CarFactory抽象工厂接口

public interface CarFactory {
      Car getCar()  ;
}

2、然后创建TeslaFactory 和 WulingFactory 两个具体的工厂类

• TeslaFactory.java

public class TeslaFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new Tesla();
    }
}

• WulingFactory .java

public class WulingFactory implements CarFactory {
    @Override
    public Car getCar() {
        return new Wuling();
    }
}

3、进行测试

public class Consumer {
    public static void main(String[] args) {
        Car car = new TeslaFactory().getCar();
        Car car1 = new WulingFactory().getCar();
        
        car.name();   // 特斯拉Model3
        car1.name(); //五菱之光
    }
}

测试成功！

工厂方法模式思路如下图：

工厂方法模式优点：

• 符合开闭原则，增加⼀个产品类，只需要实现其他具体的产品类和具体的⼯⼚类；
• 符合单⼀职责原则，每个⼯⼚只负责⽣产对应的产品；

工厂方法模式缺点：

• 增加⼀个产品，需要实现对应的具体⼯⼚类和具体产品类；
• 每个产品需要有对应的具体⼯⼚和具体产品类；

1|33、抽象工厂模式

抽象工厂⽅法模式是简单工厂模式 和工厂方法模式的整合升级版。抽象工厂模式在 Spring 中应⽤得最为⼴泛的⼀种设计模式。

• 工厂方法模式引⼊工厂等级结构，解决了简单工厂模式中工厂类职责过重的问题。
• 但工厂方法模式中每个工厂只创建⼀类具体类的对象， 后续发展可能会导致工厂类过多

实现步骤

1、定义两个接口：IPhoneProduct（手机）、IRouterPruduct（路由器）

2、创建具体的 手机产品 和 路由器产品

3、创建抽象工厂：IProductFactory ，其中有创建手机和创建路由器两个方法

4、创建Apple产品族（Apple工厂），实现抽象工厂IProductFactory

5、创建华为产品族（华为工厂），实现抽象工厂IProductFactory

6、创建Client去拿到工厂，获取对应的产品

接下来，我们就按照步骤实现以下抽象工厂模式 ：

1、定义两个接口：IPhoneProduct（手机）、IRouterPruduct（路由器）

public interface IPhoneProduct {    //手机接口
    void start() ;   //开机
    void shutdown() ;  // 关机
    void callUp() ; //打电话
    void sendSMS() ;  //发短息
}

public interface IRouterProduct {    //路由器接口
    void start() ;  // 路由器开机
    void shutdown() ; //  路由器关机
    void findWifi() ; // 路由器寻找wifi
    void Setting() ; // 路由器设置
}

2、创建具体的 手机产品 和 路由器产品

• 手机产品：华为手机、Apple手机

/*
*	Apple手机
*/
public class ApplePhone implements IPhoneProduct {
    @Override
    public void start() {System.out.println("Apple开机");}
    @Override
    public void shutdown() { System.out.println("Apple关机");}
    @Override
    public void callUp() {System.out.println("Apple打电话");}
    @Override
    public void sendSMS() {System.out.println("Apple发短信");}
}

/*
*	华为手机
*/
public class HuaWeiPhone implements IPhoneProduct {
    @Override
    public void start() { System.out.println("华为开机"); }
  	@Override
    public void shutdown() { System.out.println("华为关机");}
    @Override
    public void callUp() { System.out.println("华为打电话");}
    @Override
    public void sendSMS() { System.out.println("华为发短信");}
}

• 路由器产品：华为路由器、Apple路由器

/*
*	华为路由器
*/
public class HuaWeiRouter implements IRouterProduct {
    @Override
    public void start() {System.out.println("华为路由器开机");}

    @Override
    public void shutdown() {System.out.println("华为路由器关机"); }

    @Override
    public void findWifi() { System.out.println("华为路由器找wifi");}

    @Override
    public void Setting() { System.out.println("开启华为路由器设置"); }
}

/*
*	Apple路由器产品
*/
public class AppleRouter implements IRouterProduct {
    @Override
    public void start() {System.out.println("Apple路由器开机");}

    @Override
    public void shutdown() {System.out.println("Apple路由器关机"); }

    @Override
    public void findWifi() {System.out.println("Apple路由器找wifi");}

    @Override
    public void Setting() {System.out.println("Apple华为路由器设置");}
}

3、创建抽象工厂：IProductFactory ，其中有创建手机和创建路由器两个方法

/***
 * 抽象工厂：生产工厂
 */
public interface IProductFactory {

    //生产手机
    IPhoneProduct iPhoneProduct() ;

    //生产路由器
    IRouterProduct iRouterProduct() ;

}

4、创建Apple产品族（Apple工厂），实现抽象工厂IProductFactory

public class AppleFactory implements IProductFactory {
    @Override
    public IPhoneProduct iPhoneProduct() {
        return new ApplePhone();
    }

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

5、创建华为产品族（华为工厂），实现抽象工厂IProductFactory

public class HuaWeiFactory implements IProductFactory {
    @Override
    public IPhoneProduct iPhoneProduct() {
        return new HuaWeiPhone();
    }

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

6、创建Client去拿到工厂，获取对应的产品

public class Client {
    public static void main(String[] args) {
        System.out.println("================华为生产====================");
        HuaWeiFactory huaWeiFactory = new HuaWeiFactory();
        IPhoneProduct product = huaWeiFactory.iPhoneProduct();
        product.start();
        product.callUp();
        product.sendSMS();

        IRouterProduct routerProduct = huaWeiFactory.iRouterProduct();
        routerProduct.findWifi();
        routerProduct.Setting();
        routerProduct.shutdown();

        System.out.println("================Apple生产====================");
        AppleFactory appleFactory = new AppleFactory();
        IPhoneProduct iPhoneProduct = appleFactory.iPhoneProduct();
        iPhoneProduct.start();
        iPhoneProduct.callUp();
        iPhoneProduct.sendSMS();

        IRouterProduct iRouterProduct = appleFactory.iRouterProduct();
        iRouterProduct.findWifi();
        iRouterProduct.Setting();
        iRouterProduct.shutdown();
    }
}

• 从上面案例可以看出，抽象工厂模式是工厂方法模式和静态工厂模式的合并，即超级工厂使用的是简单工厂模式，受超级工厂管辖的工厂使用的是工厂方法模式。

抽象工厂模式思路如下图：

__EOF__

本文作者：宋淇祥
本文链接：https://www.cnblogs.com/qxsong/p/15837227.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！