Java编程技巧之样板代码

前言

北宋科学家沈括在《梦溪笔谈》第十八卷《技艺》中这样描述“活字印刷术”：

庆历中，有布衣毕昇，又为活版。其法用胶泥刻字，薄如钱唇，每字为一印，火烧令坚……若止印三、二本，未为简易;若印数十百千本，则极为神速。

在日常编码的过程中，我们可以总结出很多“样板代码”，就像”活字印刷术中的“活字”一样。当我们编写新的代码时，需要用到这些“活字”，就把“样板代码”拷贝过来，修改替换一下就可以了，写起代码来“极为神速”。“样板代码”其实就是一种样例、一种模式、一种经验……总结的“样板代码”越多，编写代码的格式越规范、质量越高、速度越快。

这里，作者总结了几种常见Java的“样板代码”，希望起到抛砖引玉的作用，希望大家不断总结和完善，形成自己的样板代码库。

一样板代码简介

1 什么是样板代码?

样板代码(Boilerplate Code)，通常是指一堆具有固定模式的代码块，可以被广泛地应用到各个程序模块。

例如，读取文件就是典型的样板代码：

 
 
 
   
  
  
  try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {   
  
  
      String line;   
  
  
      while (Objects.nonNull(line = reader.readLine())) {   
  
  
          // 处理一行   
  
  
          ...   
  
  
      }   
  
  
  } catch (IOException e) {   
  
  
      String message = String.format("读取文件(%s)异常", fileName);   
  
  
      log.error(message, e);   
  
  
      throw new ExampleException(message, e);   
  
  
  }

2 样板代码有什么用?

样板(Boilerplate )，可以拆分为样例(Example)和模式(Pattern)两个单词进行理解——样例(Example)指可以当成一种标准范例，模式(Pattern)指可以作为一种解决方案。当遇到类似的案例时，就把样板代码拷贝过去，根据实际情况进行修改，该案例就被轻松解决了。

样板代码的主要作用：

提供一种标准样例：可以用于新人学习，能够快速上手并使用;
提供一种解决方案：遇到类似案例时，可以快速利用该方案进行解决;
有助于不断积累经验：当发现一种样例代码时，都会不断地进行优化，力求达到最佳样例;
有助于提高代码质量：样板代码必然通过了时间考验，存在BUG和出错的几率相对比较低;
有助于提高编码速度：利用样板代码编码，只是复制粘贴修改代码，编码速度大幅提高;
有助于统一代码样式：心中有了样板代码，就能保证每次都写出统一样式的代码。

3 如何编写样板代码?

在作者以前的文章《这6种编码方法，你掌握了几个?》中，有详细的说明和举例，这里不再累述。其中，适合于样板代码的编写方法有：

复制粘贴生成代码：利用复制粘贴样板代码，用好了编码会事半功倍。

用文本替换生成代码：利用文本替换生成代码，可以很快生成一段新代码。

用Excel公式生成代码：把样板代码先公式化，传入不同的参数，生成不同的代码。

用工具或插件生成代码：很多开发工具或插件都提供一些工具生成代码，比如：生成构造方法、重载基类/接口方法、生成Getter/Setter方法、生成toString方法、生成数据库访问方法……能够避免很多手敲代码。

用代码生成代码：用代码生成代码，就是自己编写代码，按照自己的样板代码格式生成代码。

4 如何减少样板代码?

样板代码(Boilerplate Code)具有很大的重复性，通常被认为是一种冗余而又不得不写的代码。其实不然，有些样板代码不能减少，只是我们还没有遇到合适的解决方案而已。通常情况下，我们可以通过以下几种方式减少样板代码：

利用注解减少样板代码

比如，JavaBean模型类中的Getter/Setter就是样板代码，我们可以通过Lombok的@Getter/@Setter注解来减少这样的样板代码。

