《代码整洁之道》第14章 逐步改进 的代码片段

已于 2022-04-14 00:09:52 修改
阅读量509 收藏 4
点赞数 1
分类专栏： 笔记 Java基础 文章标签： java
于 2022-04-14 00:09:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l751475472/article/details/124161333
版权

由于没有纸质书或pdf没有代码，不在编辑器里看代码，实在难看懂。所以跟着写了一遍。代码不完全一样，没有单元测试，不保证没问题。大概可以一用吧。

代码14-9

package com.example.demo.args;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

/**
 * 代码清单 14-9 一个早期版本代码，只支持Boolean 参数
 */
public class Args149 {
    private String schema;
    private String[] args;
    private boolean valid;
    private Set<Character> unexpectArguments = new TreeSet<>();
    private Map<Character, Boolean> booleanArgs = new HashMap<>();
    private int numberOfArguments = 0;

    public Args149(String schema, String[] args) {
        this.schema = schema;
        this.args = args;
        valid = parse();
    }

    public boolean getBoolean(char arg) {
        return booleanArgs.get(arg);//TODO 校验key是否存在，不存在：给提示（抛错太不友好；了）
    }

    public int cardinality() {
        return numberOfArguments;
    }

    public String usage() {
        if (schema.length() > 0)
            return "-[" + schema + "]";
        else
            return "";
    }

    public String errorMessage() {
        if (unexpectArguments.size() > 0)
            return unexpectArgumentsMessage();
        else
            return "";
    }

    public boolean isValid() {
        return valid;
    }

    private boolean parse() {
        if (schema.length() == 0 && args.length == 0) return true;
        parseSchema();
        parseArguments();
        return unexpectArguments.size() == 0;
    }

    private boolean parseSchema() {
        for (String element : schema.split(",")) {
            parseSchemaElement(element);
        }
        return true;
    }

    private void parseSchemaElement(String element) {
        if (element.length() == 1) {
            parseBooleanSchemaElement(element);
        }
    }


    private void parseBooleanSchemaElement(String element) {
        char c = element.charAt(0);
        if (Character.isLetter(c)) {
            booleanArgs.put(c, false);
        }
    }

    private boolean parseArguments() {
        for (String arg : args)
            parseArgument(arg);
        return true;
    }

    private void parseArgument(String arg) {
        if (arg.startsWith("-")) {
            parseElements(arg);
        }
    }

    private void parseElements(String arg) {
        for (int i = 1; i < arg.length(); i++) {
            parseElement(arg.charAt(i));
        }
    }

    private void parseElement(char argChar) {
        if (isBoolean(argChar)) {
            numberOfArguments++;
            setBooleanArg(argChar, true);
        } else
            unexpectArguments.add(argChar);
    }

    private void setBooleanArg(char argChar, boolean value) {
        booleanArgs.put(argChar, value);
    }

    private boolean isBoolean(char argChar) {
        return booleanArgs.containsKey(argChar);
    }

    private String unexpectArgumentsMessage() {
        StringBuffer message = new StringBuffer("Argument(s) -");
        for (Character c : unexpectArguments) {
            message.append(c);
        }
        message.append("  unexpected.");
        return message.toString();
    }

}

代码14-10

package com.example.demo.args;

import java.text.ParseException;
import java.util.*;

/**
 * 代码清单 14-10
 */
public class Args1410 {
    private String schema;
    private String[] args;
    private boolean valid = true;
    private Set<Character> unexpectArguments = new TreeSet<>();
    private Map<Character, Boolean> booleanArgs = new HashMap<>();
    private Map<Character, String> stringArgs = new HashMap<>();
    private Set<Character> argsFound = new HashSet<>();
    private int currentArgument;
    private char errorArgument = '\0';

    enum ErrorCode {
        OK, MISSING_STRING
    }

    private ErrorCode errorCode = ErrorCode.OK;

    private int numberOfArguments = 0;


    public Args1410(String schema, String[] args) throws ParseException {
        this.schema = schema;
        this.args = args;
        valid = parse();
    }

    private boolean parse() throws ParseException {
        if (schema.length() == 0 && args.length == 0) return true;
        parseSchema();
        parseArguments();
        return valid;
    }

