Java编程10大低级错误

最新推荐文章于 2022-09-24 01:34:12 发布
最新推荐文章于 2022-09-24 01:34:12 发布
阅读量3.3k 收藏 3
点赞数
文章标签： java 编程 integer null string 产品

今天面试时HR问我一个关于数据库性能调优的问题，对于我的回答引发了她的另一个问题：Java 10大低级错误 知不知道？这个在以前公司的时候还真的提过这个问题，但是我实在是、、、在网上搜了一下，拿来分享一下，原文链接：http://blog.csdn.net/tianhangsky/article/details/6521800

1       前言
为了规范大家的编程行为，借鉴前人的编程经验，避免低级错误的不断发生，特发布MDSP产品Java十大低级错误，供所有Java开发人员学习。
2       Java十大低级错误
1、              类、方法、变量、常量等命名不能表达具体的含义，或者表达的含义和实际用途不一致。
2、              缺少类、方法注释，代码修改后没有同步修改注释。
3、              日志和实际情况不一致；捕获异常后没有在日志中记录异常栈。
4、              魔鬼数字。
5、              空指针异常。
6、              数组下标越界。
7、              将字符串转换为数字时没有捕获NumberFormatException异常。
8、              对文件、IO、数据库等资源进行操作后没有及时、正确进行释放。
9、              循环体编码时不考虑性能，循环体中包含不需要的重复逻辑。
10、           数据类没有重载toString()方法。
3       解读&案例
3.1   命名规范性
3.1.1   解读
在代码中，类、方法、变量、常量等的名称是帮助理解代码最直观的要素。命名良好、逻辑简洁的代码可以达到自注释的目的，通过阅读代码就可以基本理解业务逻辑，减少编写和维护注释的工作量。在编码时必须重视命名的规范性，名称应该简洁、容易理解，能够准确表达所命名对象的含义。临时变量的名称应该符合常用的习惯（如for循环的整形循环子一般使用i、j）。
3.1.2   案例
下面就是一个命名规范性不好的例子：
public void notifyProduct(Integer productId)
{
    if (productId == null)
    {
        throw new PMSException(PMSErrorCode.CommonError.PARAM_NULL, "product ID is null");
    }
 
    ProductService prodSrv = (ProductService) ServiceLocator.findService(ProductService.class);
    ProductServiceStruct product = prodSrv.queryProduct(productId);
    if (product == null)
    {
        throw new PMSException(PMSErrorCode.CommonError.PARAM_ERROR, "product not exist");
    }
 
    if (PMSConfig.getInstance().getConfig1())           // getConfig1没有具体含义
    {
        NotifyService sss1 = (NotifyService) ServiceLocator.findService(NotifyService.class);
        sss1.notifyProduct(product);
 
        if (PMSConfig.getInstance().getNotifyWisg())    // getNotifyWisg名称和实际含义不一致
        {
            MdspProductExtService sss2 = (MdspProductExtService) ServiceLocator.findService(MdspProductExtService.class);
            List<MdspProductExt> eee1 = sss2.queryProductExtInfo(productId);
            sss1.notifyProductExtInfo(eee1);
        }
        // sss1、sss2、eee1没有任何含义，理解困难
    }
}
如果采用规范、能表达含义的名称，代码就变得非常容易理解：
public void notifyProduct(Integer productId)
{
    if (productId == null)
    {
        throw new PMSException(PMSErrorCode.CommonError.PARAM_NULL, "product ID is null");
    }
 
    ProductService prodSrv = (ProductService) ServiceLocator.findService(ProductService.class);
    ProductServiceStruct product = prodSrv.queryProduct(productId);
    if (product == null)
    {
        throw new PMSException(PMSErrorCode.CommonError.PARAM_ERROR, "product not exist");
    }
 
    if (PMSConfig.getInstance().isNeedNotifyProduct())
    {
        NotifyService notifySrv = (NotifyService) ServiceLocator.findService(NotifyService.class);
        notifySrv.notifyProduct(product);
 
        if (PMSConfig.getInstance().isNeedNotifyProductExtInfo())
        {
            MdspProductExtService prodExtSrv = (MdspProductExtService) ServiceLocator.findService(MdspProductExtService.class);
            List<MdspProductExt> prodExtInfos = prodExtSrv.queryProductExtInfo(productId);
            notifySrv.notifyProductExtInfo(prodExtInfos);
        }
    }
}
3.2   注释规范性
3.2.1   解读
注释是帮助理解代码的重要资料，缺少必要的注释，可能需要浪费大量的时间阅读、调试代码，才能真正理解代码的逻辑，造成巨大的浪费，也会给维护代码带来很多困难。但注释也不是越多约好，在没有必要写注释的地方写冗余注释，或者不规范、甚至和代码逻辑不一致的注释，会给理解代码造成严重的干扰，不如不写。
类注释和方法注释应该按照编程规范的规定编写。方法注释需要说明方法入参含义、取值范围、可否为空、是否会被方法修改，以及方法返回值的含义、能否为空等情况。
对于方法中的注释，建议通过良好的命名规范、代码结构和统一的缩进风格，尽量使代码自注释，只在代码无法完全表达业务逻辑的地方添加必要的注释。以代码为主，注释为辅。修改代码时应同步修改注释，杜绝注释和代码不一致的情况。
3.2.2   案例
/**
 * <一句话功能简述>。
 * <功能详细描述>
 * // 没有方法注释，应该将自动生成的注释模板删除，添加有意义的类注释
 */