原始代码：

 
 
 
   
  
  
  public class User {   
  
  
      private Long id;   
  
  
      ...   
  
  
      public Long getId() {   
  
  
          return id;   
  
  
      }   
  
  
      public void setId(Long id) {   
  
  
          this.id = id;   
  
  
      }   
  
  
      ...   
  
  
  }

优化代码：

 
 
 
   
  
  
  @Getter   
  
  
  @Setter   
  
  
  public class User {   
  
  
      private Long id;   
  
  
      ...   
  
  
  }

利用框架减少样板代码

比如，MyBatis 是一款优秀的持久层框架，封装了获取数据库连接和声明、设置参数、获取结果集等所有JDBC操作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects，普通老式 Java 对象)为数据库中的记录。

原始代码：

 
 
 
   
  
  
  /** 查询公司员工 */   
  
  
  public List queryEmployee(Long companyId) {   
  
  
      try (Connection connection = tddlDataSource.getConnection();   
  
  
          PreparedStatement statement = connection.prepareStatement(QUERY_EMPLOYEE_SQL)) {   
  
  
          statement.setLong(1, companyId);   
  
  
          try (ResultSet result = statement.executeQuery()) {   
  
  
              List employeeList = new ArrayList<>();   
  
  
              while (result.next()) {   
  
  
                  EmployeeDO employee = new EmployeeDO();   
  
  
                  employee.setId(result.getLong(1));   
  
  
                  employee.setName(result.getString(2));   
  
  
                  ...   
  
  
                  employeeList.add(employee);   
  
  
              }   
  
  
              return employeeList;   
  
  
          }   
  
  
      } catch (SQLException e) {   
  
  
          String message = String.format("查询公司(%s)用户异常", companyId);   
  
  
          log.error(message, e);   
  
  
          throw new ExampleException(message, e);   
  
  
      }   
  
  
  }

优化代码：

1)UserDAO.java

 
 
 
   
  
  
  @Mapper   
  
  
  public interface UserDAO {   
  
  
      List queryEmployee(@Param("companyId") Long companyId);   
  
  
  }

2)UserDAO.xml

 
 
 
   
  
  
     
  
  
         
  
  
          select id   
  
  
          , name   
  
  
          ...   
  
  
          from t_user   
  
  
          where company_id = #{companyId}

利用设计模式减少样板代码

利用设计模式，可以把一些重复性代码进行封装。比如，上面的读取文件行模式代码，就可以用模板方法进行封装。

原始代码：

 
 
 
   
  
  
  try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {   
  
  
      String line;   
  
  
      while (Objects.nonNull(line = reader.readLine())) {   
  
  
          // 处理一行   
  
  
          ...   
  
  
      }   
  
  
  } catch (IOException e) {   
  
  
      String message = String.format("读取文件(%s)异常", fileName);   
  
  
      log.error(message, e);   
  
  
      throw new ExampleException(message, e);   
  
  
  }

优化代码：

 
 
 
   
  
  
  /** 定义方法 */   
  
  
  public static void readLine(String fileName, Consumer lineConsumer) {   
  
  
      try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {   
  
  
          String line;   
  
  
          while (Objects.nonNull(line = reader.readLine())) {   
  
  
              lineConsumer.accept(line);   
  
  
          }   
  
  
      } catch (IOException e) {   
  
  
          String message = String.format("读取文件(%s)异常", fileName);   
  
  
          log.error(message, e);   
  
  
          throw new ExampleException(message, e);   
  
  
      }   
  
  
  }   
  
  
     
  
  
  // 使用代码   
  
  
  readLine("example.txt", line -> {   
  
  
      // 处理一行   
  
  
      ...   
  
  
  });

5 消灭不了的样板代码

如果样板代码可以被消灭，那么世界上就不存在样板代码了。即便是上一节提供的减少样板代码方法，也不能完全的消灭样板代码，因为这些样板代码依旧存在于框架和模式的实现中。所以，样板代码是消灭不了的。

既然不能消灭样板代码，那就应该合理地利用样板代码。提炼一段样板代码，若只用二三次，未为简便;若用数十百千次，则极为神速。下面，列举了几种常见Java的样板代码，描述了样板代码在日常编程中如何提炼和使用。