    private boolean parseSchema() throws ParseException {
        for (String element : schema.split(",")) {
            if (element.length() > 0) {
                String trimElement = element.trim();
                parseSchemaElement(trimElement);
            }
        }
        return true;
    }

    private void parseSchemaElement(String element) throws ParseException {
        char elementId = element.charAt(0);
        String elementTail = element.substring(1);
        validateSchemaElementId(elementId);
        if (isBooleanSchemaElement(elementTail))
            parseBooleanSchemaElement(elementId);
        else if (isStringSchemaElement(elementTail))
            parseStringSchemaElement(elementId);
    }

    private void validateSchemaElementId(char elementId) throws ParseException {
        if (!Character.isLetter(elementId)) {
            throw new ParseException("Bad character:" + elementId + "in Args format: " + schema, 0);
        }
    }

    private boolean isBooleanSchemaElement(String elementTail) {
        return elementTail.length() == 0;
    }

    private boolean isStringSchemaElement(String elementTail) {
        return "*".equals(elementTail);
    }

    private void parseBooleanSchemaElement(char elementId) {
        booleanArgs.put(elementId, false);
    }

    private void parseStringSchemaElement(char elementId) {
        stringArgs.put(elementId, "");
    }

    private boolean parseArguments() {
        for (currentArgument = 0; currentArgument < args.length; currentArgument++) {
            String arg = args[currentArgument];
            parseArgument(arg);
        }
        return true;
    }

    private void parseArgument(String arg) {
        if (arg.startsWith("-")) {
            parseElements(arg);
        }
    }

    private void parseElements(String arg) {
        for (int i = 1; i < arg.length(); i++) {
            parseElement(arg.charAt(i));
        }
    }

    private void parseElement(char argChar) {
        if (setArgument(argChar)) {
            argsFound.add(argChar);
        } else {
            unexpectArguments.add(argChar);
            valid = false;
        }
    }

    private boolean setArgument(char argChar) {
        boolean set = true;
        if (isBoolean(argChar))
            setBooleanArg(argChar, true);
        else if (isString(argChar))
            setStringArg(argChar);
        else
            set = false;
        return set;
    }

    private void setBooleanArg(char argChar, boolean value) {
        booleanArgs.put(argChar, value);
    }

    private void setStringArg(char argChar) {
        currentArgument++;
        try {
            stringArgs.put(argChar, args[currentArgument]);
        } catch (ArrayIndexOutOfBoundsException e) {
            valid = false;
            errorArgument = argChar;
            errorCode = ErrorCode.MISSING_STRING;
        }
    }

    private boolean isBoolean(char argChar) {
        return booleanArgs.containsKey(argChar);
    }

    private boolean isString(char argChar) {
        return stringArgs.containsKey(argChar);
    }

    public int cardinality() {
        return argsFound.size();
    }

    public String usage() {
        if (schema.length() > 0)
            return "-[" + schema + "]";
        else
            return "";
    }

    public String errorMessage() throws Exception {
        if (unexpectArguments.size() > 0)
            return unexpectArgumentsMessage();
        else
            switch (errorCode) {
                case MISSING_STRING:
                    return String.format("Could not find string paramenter for -%c.", errorArgument);
                case OK:
                    throw new Exception("TILT: should not get here.");
            }
        return "";

    }

    private String unexpectArgumentsMessage() {
        StringBuffer message = new StringBuffer("Argument(s) -");
        for (Character c : unexpectArguments) {
            message.append(c);
        }
        message.append("  unexpected.");
        return message.toString();
    }

    public boolean getBoolean(char arg) {
        return falseIfNull(booleanArgs.get(arg));
    }

    private boolean falseIfNull(Boolean b) {
        return b == null ? false : b;
    }

    public String getString(char arg) {
        return blankIfNull(stringArgs.get(arg));
    }

    public String blankIfNull(String s) {
        return s == null ? "" : s;
    }

    public boolean has(char arg) {
        return argsFound.contains(arg);
    }

    public boolean isValid() {
        return valid;
    }

}

基本上算完成的代码：
Args1411