publicvoid sendMsg()
{
    ...
}
 
/**
 * 根据内容ID和产品类型查询产品列表。
 *
 * @param内容ID        // 能否为null？如果为null如何处理？ contentId
 * @param产品类型    // 都有哪些类型？能否为null？为null如何处理？ productType
 * @return产品列表                 // 如果没有查到，是返回空List还是返回null？
 */
public List<ProductServiceStruct> queryProduct(String contentId, String productType)
{
    ...
   
    if (PRODUCT_TYPE_SUB.equals(productType))
    {
        // 查询点播类产品
        // 注释和代码不一致
        return querySubProduct(contentId);
    }
    ...
   
    returnnull;
}
 
/**
 * 根据内容ID查询订购类产品列表。
 *
 * @param contentId 内容ID，不能为null
 * @return产品列表，如果没有返回空List
 */
public List<ProductServiceStruct> querySubProduct(String contentId)
{
    return ...;
}
 
3.3   日志规范性
3.3.1   解读
日志是定位问题时最重要的依据，业务流程中缺少必要的日志会给定位问题带来很多麻烦，甚至可能造成问题完全无法定位。
异常产生后，必须在日志中以ERROR或以上级别记录异常栈，否则会导致异常栈丢失，无法确认异常产生的位置。并不需要在每次捕获异常时都记录异常日志，这样可能导致异常被多次重复记录，影响问题的定位。但异常发生后其异常栈必须至少被记录一次。
和注释一样，日志也不是越多越好。无用的冗余日志不但不能帮助定位问题，还会干扰问题的定位。而错误的日志更是会误导问题，必须杜绝。
3.3.2   案例
下面的例子虽然打印了很多日志，但基本上都是无用的日志，难以帮助定位问题。甚至还有错误的日志会干扰问题的定位：
public void saveProduct1(ProductServiceStruct product)
{
    log.debug("enter method: addProduct()");
 
    log.debug("check product status");
    if (product.getProduct().getProductStatus() != ProductFieldEnum.ProductStatus.RELEASE)
    {
        throw new PMSException(PMSErrorCode.Product.ADD_ERROR);
    }
 
    log.debug("check tariff");
    BooleanResult result = checkTariff(product.getTariffs());
    if (!result.getResult())
    {
        throw new PMSException(PMSErrorCode.Product.ADD_ERROR);
    }
 
    log.debug("before add product");
    ProductService prodSrv = (ProductService) ServiceLocator.findService(ProductService.class);
    try
    {
        prodSrv.addProduct(product);
    }
    catch (BMEException e)
    {
        // 未记录异常栈，无法定位问题根源
    }
    log.debug("after add product");
 
    log.debug("exit method: updateProduct()"); // 错误的日志
}
而下面的例子日志打印的不多，但都是关键信息，可以很好的帮助定位问题：
public void saveProduct2(ProductServiceStruct product)
{
    if (product.getProduct().getProductStatus() != ProductFieldEnum.ProductStatus.RELEASE)
    {
        log.error(
                "product status "
                + product.getProduct().getProductStatus()
                + " error, expect " + ProductFieldEnum.ProductStatus.RELEASE);
        throw new PMSException(PMSErrorCode.Product.ADD_ERROR);
    }
 
    BooleanResult result = checkTariff(product.getTariffs());
    if (!result.getResult())
    {
        log.error(
                "check product tariff error "
                + result.getResultCode()
                + ": "
                + result.getResultDesc());
        throw new PMSException(PMSErrorCode.Product.ADD_ERROR);
    }
 
    ProductService prodSrv = (ProductService) ServiceLocator.findService(ProductService.class);
    try
    {
        prodSrv.addProduct(product);
    }
    catch (BMEException e)
    {
        log.error("add product error", e);
        throw new PMSException(PMSErrorCode.Product.ADD_ERROR, e);
    }
}
 