二定义工具类

1 常用定义方式

通常，我们会如下定义工具类：

 
 
 
   
  
  
  /** 例子工具类 */   
  
  
  public class ExampleHelper {   
  
  
      /** 常量值 */   
  
  
      public final static int CONST_VALUE = 123;   
  
  
      /** 求和方法 */   
  
  
      public static int sum(int a, int b) {   
  
  
          return a + b;   
  
  
      }   
  
  
  }

2 存在一些问题

修饰符顺序不规范

通过SonarLint插件扫描，会出现以下问题：

Java语言规范建议使用”static final”，而不是”final static”。请记住这么一条规则：静态常量，静态(static)在前，常量(final)在后。

工具类可以被继承覆盖

如果我们定义一个MyExampleHelper来继承ExampleHelper：

 
 
 
   
  
  
  public class MyExampleHelper extends ExampleHelper {   
  
  
      /** 常量值 */   
  
  
      public static final int CONST_VALUE = 321;   
  
  
     
  
  
      /** 求和方法 */   
  
  
      public static int sum(int a, int b) {   
  
  
          return a * b;   
  
  
      }   
  
  
  }

会发现，MyExampleHelper会对ExampleHelper中的常量和方法进行覆盖，导致我们不知道是不是使用了ExampleHelper中的常量和方法。

对于Apache提供的工具类，很多同学都喜欢定义相同名称的工具类，并让这个工具类继承Apache的工具类，并在这个类中添加自己的实现方法。其实，我是非常不推荐这种做法的，因为你不知道——你调用的是Apache工具类提供的常量和方法，还是被覆盖的常量和方法。最好的办法，就是对工具类添加final关键字，让这个工具类不能被继承和覆盖。

工具类可以被实例化

对于ExampleHelper工具类，我们可以这样使用：

 
 
 
   
  
  
  int value = ExampleHelper.CONST_VALUE;   
  
  
  int sum = ExampleHelper.sum(1, 2);

也可以被这样使用：

 
 
 
   
  
  
  ExampleHelper exampleHelper = new ExampleHelper();   
  
  
  int value = exampleHelper.CONST_VALUE;   
  
  
  int sum = exampleHelper.sum(1, 2);

对于工具类来说，没有必要进行实例化。所以，我们建议添加私有构造方法，并在方法中抛出UnsupportedOperationException(不支持的操作异常)。

3 最佳定义方式

根据以上存在问题及其解决方法，最佳定义的ExampleHelper工具类如下：

 
 
 
   
  
  
  /** 例子工具类 */   
  
  
  public final class ExampleHelper {   
  
  
      /** 常量值 */   
  
  
      public static final int CONST_VALUE = 123;   
  
  
     
  
  
      /** 构造方法 */   
  
  
      private ExampleHelper() {   
  
  
          throw new UnsupportedOperationException();   
  
  
      }   
  
  
     
  
  
      /** 求和方法 */   
  
  
      public static int sum(int a, int b) {   
  
  
          return a + b;   
  
  
      }   
  
  
  }

三定义枚举类

1 常用定义方式

通常，我们会如下定义枚举类：

 
 
 
   
  
  
  /** 例子枚举类 */   
  
  
  public enum ExampleEnum {   
  
  
      /** 枚举相关 */   
  
  
      ONE(1, "one(1)"),   
  
  
      TWO(2, "two(2)"),   
  
  
      THREE(3, "two(3)");   
  
  
     
  
  
      /** 属性相关 */   
  
  
      private Integer value;   
  
  
      private String desc;   
  
  
     
  
  
      /** 构造方法 */   
  
  
      private ExampleEnum(Integer value, String desc) {   
  
  
          this.value = value;   
  
  
          this.desc = desc;   
  
  
      }   
  
  
     
  
  
      /** 获取取值 */   
  
  
      public Integer getValue() {   
  
  
          return value;   
  
  
      }   
  
  
     
  
  
      /** 获取描述 */   
  
  
      public String getDesc() {   
  
  
          return desc;   
  
  
      }   
  
  
  }