package com.example.demo.args;

import com.example.demo.args.marshaler.ArgumentMarshaler;
import com.example.demo.args.marshaler.BooleanArgumentMarshaler;
import com.example.demo.args.marshaler.IntegerArgumentMarshaler;
import com.example.demo.args.marshaler.StringArgumentMarshaler;

import java.text.ParseException;
import java.util.*;

public class Args1411 {
    private String schema;
    private List<String> argsList;
    private boolean valid = true;
    private Set<Character> unexpectArguments = new TreeSet<>();
    private Map<Character, ArgumentMarshaler> argumentMarshaler = new HashMap<>();
    private Set<Character> argsFound = new HashSet<>();
    private Iterator<String> currentArgument;
    private ArgsException.ErrorCode errorCode = ArgsException.ErrorCode.OK;


    public Args1411(String schema, String[] args) throws ParseException {
        this.schema = schema;
        this.argsList = Arrays.asList(args);
        valid = parse();
    }

    private boolean parse() throws ParseException {
        if (schema.length() == 0 && argsList.size() == 0) return true;
        parseSchema();
        parseArguments();
        return valid;
    }

    private boolean parseSchema() throws ParseException {
        for (String element : schema.split(",")) {
            if (element.length() > 0) {
                String trimElement = element.trim();
                parseSchemaElement(trimElement);
            }
        }
        return true;
    }

    private void parseSchemaElement(String element) throws ParseException {
        char elementId = element.charAt(0);
        String elementTail = element.substring(1);
        validateSchemaElementId(elementId);
        if (elementTail.length() == 0)
            argumentMarshaler.put(elementId, new BooleanArgumentMarshaler());
        else if ("*".equals(elementTail))
            argumentMarshaler.put(elementId, new StringArgumentMarshaler());
        else if ("#".equals(elementTail))
            argumentMarshaler.put(elementId, new IntegerArgumentMarshaler());

    }

    private void validateSchemaElementId(char elementId) throws ParseException {
        if (!Character.isLetter(elementId)) {
            throw new ParseException("Bad character:" + elementId + "in Args format: " + schema, 0);
        }
    }

    private boolean parseArguments() {
        for (currentArgument = argsList.iterator(); currentArgument.hasNext(); ) {
            String arg = currentArgument.next();
            parseArgument(arg);
        }
        return true;
    }

    private void parseArgument(String arg) {
        if (arg.startsWith("-")) {
            parseElements(arg);
        }
    }

    private void parseElements(String arg) {
        for (int i = 1; i < arg.length(); i++) {
            parseElement(arg.charAt(i));
        }
    }

    private void parseElement(char argChar) {
        if (setArgument(argChar)) {
            argsFound.add(argChar);
        } else {
            unexpectArguments.add(argChar);
            valid = false;
        }
    }

    private boolean setArgument(char argChar) {
        boolean set = true;
        ArgumentMarshaler marshaler = this.argumentMarshaler.get(argChar);
        if (marshaler == null) return false;
        try {
            marshaler.set(currentArgument);
        } catch (ArgsException e) {
            errorCode = e.getErrorCode();
            valid = false;
        }
        return set;
    }

    public int cardinality() {
        return argsFound.size();
    }

    public String usage() {
        if (schema.length() > 0)
            return "-[" + schema + "]";
        else
            return "";
    }

    public String errorMessage() throws Exception {
        if (unexpectArguments.size() > 0)
            return unexpectArgumentsMessage();
        else
            switch (errorCode) {
                case MISSING_STRING:
                    return "Could not find string paramenter for -%c.";
                //其他的省略
                case OK:
                    throw new Exception("TILT: should not get here.");
            }
        return "";

    }

    private String unexpectArgumentsMessage() {
        StringBuffer message = new StringBuffer("Argument(s) -");
        for (Character c : unexpectArguments) {
            message.append(c);
        }
        message.append("  unexpected.");
        return message.toString();
    }

    public boolean getBoolean(char arg) {
        ArgumentMarshaler am = argumentMarshaler.get(arg);
        boolean b;
        try {
            b = am != null && (boolean) am.get();
        } catch (ClassCastException e) {
            b = false;
        }
        return b;
    }