3.4   魔鬼数字
3.4.1   解读
在代码中使用魔鬼数字（没有具体含义的数字、字符串等）将会导致代码难以理解，应该将数字定义为名称有意义的常量。
将数字定义为常量的最终目的是为了使代码更容易理解，所以并不是只要将数字定义为常量就不是魔鬼数字了。如果常量的名称没有意义，无法帮助理解代码，同样是一种魔鬼数字。
在个别情况下，将数字定义为常量反而会导致代码更难以理解，此时就不应该强求将数字定义为常量。
3.4.2   案例
public void addProduct(ProductServiceStruct product)
{
    // 魔鬼数字，无法理解3具体代表产品的什么状态
    if (product.getProduct().getProductStatus() != 3)
    {
        throw new PMSException(PMSErrorCode.Product.ADD_ERROR);
    }
 
    BooleanResult result = checkTariff(product.getTariffs());
    if (!result.getResult())
    {
        throw new PMSException(PMSErrorCode.Product.ADD_ERROR);
    }
}
 
public void addProduct2(ProductServiceStruct product)
{
    // 仍然是魔鬼数字，无法理解NUM_THREE具体代表产品的什么状态
    if (product.getProduct().getProductStatus() != NUM_THREE)
    {
        throw new PMSException(PMSErrorCode.Product.ADD_ERROR);
    }
 
    BooleanResult result = checkTariff(product.getTariffs());
    if (!result.getResult())
    {
        throw new PMSException(PMSErrorCode.Product.ADD_ERROR);
    }
}
下面的例子中虽然将数字定义为了常量，但代码却并不容易理解：
/**
 * 获取将子窗口绘制在父窗口中间时，子窗口的坐标。
 *
 * @param父窗口的位置 parentWindow
 * @param子窗口的位置 clientWindow
 * @return子窗口在父窗口中间时的坐标
 */
public Point getDrawCenter1(Rect parentWindow, Rect clientWindow)
{
    Point drawCenter = new Point();
    drawCenter.x = parentWindow.x + (parentWindow.width - clientWindow.width) / HALF_SIZE_DIV;
    drawCenter.y = parentWindow.y + (parentWindow.height - clientWindow.height) / HALF_SIZE_DIV;
    return drawCenter;
}
直接使用数字，代码反而更容易理解：
/**
 * 获取将子窗口绘制在父窗口中间时，子窗口的坐标。
 *
 * @param父窗口的位置 parentWindow
 * @param子窗口的位置 clientWindow
 * @return子窗口在父窗口中间时的坐标
 */