2 一些优化建议

修饰符private可缺省

通过SonarLint插件扫描，会出现以下问题：

根据建议，应该删除构造方法前多余的private修饰符。

建议使用基础类型

用包装类型Integer保存枚举取值，本身并没有什么问题。但是，本着能用基础类型就用基础类型的规则，所以建议使用基础类型int。

建议使用final字段

假设，我们要实现一个静态方法，可能一不小心就把枚举值给修改了：

 
 
 
   
  
  
  /** 修改取值 */   
  
  
  public static void modifyValue() {   
  
  
      for (ExampleEnum value : values()) {   
  
  
          value.value++;   
  
  
      }   
  
  
  }

如果调用了modifyValue方法，就会把枚举值修改，导致应用程序出错。为了避免这样的情况出现，我们建议对字段添加final修饰符，从而避免字段值被恶意篡改。

3 最佳定义方式

 
 
 
   
  
  
  /** 例子枚举类 */   
  
  
  public enum ExampleEnum {   
  
  
      /** 枚举相关 */   
  
  
      ONE(1, "one(1)"),   
  
  
      TWO(2, "two(2)"),   
  
  
      THREE(3, "two(3)");   
  
  
     
  
  
      /** 字段相关 */   
  
  
      private final int value;   
  
  
      private final String desc;   
  
  
     
  
  
      /** 构造方法 */   
  
  
      ExampleEnum(int value, String desc) {   
  
  
          this.value = value;   
  
  
          this.desc = desc;   
  
  
      }   
  
  
     
  
  
      /** 获取取值 */   
  
  
      public int getValue() {   
  
  
          return value;   
  
  
      }   
  
  
     
  
  
      /** 获取描述 */   
  
  
      public String getDesc() {   
  
  
          return desc;   
  
  
      }   
  
  
  }

四定义模型类

下面，以定义User(用户)模型类为例，从JavaBean模式、重载构造方法、Builder模式3种方式，来说明模型类的定义方法以及优缺点。

假设：User(用户)模型类共有4个属性——id(标识)、name(名称)、age(年龄)、desc(描述)，其中必填属性为——id(标识)、name(名称)，可填属性为——age(年龄)、desc(描述)。

1 JavaBean模式

JavaBean是一个遵循特定写法的Java类，它通常具有如下特点：

必须具有一个无参的构造方法;
所有属性字段必须是私有的;
所有属性字段必须通过遵循一种命名规范的Getter/Setter方法开放出来。

通过JavaBean模式定义的User(用户)模型类如下：

 
 
 
   
  
  
  /** 用户类 */   
  
  
  public class User {   
  
  
      private Long id;   
  
  
      private String name;   
  
  
      private Integer age;   
  
  
      private String desc;   
  
  
     
  
  
      public Long getId() {return id;}   
  
  
      public void setId(Long id) {this.id = id;}   
  
  
      public String getName() {return name;}   
  
  
      public void setName(String name) {this.name = name;}   
  
  
      public Integer getAge() {return age;}   
  
  
      public vid setAge(Integer age) {this.age = age;}   
  
  
      public String getDesc() {return desc;}   
  
  
      public void setDesc(String desc) {this.desc = desc;}   
  
  
  }

注意：也可以通过Lombok的@Getter/@Setter注解生成对应个Getter/Setter方法。

使用代码：

 
 
 
   
  
  
  User user = new User();   
  
  
  user.setId(1L);   
  
  
  user.setName("alibaba");   
  
  
  user.setAge(102);   
  
  
  user.setDesc("test");   
  
  
  verifyUser(user);

主要优点：

代码非常简单，只有私有属性字段及其公有Getter/Setter方法;
赋值对象代码可读性较强，明确地知道哪个属性字段对应哪个值;
非常简单实用，被广泛地用于HSF、Dubbo、MyBatis等中间件。

主要缺点：