    public String getString(char arg) {
        ArgumentMarshaler am = argumentMarshaler.get(arg);
        return am == null ? "" : (String) am.get();
    }

    public String blankIfNull(String s) {
        return s == null ? "" : s;
    }

    public Integer getInteger(char arg) {
        ArgumentMarshaler am = argumentMarshaler.get(arg);
        return am == null ? 0 : (Integer) am.get();
    }

    public boolean has(char arg) {
        return argsFound.contains(arg);
    }

    public boolean isValid() {
        return valid;
    }
}

ArgumentMarshaler

package com.example.demo.args.marshaler;

import com.example.demo.args.ArgsException;

import java.util.Iterator;

public abstract class ArgumentMarshaler {

    public abstract void set(Iterator<String> integerValue) throws ArgsException;

    public abstract Object get();
}

BooleanArgumentMarshaler

package com.example.demo.args.marshaler;

import java.util.Iterator;

public class BooleanArgumentMarshaler extends ArgumentMarshaler {

    private boolean booleanValue = false;

    public void set(Iterator<String> currentArgument) {
        booleanValue = true;
    }

    public Object get() {
        return booleanValue;
    }
}

IntegerArgumentMarshaler

package com.example.demo.args.marshaler;

import com.example.demo.args.ArgsException;

import java.util.Iterator;

public class IntegerArgumentMarshaler extends ArgumentMarshaler {
    private Integer integerValue;

    public void set(Iterator<String> currentArgument) throws ArgsException {
        try {
            this.integerValue = Integer.valueOf(currentArgument.next());
        } catch (NumberFormatException e) {
            throw new ArgsException(ArgsException.ErrorCode.INALID_INTEGER);
        }
    }

    public Object get() {
        return integerValue == null ? 0 : integerValue;
    }
}

StringArgumentMarshaler

package com.example.demo.args.marshaler;

import com.example.demo.args.ArgsException;

import java.util.Iterator;

public class StringArgumentMarshaler extends ArgumentMarshaler {
    private String stringValue;

    public void set(Iterator<String> currentArgument) throws ArgsException {
        try {
            this.stringValue = currentArgument.next();
        } catch (ArrayIndexOutOfBoundsException e) {
            throw new ArgsException(ArgsException.ErrorCode.MISSING_STRING);
        } catch (ClassCastException e) {
            throw new ArgsException(ArgsException.ErrorCode.INALID_STRING);
        }
    }

    public String get() {
        return stringValue == null ? "" : stringValue;
    }
}

ArgsException

package com.example.demo.args;

public class ArgsException extends Exception {
    private char errorArgument = '\0';
    private String errorParameter = "TILT";

    private ErrorCode errorCode = ErrorCode.OK;

    public ErrorCode getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(ErrorCode errorCode) {
        this.errorCode = errorCode;
    }

    public ArgsException() {
    }

    public ArgsException(String message) {
        super(message);
    }

    public ArgsException(ErrorCode errorCode) {
        this.errorCode = errorCode;
    }

    public enum ErrorCode {
        OK, MISSING_STRING, MISSING_INTEGER,
        INALID_INTEGER, INALID_STRING, UNEXPECTED_ARGUMENT;

    }
}

Args1410Test

package com.example.demo.args;

import java.text.ParseException;

/**
 * description
 *
 * @author lilei
 * @date 2022/4/12 16:32
 */