public Point getDrawCenter2(Rect parentWindow, Rect clientWindow)
{
    Point drawCenter = new Point();
    drawCenter.x = parentWindow.x + (parentWindow.width - clientWindow.width) / 2;
    drawCenter.y = parentWindow.y + (parentWindow.height - clientWindow.height) / 2;
    return drawCenter;
}
 
3.5   空指针异常
3.5.1   解读
空指针异常是编码过程中最常见的异常，在使用一个对象的时候，如果对象可能为空，需要先判断对象是否为空，再使用这个对象。
在进行常量和变量的相等判断时，建议将常量定义为Java对象封装类型（如将int类型的常量定义为Integer类型），这样在比较时可以将常量放在左边，调用equals方法进行比较，可以省去不必要的判空。
3.5.2   案例
public class NullPointer
{
    static final Integer RESULT_CODE_OK = 0;
    static final Result RESULT_OK = new Result();
 
    public void printResult(Integer resultCode)
    {
        Result result = getResult(resultCode);
 
        // result可能为null，造成空指针异常
        if (result.isValid())
        {
            print(result);
        }
    }
 
    public Result getResult(Integer resultCode)
    {
        // 即使resultCode为null，仍然可以正确执行，减少额外的判空语句
        if (RESULT_CODE_OK.equals(resultCode))
       {
            return RESULT_OK;
        }
        return null;
    }
 
    public void print(Result result)
    {
        ...
    }
}
 
3.6   下标越界
3.6.1   解读
访问数组、List等容器内的元素时，必须首先检查下标是否越界，杜绝下标越界异常的发生。
3.6.2   案例
publicclass ArrayOver
{
    publicvoid checkArray(String name)
    {
        // 获取一个数组对象
        String[] cIds = ContentService.queryByName(name);
        if(null != cIds)
        {
           // 只是考虑到 cids有可能为null的情况，但是 cids完全有可能是个0长度的数组，因此cIds[0]有可能数组下标越界
            String cid=cIds[0];
            cid.toCharArray();
        }
    }
}
 
3.7   字符串转数字
3.7.1   解读
调用Java方法将字符串转换为数字时，如果字符串的格式非法，会抛出运行时异常NumberFormatException。
3.7.2   案例
错误例子：
public Integer getInteger1(String number)
{
    // 如果number格式非法，会抛出NumberFormatException
    return Integer.valueOf(number);
}
正确的处理方法如下：
public Integer getInteger2(String number)
{
    try
    {
        return Integer.valueOf(number);
    }
    catch (NumberFormatException e)
    {
        ...
        return null;
    }
}
 
3.8   资源释放
3.8.1   解读
在使用文件、IO流、数据库连接等不会自动释放的资源时，应该在使用完毕后马上将其关闭。关闭资源的代码应该在try...catch...finally的finally内执行，否则可能造成资源无法释放。
3.8.2   案例
错误案例如下：
public void writeProduct1(ProductServiceStruct product)
{
    try
    {
        FileWriter fileWriter = new FileWriter("");
        fileWriter.append(product.toString());
        // 如果append()抛出异常，close()方法就不会执行，造成IO流长时间无法释放
        fileWriter.close();
    }
    catch (IOException e)
    {
        ...
    }
}
关闭IO流的正确方法如下：
public void writeProduct2(ProductServiceStruct product)
{
    FileWriter fileWriter = null;
    try
    {
        fileWriter = new FileWriter("");
        fileWriter.append(product.toString());
    }
    catch (IOException e)
    {
        ...
    }
    finally
    {
        // 不管前面是否发生异常，finally中的代码一定会执行
        if (fileWriter != null)
        {
            try
            {
                fileWriter.close();
            }
            catch (IOException e)
            {
                ...
            }
        }
    }
}
 