由于可以通过Setter方法设置属性字段，所以不能定义为不可变类;
由于每个字段分别设置，所以不能保证字段必填，必须设置完毕后进行统一验证。

2 重载构造方法

通过”重载构造方法”定义User(用户)模型类如下：

 
 
 
   
  
  
  /** 用户类 */   
  
  
  public final class User {   
  
  
      private Long id;   
  
  
      private String name;   
  
  
      private Integer age;   
  
  
      private String desc;   
  
  
     
  
  
      public User(Long id, String name) {   
  
  
          this(id, name, null);   
  
  
      }   
  
  
      public User(Long id, String name, Integer age) {   
  
  
          this(id, name, age, null);   
  
  
      }   
  
  
      public User(Long id, String name, Integer age, String desc) {   
  
  
          Assert.notNull(id, "标识不能为空");   
  
  
          Assert.notNull(name, "名称不能为空");   
  
  
          this.id = id;   
  
  
          this.name = name;   
  
  
          this.age = age;   
  
  
          this.desc = desc;   
  
  
      }   
  
  
     
  
  
      public Long getId() {return id;}   
  
  
      public String getName() {return name;}   
  
  
      public Integer getAge() {return age;}   
  
  
      public String getDesc() {return desc;}   
  
  
  }

使用代码：

 
 
 
   
  
  
  User user1 = new User(1L, "alibaba");   
  
  
     
  
  
  User user2 = new User(1L, "alibaba", 102, "test");

主要优点：

初始化对象代码简洁，只有简单的一行代码;
可以定义为不可变类，初始化后属性字段值不可变更;
可以在构造方法内进行不可空验证。

主要缺点：

重载构造方法数量过多，无法覆盖必填字段和非必填字段的所有组合;
初始化对象代码可读性差，无法看出哪个属性字段对应哪个值;
如果删除某个字段，初始化对象代码可能不会报错，导致出现赋值错误问题。

3 Builder模式

 
 
 
   
  
  
  /** 用户类 */   
  
  
  public final class User {   
  
  
      private Long id;   
  
  
      private String name;   
  
  
      private Integer age;   
  
  
      private String desc;   
  
  
     
  
  
      private User(Builder builder) {   
  
  
          this.id = builder.id;   
  
  
          this.name = builder.name;   
  
  
          this.age = builder.age;   
  
  
          this.desc = builder.desc;   
  
  
      }   
  
  
      public static Builder newBuilder(Long id, String name) {   
  
  
          return new Builder(id, name);   
  
  
      }   
  
  
     
  
  
      public Long getId() {return id;}   
  
  
      public String getName() {return name;}   
  
  
      public Integer getAge() {return age;}   
  
  
      public String getDesc() {return desc;}   
  
  
     
  
  
      public static class Builder {   
  
  
          private Long id;   
  
  
          private String name;   
  
  
          private Integer age;   
  
  
          private String desc;   
  
  
     
  
  
          private Builder(Long id, String name) {   
  
  
              Assert.notNull(id, "标识不能为空");   
  
  
              Assert.notNull(name, "名称不能为空");   
  
  
              this.id = id;   
  
  
              this.name = name;   
  
  
          }   
  
  
          public Builder age(Integer age) {   
  
  
              this.age = age;   
  
  
              return this;   
  
  
          }   
  
  
          public Builder desc(String desc) {   
  
  
              this.desc = desc;   
  
  
              return this;   
  
  
          }   
  
  
          public User build() {   
  
  
              return new User(this);   
  
  
          }   
  
  
      }   
  
  
  }

注意：可以采用Lombok的@Builder注解简化代码。

使用代码：

 
 
 
   
  
  
  User user = User.newBuilder(1L, "alibaba").age(102).desc("test").build();

主要优点：

明确了必填参数和可选参数，在构造方法中进行验证;
可以定义为不可变类，初始化后属性字段值不可变更;
赋值代码可读性较好，明确知道哪个属性字段对应哪个值;
支持链式方法调用，相比于调用Setter方法，代码更简洁。

