Java教程

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

本文主要是介绍Java常用设计模式—工厂模式,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

工厂模式

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

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

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

应⽤场景:

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

1、简单工厂模式

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

核心组成

  • 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(大众)类,就必须改动现有的逻辑结构,因此,引入工厂方法模式解决此问题!

2、工厂方法模式

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

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

核心组成:

  • 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(); //五菱之光
    }
}

测试成功!

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

在这里插入图片描述

工厂方法模式优点:

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

工厂方法模式缺点:

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

3、抽象工厂模式

抽象工厂⽅法模式是简单工厂模式 和工厂方法模式的整合升级版。抽象工厂模式在 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();
    }
}

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

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

在这里插入图片描述

这篇关于Java常用设计模式—工厂模式的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!