3.9   循环体性能
3.9.1   解读
循环体是软件中最容易造成性能问题的地方，所以在进行循环体编码时务必考虑性能问题。
在循环体内重复使用且不会变化的资源（如变量、文件对象、数据库连接等），应该在循环体开始前构造并初始化，避免在循环体内重复和构造初始化造成CPU资源的浪费。
除非业务场景需要，避免在循环体内构造try...catch块，因为每次进入、退出try...catch块都会消耗一定的CPU资源，将try...catch块放在循环体之外可以节省大量的执行时间。
3.9.2   案例
public void addProducts(List<ProductServiceStruct> prodList)
{
    for (ProductServiceStruct product : prodList)
    {
        // prodSrv在每次循环时都会重新获取，造成不必要的资源消耗
        ProductService prodSrv = (ProductService) ServiceLocator.findService(ProductService.class);
 
        // 避免在循环体内try...catch，放在循环体之外可以节省执行时间
        try
        {
            prodSrv.addProduct(product);
        }
        catch (BMEException e)
        {
            ...
        }
    }
}
 
3.10 数据类重载toString()方法
3.10.1          解读
数据类如果没有重载toString()方法，在记录日志的时候会无法记录数据对象的属性值，给定位问题带来困难。
3.10.2          案例
public class MdspProductExt
{
    private String key;
   
    private String value;
 
    public String getKey()
    {
        return key;
    }
 
    public void setKey(String key)
    {
        this.key = key;
    }
 
    public String getValue()
    {
        return value;
    }
 
    public void setValue(String value)
    {
        this.value = value;
    }
}
 
class BusinessProcess
{
    private DebugLog log = LogFactory.getDebugLog(BusinessProcess.class);
   
    public void doBusiness(MdspProductExt prodExt)
    {
        try
        {
            ...
        }
        catch (PMSException e)
        {
            // MdspProductExt未重载toString()方法，日志中无法记录对象内属性的值，只能记录对象地址
            log.error("error while process prodExt " + prodExt);
        }
    }
}