主要缺点：

代码量较大，多定义了一个Builder类，多定义了一套属性字段，多实现了一套赋值方法;
运行效率低，需要先创建Builder实例，再赋值属性字段，再创建目标实例，最后拷贝属性字段。

五定义集合常量

在编码中，经常使用到各种集合常量，比如List(列表)常量、Set(集合)常量、Map(映射)常量等。

1 普通定义方式

定义代码：

最简单的方法，就是直接定义一个普通的集合常量。

 
 
 
   
  
  
  /** 例子工具类 */   
  
  
  public final class ExampleHelper {   
  
  
      /** 常量值列表 */   
  
  
      public static final List CONST_VALUE_LIST = Arrays.asList(1, 2, 3);   
  
  
      /** 常量值集合 */   
  
  
      public static final Set CONST_VALUE_SET = new HashSet<>(Arrays.asList(1, 2, 3));   
  
  
      /** 常量值映射 */   
  
  
      public static final Map CONST_VALUE_MAP;   
  
  
      static {   
  
  
          CONST_VALUE_MAP = new HashMap<>(MapHelper.DEFAULT);   
  
  
          CONST_VALUE_MAP.put(1, "value1");   
  
  
          CONST_VALUE_MAP.put(2, "value2");   
  
  
          CONST_VALUE_MAP.put(3, "value3");   
  
  
      }   
  
  
      ...   
  
  
  }

使用代码：

使用也很方便，直接通过”类名.常量名”使用。

 
 
 
   
  
  
  // 使用常量值集合   
  
  
  List constValueList = ExampleHelper.CONST_VALUE_LIST;   
  
  
  Set constValueSet = ExampleHelper.CONST_VALUE_SET;   
  
  
  Map constValueMap = ExampleHelper.CONST_VALUE_MAP

2 存在主要问题

通过SonarLint插件扫描，会出现以下问题：

由于普通的集合对象(如ArrayList、HashMap、HashSet等)都是可变集合对象，即便是定义为静态常量，也可以通过操作方法进行修改。所以，上面方法定义的集合常量，并不是真正意义上的集合常量。其中，Arrays.asList方法生成的内部ArrayList不能执行add/remove/clear方法，但是可以set方法，也属于可变集合对象。

 
 
 
   
  
  
  // 操作常量列表   
  
  
  ExampleHelper.CONST_VALUE_LIST.remove(3); // UnsupportedOperationException   
  
  
  ExampleHelper.CONST_VALUE_LIST.add(4); // UnsupportedOperationException   
  
  
  ExampleHelper.CONST_VALUE_LIST.set(1, 20); // [1,20,3]   
  
  
  ExampleHelper.CONST_VALUE_LIST.clear(); // UnsupportedOperationException   
  
  
     
  
  
  // 操作常量集合   
  
  
  ExampleHelper.CONST_VALUE_SET.remove(3); // [1,2]   
  
  
  ExampleHelper.CONST_VALUE_SET.add(3); // [1,2,3]   
  
  
  ExampleHelper.CONST_VALUE_SET.clear(); // []   
  
  
     
  
  
  // 操作常量映射   
  
  
  ExampleHelper.CONST_VALUE_MAP.remove(3); // {1:"value1",2:"value2"}   
  
  
  ExampleHelper.CONST_VALUE_MAP.put(3, "value3"); // {1:"value1",2:"value2",3:"value3"}   
  
  
  ExampleHelper.CONST_VALUE_MAP.clear(); // []

3 最佳定义方式