public class Args1410Test {
    public static void main(String[] args) throws Exception {
        Args1410 args1410 = null;
        String[] args2 = new String[]{"-b", "-s", "A", "-S", "B", "c"};
        try {
            args1410 = new Args1410("b,s*,S*", args2);
        } catch (ParseException e) {
            System.out.println(e.getMessage());
        }
        System.out.printf("usage:%s", args1410.usage());
        System.out.println();
        System.out.printf("boolean:%b", args1410.getBoolean('b'));
        System.out.println();
        System.out.printf("String:%s", args1410.getString('s'));
        System.out.println();
        System.out.printf("String:%s", args1410.getString('S'));
        System.out.println();
        System.out.printf("isValid:%s", args1410.isValid());
        System.out.println();
        System.out.printf("errorMessage:%s", args1410.errorMessage());
    }
}
逗你玩儿2333
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码整洁之道内容概括
02-01
一个偶然的机会读了代码整洁之道，觉得这本书写的很好，所以就将里面自己觉得很经典的内容记录下来，作为自己以后写代码的标准和准则。同时也为那些曾经困惑过的人一点参考吧～！1.需求与代码哪个重要？答：并不是所有的产品都能提出合理的需求，当你面对一个提出不合理需求的产品的时候，你需要坚持自己的原则，不能妥协。2.易读和易懂是一回事吗？答：易读的代码和易懂的代码是有区别的，不是易读的代码就是易懂的代码。3.什么是测试驱动代码？答：测试驱动代码，你写的代码要可以执行单元测试。如果你发现你的代码很难写单元测试，那么你就要思考你的代码是不是已经不整洁了，或者说已经乱成一团了。4.什么是简单的代码？答：1.能通
Refining Uncle Bob’s Clean Code（三）
LGY2001的专栏
10-27 1302
But now, let’s take a closer look at the new interface of ArgumentMarshaler: 01 public interface ArgumentMarshaler { 02   03     public
史上最细gRPC(Go)入门教程(七)---利用Gateway同时提供HTTP和RPC服务
探索云原生
04-10 2608
本文主要记录了如何使用 gRPC-Gateway 同时对外提供 RESTful API 和 gRPC 接口。 1. 概述 gRPC 系列相关代码见 Github gRPC-Gateway 是Google protocol buffers compiler(protoc)的一个插件。读取 protobuf 定义然后生成反向代理服务器，将 RE
create_target_machine() got an unexpected keyword argument ‘jitdebug‘ 处理方法
crazyman33的专栏
02-02 371
create_target_machine() got an unexpected keyword argument 'jitdebug' 处理方法
protoc: does not implement protoreflect.ProtoMessage (missing ProtoReflect method)
qq_40531074的博客
05-19 4200
在学习protobuf做第一个小例子时出现如下错误： # command-line-arguments ./test_proto.go:23:29: cannot use test (type *Student) as type protoreflect.ProtoMessage in argument to marshaler.Marshal: *Student does not implement protoreflect.ProtoMessage (missing ProtoRefle
《代码整洁之道 》第十四章 逐步改进
weixin_39924752的博客
11-20 395
许多人认为，首要任务就是能写出能工作的代码，只要程序“能工作”就转移到下一个任务上，而“能工作”的程序就一直停留在那个所谓“能工作”的状态。很多团队的要求都只是让代码能工作，但是这样就留下了很大的隐患，而且会一直腐烂发酵，一片沼泽，不受控制，拖累团队。要编写整洁的代码，就必须先写肮脏的代码。有时候就像写作文一样，需要先写草稿，二稿，一次次的修改，直到终稿。优秀的软件设计，大都关乎分隔—创建合适的空间放置不同种类的代码。主要的代码的优化，写得还是优雅的。保持代码的整洁和简单，不要让代码有腐败的机会。
代码整洁之道
程序前行者的博客
07-24 1976
取好名字最难的地方在于需要良好的描述技巧和共有文化背景。与其说这是一种技术、商业或管理问题，还不如说是一种教学问题。其结果是，这个领域内的许多人都没能学会做得很好。我们有时会怕其他开发者反对重命名。如果讨论一下就知道，如果名称改得更好，那大家真的会感激你。多数时候我们并不记忆类名和方法名。我们使用现代工具对付这些细节，好让自己集中精力于把代码写得就像词句篇章、至少像是表和数据结构（词句并非总是呈现数据的最佳手段）。改名可能会让某人吃惊，就像你做到其他代码改善工作一样。别让这种事阻碍你的前进步伐。...
返回值类型与函数类型不匹配_golang基础语法,定义函数类型 为已存在的数据类型起别名...
weixin_39638603的博客
11-23 954
简介在 GO 语言中还有另外一种定义使用函数的方式，就是函数类型，所谓的函数类型就是将函数作为一种类型可以用来定义变量，这种用法类似于前面我们讲过的 int ,float64,string 等类型，这些类型都是可以用来定义变量。基本语法如下：说明如下：type 关键字后面跟着类型的名字 (FunType)，FunType 就是一个类型。那么 FunType 是一个什么类型呢？是一个函数类...
.NET 的 代码整洁之道 与 测试驱动开发 系列之(一)CleanCode 第14章
weixin_30528371的博客
03-16 348
这两天看了和测试驱动相关的开发，一开始觉得有够恶心的，本来几行代码能搞定的事，却要这么折腾。给我的感觉是，一但测试代码相对稳定了，敏捷开发者就“敏捷”地打成重构，代码整洁的旗号去对那柔弱的旧代码大开杀戒了。顺理成章的去用一些模式，可以说TDD的那些测试，就成了免死金牌。 下面写出自己对TDD的几条理解吧； 1、先把测试代码写出来，想好怎么调用，虽然编译都没过 2、用最傻，弱智的方法把编译先过...
marshaller java_使用Marshaller将Java对象转换为Json
weixin_42400619的博客
02-16 862
注意：我是EclipseLink JAXB (MOXy)的领导和JAXB (JSR-222)专家组的成员,以下是如何使用MOXy作为您的JAXB提供程序.JAVA模型顾客import java.util.*;import javax.xml.bind.annotation.*;@XmlRootElement(namespace="http://www.example.com")@XmlType(n...
读代码整洁之道
01-31
现在的软件系统开发难度主要在于其复杂度和规模，客户需求也不再像WinstonRoyce瀑布模型期望那样在系统编码...在《代码整洁之道》（Clean Code），提出一种软件质量，可持续开发不仅在于项目架构设计，还与代码质量密切
浅谈JavaScript 代码整洁之道
01-19
它们仅用于参考，不过要知道这些原则都是《代码整洁之道》的作者们累积多年的集体经验。 我们在软件工程方面的技术发展刚刚超过 50 年，我们仍然在学习很多东西。当软件架构和架构本身一样古老的时候，我们应该遵循...
代码整洁之道读书分享.zip
09-03
阅读《代码整洁之道》这本书的《逐步改进》、《JUnit内幕》这两章内容时写的demo
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 298
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1416
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 561
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1312
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 751
consul官网地址。
迭代器模式
最新发布
LuckFairyLuckBaby的博客
04-23 469
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
Java代码整洁之道
03-05
Java代码整洁之道是指编写易于理解、易于维护、可扩展性强的高质量代码的一系列准则和实践。以下是一些Java代码整洁之道的要点： 1. 命名规范：使用有意义的变量、方法和类名，遵循驼峰命名法，并避免使用缩写和单个字符作为名称。 2. 函数和方法的简洁性：函数和方法应该尽可能短小，只做一件事，并遵循单一职责原则。避免过长的函数和方法，可以通过提取子函数或方法来减少代码复杂性。 3. 注释和文档：使用清晰的注释来解释代码的意图和逻辑，但不要过度注释。另外，编写良好的文档注释，以便其他开发人员能够理解和使用你的代码。 4. 避免重复代码：重复代码会增加维护成本，应该尽量避免。可以通过提取公共代码块为方法或函数，或者使用继承、接口等方式来实现代码的重用。 5. 异常处理：合理处理异常情况，避免捕获所有异常或忽略异常。根据具体情况选择合适的异常处理方式，例如抛出异常、记录日志或返回默认值。 6. 单元测试：编写单元测试是保证代码质量的重要手段。每个方法都应该有对应的单元测试，覆盖各种情况，确保代码的正确性和稳定性。 7. 代码格式化：统一的代码格式可以提高代码的可读性。使用合适的缩进、空格、换行等格式化规范，并使用代码格式化工具进行自动格式化。 8. 设计模式和面向对象原则：熟悉常用的设计模式和面向对象原则，如单一职责原则、开闭原则、依赖倒置原则等，合理应用于代码设计中。 9. 持续重构：随着需求的变化和代码的演进，及时进行代码重构是保持代码整洁的关键。通过重构，可以改进代码结构、提高可读性和可维护性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值