小屁孩_P
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java编程十大低级错误
03-05
java编程中需要竭力避免的10大低级错误，否则要被同行看扁了
使用service locator快速定位你的服务
googlezhang的专栏
04-05 3040
申明：本人对java了解不太深，发表的观点可能有不当之处，如有之请不吝赐教。service locator模式在老早的j2ee中就被提出来，原因是在一个程序中有大量服务(service)时，使用者调用相关的服务组件就显得不那么容易，既不易寻找，又需要自己创建实例，既耗时又没有任何技术含量。service locator模式的出现解决了上述问题，它将一组服务甚至所有服务交给一个或者若干个service locator，由这些service locator来找寻服务并完成初始化的工作，调用者只需要知道使用哪个s
异常：@Service interfaceClass() or interfaceName() or interface class must be present
u014685642的博客
03-29 372
service注入错误，@DubboReference 改成 @Resource
【Java基础】注解--@interface使用详解
热门推荐
m0_45406092的博客
01-18 2万+
文章目录1. 引言2. 语法规范2.1 继承的Annotation父接口2.2 @Target中的参数ElementType2.3 @Retention中的参数RetentionPolicy2.4 成员变量3. 获取注解信息3.2 使用场景——框架初始化过程中模拟扫描jar包和文件夹中的所有注解4. 注解的作用4.1 编译检查4.2 在反射中使用 Annotation4.3 根据 Annotation 生成帮助文档参考 1. 引言 注解@interface不是接口是注解类，在jdk1.5之后加入的功能，使用
记一次JAVA自定义@interface中方法定义诡异问题
xiaoll880214的专栏
03-21 461
诡异问题描述： 使用IDEA工具，正常不报错但是执行mvn install的时候，出现了大量的方法和属性不存在提示错误，实际上都要是存在，但无论如何都编译不通过。这种场景有点类似于在一个类中少了个大括号，然后真个类报错的那种感觉。 问题查找： 排除了各种依赖，也执行了各种clean。最后再另一个同事的eclipse上，发现在一个类的注解上提示了：注解的源类型为i...
Java自定义注解@interface
weixin_44223977的博客
02-26 580
自定义注解 步骤 第一步，用@interface定义注解： 在类中声明可以去掉public public @interface Report { } 第二步，元注释配置注解 @Target 最常用的元注解是@Target。使用@Target可以定义Annotation能够被应用于源码的哪些位置： 类或接口：ElementType.TYPE； 字段：ElementType.FIELD； 方法：ElementType.METHOD； 构造方法：ElementType.CONSTRUCTOR； 方法参
java10大低级错误
03-25
Java十大低级错误 1、方法和变量命名随意而不规范，没有类注释、方法注释或注释不规范，代码修改后，不同步修改注释，导致注释与代码不符。 2、数据类不重载toString（）方法（说明：编程规范要求“所有的数据类必须...
JAVA编程规范学习材料
05-12
JAVA编程规范学习材料
rosjava_core:支持 Android 的纯 Java ROS 实现
05-29
它提供了您期望从操作系统获得的服务，包括硬件抽象，低级设备控制，常用功能的实现，进程之间的消息传递以及程序包管理。 rosjava 由 Google 与 Willow Garage 合作开发，能够集成 Android 和 ROS 兼容机器人。 ...
Java十大低级错误
04-27
Java十大低级错误,用于规范程序员编码行为
Java十大低级错误.doc
09-06
Java十大低级错误
C++编程中的十大低级错误
03-05
C++编程中需要避免的10大编程错误，可用于代码检查。
软件编程低级错误：野指针
10-05
C和C++语言是我司的主流编程语言，然而C/C++具有很多强大的语言特性，从而导致C/C++非常复杂，使得代码更容易出现BUG、难以阅读和维护。
Java I/O流详解
沐雨橙风ιε的博客
09-24 749
Java I/O流详解
java高级流低级流定义_java中哪些是低级流？哪些是高级流？
weixin_39928233的博客
02-28 854
引用来自“静心天涯”的评论在输入输出里，有字节流和字符流分，这两者区别在于所操作的数据单元不同。还有另外一种认识，输入输出流可以分为节点刘和处理流(包装流)，节点流有时候会被称为低级流，节点流是直接和实际的数据源相互连接的，和实际的输入输出点连接。处理流有时候也成为高级流，是对一个已存在的流进行连接或封装。区分节点流和处理流，只要看给出的参数是什么就行了，如果是一个实际的数据源，就是节点流，如果是...
新java十大低级错误
tianhangsky的专栏
04-13 2388
 1       前言为了规范大家的编程行为，借鉴前人的编程经验，避免低级错误的不断发生，特发布MDSP产品Java十大低级错误，供所有Java开发人员学习。2       Java十大低级错误1、              类、方法、变量、常量等命名不能表达具体的含义，或者表达的含义和实际用途不一致。2、              缺少类、方法注释，代码修改后没有同步修改注释
开发中必须避免的基础问题
asia273360657的专栏
05-12 490
本文转自Liter’s Blog1.空指针异常第一就要说这个，必须的，避免了它，大概意味着避免80、90%的错误吧，对方法的调用不进行空指针判断而造成针异常（原则是千万不要想当然认为一个对象就不会空），举个简单例子就是equals操作时没有将常量放在equals操作符的左边（字符串变量与常量比较时，先写常量可以避免空指针异常）。记得有危险的地方要么if判断要么try catch。2.命名与注释方法和
java编程10大低级错误
最新发布
06-13
以下是 Java 编程中常见的 10 大低级错误： 1. 空指针异常：没有正确地处理变量或对象的空值 2. 类型转换异常：尝试将不兼容的类型进行强制类型转换 3. 数组越界异常：尝试访问数组中不存在的元素 4. 不正确的方法重载：重载方法时，参数类型或数量不正确 5. 不正确的方法覆盖：覆盖方法时，方法签名或返回类型不正确 6. 不正确的异常处理：没有正确地捕获或处理异常 7. 不正确的同步：在多线程操作时，没有正确地同步共享资源 8. 不正确的循环：循环条件或循环体不正确 9. 不正确的变量作用域：变量的作用域不正确，导致编译错误或运行时错误 10. 不正确的字符串操作：字符串拼接、比较或格式化时，没有正确地使用字符串方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值