在JDK中，Collections工具类中提供一套方法，用于把可变集合对象变为不可变(不可修改，修改时会抛出UnsupportedOperationException异常)集合对象。所以，可以利用这套方法定义集合静态常量。

 
 
 
   
  
  
  /** 例子工具类 */   
  
  
  public final class ExampleHelper {   
  
  
      /** 常量值列表 */   
  
  
      public static final List CONST_VALUE_LIST = Collections.unmodifiableList(Arrays.asList(1, 2, 3));   
  
  
      /** 常量值集合 */   
  
  
      public static final Set CONST_VALUE_SET = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(1, 2, 3)));   
  
  
      /** 常量值映射 */   
  
  
      public static final Map CONST_VALUE_MAP;   
  
  
      static {   
  
  
          Map valueMap = new HashMap<>(MapHelper.DEFAULT);   
  
  
          valueMap.put(1, "value1");   
  
  
          valueMap.put(2, "value2");   
  
  
          valueMap.put(3, "value3");   
  
  
          CONST_VALUE_MAP = Collections.unmodifiableMap(valueMap);   
  
  
      }   
  
  
      ...   
  
  
  }

六定义数组常量

上一章介绍了如何定义集合常量，这一章就来介绍一下如何定义数组常量。

1 定义公有数组常量

定义代码：

一般人定义数组常量，就会像下面代码一样，定义一个公有数组常量。

 
 
 
   
  
  
  /** 例子工具类 */   
  
  
  public final class ExampleHelper {   
  
  
      /** 常量值数组 */   
  
  
      public static final int[] CONST_VALUES = new int[] {1, 2, 3};   
  
  
      ...   
  
  
  }

使用代码：

使用也很方便，直接通过”类名.常量名”使用。

 
 
 
   
  
  
  // 使用常量值数组   
  
  
  int[] constValues = ExampleHelper.CONST_VALUES;

存在问题：

但是，可以通过下标修改数组值，导致数组常量的值可变。所以，这种方法定义的数组常量，并不是一个真正意义上的数组常量。

 
 
 
   
  
  
  // 修改常量值数组   
  
  
  ExampleHelper.CONST_VALUES[1] = 20; // [1, 20, 3]

2 定义公有集合常量

定义代码：

可以通过上一章定义集合常量的方法，返回一个公有集合常量。

 
 
 
   
  
  
  /** 例子工具类 */   
  
  
  public final class ExampleHelper {   
  
  
      /** 常量值列表 */   
  
  
      public static final List CONST_VALUE_LIST =   
  
  
          Collections.unmodifiableList(Arrays.asList(1, 2, 3));   
  
  
      ...   
  
  
  }

使用代码：

要想得到数组常量，就把集合常量转化为数组常量。

 
 
 
   
  
  
  // 使用常量值列表   
  
  
  int[] constValues = ExampleHelper.CONST_VALUE_LIST.stream()   
  
  
      .mapToInt(Integer::intValue).toArray();

存在问题：

每一次都会把集合常量转化为数组常量，导致程序运行效率降低。

3 最佳定义方式

最佳法”私有数组常量+公有克隆方法”的解决方案。如下代码所示：先定义一个私有数组常量，保证不会被外部类使用;在定义一个获取数组常量方法，并返回一个数组常量的克隆值。

定义代码：

这里，提供一个”私有数组常量+公有克隆方法”的解决方案。如下代码所示：先定义一个私有数组常量，保证不会被外部类使用;在定义一个获取数组常量方法，并返回一个数组常量的克隆值。

 
 
 
   
  
  
  /** 例子工具类 */   
  
  
  public final class ExampleHelper {   
  
  
      /** 常量值数组 */   
  
  
      private static final int[] CONST_VALUES = new int[] {1, 2, 3};   
  
  
      /** 获取常量值数组方法 */   
  
  
      public static int[] getConstValues() {   
  
  
          return CONST_VALUES.clone();   
  
  
      }   
  
  
      ...   
  
  
  }

使用代码：

由于每次返回的是一个克隆数组，即便修改了克隆数组的常量值，也不会导致原始数组常量值的修改。

 
 
 
   
  
  
  // 使用常量值方法   
  
  
  int[] constValues = ExampleHelper.getConstValues(); // [1, 2, 3]   
  
  
  constValues[1] = 20; // [1, 20, 3]   
  
  
  constValues = ExampleHelper.getConstValues(); // [1, 2, 3]

