编写java的软件叫什么(java编程代码大全)

编写java的软件叫什么(java编程代码大全)

提供一种标准样例:可以用于新人学习,能够快速上手并使用;

提供一种解决方案:遇到类似案例时,可以快速利用该方案进行解决;

有助于不断积累经验:当发现一种样例代码时,都会不断地进行优化,力求达到最佳样例;

有助于提高代码质量:样板代码必然通过了时间考验,存在BUG和出错的几率相对比较低;

有助于提高编码速度:利用样板代码编码,只是复制粘贴修改代码,编码速度大幅提高;

有助于统一代码样式:心中有了样板代码,就能保证每次都写出统一样式的代码。

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

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

用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@Setterpublic class User { private Long id; …}利用框架减少样板代码比如,MyBatis 是一款优秀的持久层框架,封装了获取数据库连接和声明、设置参数、获取结果集等所有JDBC操作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。原始代码:/** 查询公司员工 */public List<EmployeeDO> 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<EmployeeDO> 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@Mapperpublic interface UserDAO { List<EmployeeDO> queryEmployee(@Param(“companyId”) Long companyId);}2)UserDAO.xml<mapper namespace=”com.example.repository.UserDAO”> <select id=”queryEmployee” resultType=”com.example.repository.UserDO”> select id , name … from t_user where company_id = #{companyId} </select></mapper>利用设计模式减少样板代码利用设计模式,可以把一些重复性代码进行封装。比如,上面的读取文件行模式代码,就可以用模板方法进行封装。原始代码: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<String> 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<Integer> CONST_VALUE_LIST = Arrays.asList(1, 2, 3); /** 常量值集合 */ public static final Set<Integer> CONST_VALUE_SET = new HashSet<>(Arrays.asList(1, 2, 3)); /** 常量值映射 */ public static final Map<Integer, String> 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<Integer> constValueList = ExampleHelper.CONST_VALUE_LIST;Set<Integer> constValueSet = ExampleHelper.CONST_VALUE_SET;Map<Integer, String> constValueMap = ExampleHelper.CONST_VALUE_MAP2 存在主要问题通过SonarLint插件扫描,会出现以下问题:

由于普通的集合对象(如ArrayList、HashMap、HashSet等)都是可变集合对象,即便是定义为静态常量,也可以通过操作方法进行修改。所以,上面方法定义的集合常量,并不是真正意义上的集合常量。其中,Arrays.asList方法生成的内部ArrayList不能执行add/remove/clear方法,但是可以set方法,也属于可变集合对象。// 操作常量列表ExampleHelper.CONST_VALUE_LIST.remove(3); // UnsupportedOperationExceptionExampleHelper.CONST_VALUE_LIST.add(4); // UnsupportedOperationExceptionExampleHelper.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<Integer> CONST_VALUE_LIST = Collections.unmodifiableList(Arrays.asList(1, 2, 3)); /** 常量值集合 */ public static final Set<Integer> CONST_VALUE_SET = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(1, 2, 3))); /** 常量值映射 */ public static final Map<Integer, String> CONST_VALUE_MAP; static { Map<Integer, String> 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<Integer> 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<BooleanSupplier> supplierList = new ArrayList<>(); supplierList.add(() -> isPassed(data.getAuditItem1())); supplierList.add(() -> isPassed(data.getAuditItem2())); … supplierList.add(() -> isPassed(data.getAuditItem11())); for (BooleanSupplier supplier : supplierList) { if (!supplier.getAsBoolean()) { return AuditResult.REJECTED; } } return AuditResult.PASSED;}存在问题:通过SonarLint插件扫描,没有提示任何问题。但是,每次都动态添加Lambda表达式,就会导致程序效率低下。那么,有没有把Lambda表达式静态化的方法呢?4 利用静态有参数Lambda表达式列表定义代码:要想固化Lambda表达式,就必须动态传入AuditDataVO对象。这里,采用Predicate<AuditDataVO>来接收Lambda表达式,在Lambda表达式中指定AuditDataVO对象data。然后,在for循环中,依次指定AuditDataVO对象data,并计算表达式的值。/** 审核结果断言列表 */private static final List<Predicate<AuditDataVO>> AUDIT_RESULT_PREDICATE_LIST = Collections.unmodifiableList(Arrays.asList( data -> isPassed(data.getAuditItem1()), data -> isPassed(data.getAuditItem2()), … data -> isPassed(data.getAuditItem11())));/** 获取审核结果方法 */private static AuditResult getAuditResult(AuditDataVO data) { for (Predicate<AuditDataVO> predicate : AUDIT_RESULT_PREDICATE_LIST) { if (!predicate.test(data)) { return AuditResult.REJECTED; } } return AuditResult.PASSED;}适用条件:

适合于&&(或||)连接大量条件表达式的情况;

适合于每个条件表达式都需要传入相同参数的情况,如果每个条件表达式传入参数不同,只能使用动态无参数Lambda表达式列表方法;

如果需要传入两个参数,可以使用BiPredicate类型来接收Lambda表达式;如果需要传入多个参数,则需要自定义方法接口。

后记明代思想家王阳明在《传习录》中说道:初种根时,只管栽培灌溉,勿作枝想,勿作叶想,勿作花想,勿作实想。悬想何益?但不忘栽培之功,怕没有枝叶花实?这也是我们高德研发团队的人才宗旨——不论学历、不论经历、不论年龄、不论性别,只要有缘来到我们的团队,我们都将一视同仁地“栽培灌溉”;力求让每一个新人都能够茁壮成长,绽放出最完美的“枝叶花实”。我们诚聘各类优秀人才:Java工程师、C 工程师、算法工程师、前端工程师、客户端工程师。欢迎大家投简历到gdtech@alibaba-inc.com,邮件标题格式为“姓名-技术方向-来自阿里技术”。

免费领取电子书

《高德技术2020年刊合辑》

高德技术重磅发布《高德技术2020年刊合辑》电子书,覆盖了大前端、算法、架构、汽车工程、质量等多个领域,以及数篇高德入选顶会论文的解读,分享高德在智慧出行上的最佳技术实践和总结。

发表评论

登录后才能评论