七定义多条件表达式

1 利用运算符&&(或||)直接拼接

定义代码：

有时候，我们会判断很多条件，需求用&&(或||)连接多个条件表达式。

 
 
 
   
  
  
  /** 获取审核结果方法 */   
  
  
  private static Integer getAuditResult(AuditDataVO data) {   
  
  
      if (isPassed(data.getAuditItem1())   
  
  
          && isPassed(data.getAuditItem2())   
  
  
          ...   
  
  
          && isPassed(data.getAuditItem11())) {   
  
  
          return AuditResult.PASSED;   
  
  
      }   
  
  
      return AuditResult.REJECTED;   
  
  
  }

存在问题：

通过SonarLint插件扫描，会存在2个问题：

其中，圈复杂度(Cyclomatic complexity，CC)也称为条件复杂度，是一种衡量代码复杂度的标准，其符号为V(G)。

麦凯布最早提出一种称为“基础路径测试”(Basis Path Testing)的软件测试方式，测试程序中的每一线性独立路径，所需的测试用例个数即为程序的圈复杂度。

圈复杂度可以用来衡量一个模块判定结构的复杂程度，其数量上表现为独立路径的条数，也可理解为覆盖所有的可能情况最少使用的测试用例个数。

2 利用运算符=和&&(或||)级联拼接

定义代码：

那么，就把&&(或||)连接符拆开，利用运算符=和&&(或||)级联进行拼接。

 
 
 
   
  
  
  /** 获取审核结果方法 */   
  
  
  private static AuditResult getAuditResult(AuditDataVO data) {   
  
  
      boolean isPassed = isPassed(data.getAuditItem1());   
  
  
      isPassed = isPassed && isPassed(data.getAuditItem2());   
  
  
      ...   
  
  
      isPassed = isPassed && isPassed(data.getAuditItem11());   
  
  
      if (isPassed) {   
  
  
          return AuditResult.PASSED;   
  
  
      }   
  
  
      return AuditResult.REJECTED;   
  
  
  }

存在问题：

通过SonarLint插件扫描，还存在1个问题：

也就是，利用运算符=和&&(或||)级联进行拼接，并不能减少方法的圈复杂度。

3 利用动态无参数Lambda表达式列表

定义代码：

下面，利用动态无参数Lambda表达式列表优化，即把每个条件表达式作为BooleanSupplier对象存在列表中，然后依次执行条件表达式得出最后结果。

 
 
 
   
  
  
  /** 获取审核结果方法 */   
  
  
  private static AuditResult getAuditResult(AuditDataVO data) {   
  
  
      List supplierList = new ArrayList<>();   
  
  
      supplierList.add(() -> isPassed(data.getAuditItem1()));   
  
  
      supplierList.add(() -> isPassed(data.            
                网页题目：Java编程技巧之样板代码
                

                当前链接：http://www.csdahua.cn/qtweb/news44/437894.html
            
            
                网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
            
                广告
                
            
            
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                快上网

成都快上网为您推荐相关内容

Java编程技巧之样板代码

前言

一 样板代码简介

1 什么是样板代码?

2 样板代码有什么用?

3 如何编写样板代码?

4 如何减少样板代码?

5 消灭不了的样板代码

二 定义工具类

1 常用定义方式

2 存在一些问题

3 最佳定义方式

三 定义枚举类

1 常用定义方式

2 一些优化建议

3 最佳定义方式

四 定义模型类

1 JavaBean模式

2 重载构造方法

3 Builder模式

五 定义集合常量

1 普通定义方式

2 存在主要问题

3 最佳定义方式

六 定义数组常量

1 定义公有数组常量

2 定义公有集合常量

3 最佳定义方式

七 定义多条件表达式

1 利用运算符&&(或||)直接拼接

2 利用运算符=和&&(或||)级联拼接

3 利用动态无参数Lambda表达式列表

一样板代码简介

二定义工具类

三定义枚举类

四定义模型类

五定义集合常量

六定义数组常量

七定义多条件表达式