精华内容
下载资源
问答
  • Java代码规范文档

    2018-08-19 12:59:49
    这是本人整理的一个Java代码规范,结合了Google编码规范,有些规范是结合了本人公司的规范的,并没有要求一定要按照此标准进行编写
  • java代码规范文档

    千次阅读 2018-09-28 13:45:54
    java代码规范文档 原则: 注释形式统一 在整个应用程序中,使用具有一致的标点和结构的样式来构造注释。如果在其它项目中发现它们的注释规范与这份文档不同,按照这份规范写代码,不要试图在既成的规范系统中引入新...

    java代码规范文档

    原则:

    注释形式统一

    在整个应用程序中,使用具有一致的标点和结构的样式来构造注释。如果在其它项目中发现它们的注释规范与这份文档不同,按照这份规范写代码,不要试图在既成的规范系统中引入新的规范。

    注释内容准确简洁

    内容要简单、明了、含义准确,防止注释的多义性,错误的注释不但无益反而有害。

    注释条件

    基本注释

    1.类(接口)的注释
    2.构造函数的注释
    3.方法的注释
    4.全局变量的注释
    5.字段/属性的注释

    特殊必加注释

    1.典型算法必须有注释
    2.在代码不明晰处必须有注释
    3.在代码修改处加上修改标识注释
    4.在循环和逻辑分支组成的代码中加注释
    5.为他人提供的接口必须加详细注释

    注释格式

    单行(single-line)注释:“//……”
    块(block)注释:“/……/”
    文档注释:“/*……/”
    javadoc 注释标签语法

    @author   对类的说明 标明开发该类模块的作者 
    @version   对类的说明 标明该类模块的版本 
    @see     对类、属性、方法的说明 参考转向,也就是相关主题 
    @param    对方法的说明 对方法中某参数的说明 
    @return   对方法的说明 对方法返回值的说明 
    @exception  对方法的说明 对方法可能抛出的异常进行说明
    

    参考实例

    类(接口)的注释

    /**
     * @Description 类的描述
     * @author Administrator
     * @Time 2018-09-28
     * @version v1.1
     */
    public class testEwallet {
    	
    }
    

    构造函数的注释

        /**
    	 * @Description 构造方法描述
    	 * @param name
    	 * 按钮上显示文字
    	 */
    	public testEwallet(String name){
    	}
    

    方法注释

     /**
    
            * 为按钮添加颜色
    
            * @param color
    
            * 按钮的颜色
    
            * @return 
    
            * @exception  (方法有异常的话加)
    
            * @author Administrator
    
            * @Time2012-11-20 15:02:29
    
            */
    
            public voidaddColor(String color){
            }
    

    全局变量注释

      /** The value is used for characterstorage. */
    
         private final char value[];
    

    字段/属性注释

    
         private String senderName;//发送人姓名
    
         private String title;//不能超过120个中文字符
    
    展开全文
  • List,Map,Set接口在取元素师,各有什么特点 如何线程安全的实现一个计数器 生产者消费者模式,要求手写过代码,还是要知道的 单例模式,饿汉式,懒汉式,线程安全的做法,两次判断instance是否为空,每次判断的...

    前言

    提到MySQL的事务,我相信对MySQL有了解的同学都能聊上几句,无论是面试求职,还是日常开发,MySQL的事务都跟我们息息相关。

    而事务的ACID(即原子性Atomicity、一致性Consistency、隔离性Isolation、持久性Durability)可以说涵盖了事务的全部知识点,所以,我们不仅要知道ACID是什么,还要了解ACID背后的实现,只有这样,无论在日常开发还是面试求职,都能无往而不利。

    为了大家更好的阅读体验,对ACID的深入分析将分为上下两篇。

    本篇主要围绕ACID中的I,也就是“隔离性”展开,从基本概念,到隔离性的实现,最后以一个实战案例进行融会贯通。

    01 JAVA基础

    1.1 java知识点

    • Hashmap 源码级掌握,扩容,红黑树,最小树化容量,hash冲突解决,有些面试官会提出发自灵魂的审问,比如为什么是红黑树,别的树不可以吗;为什么8的时候树化,4不可以吗,等等
    • concureentHashMap,段锁,如何分段,和hashmap在hash上的区别,性能,等等
    • HashTable ,同步锁,这块可能会问你synchronized关键字 1.6之后提升了什么,怎么提升的这些
    • ArrayList 优势,扩容,什么时候用
    • LinkedList 优势,什么时候用,和arraylist的区别 等等
    • 基本类型和包装类型的区别,涉及自动装箱和拆箱,怎么做的,原理
    • String ,StringBuffer,StringBuilder哪个是安全的
    • 字符串编码的区别,被问到过,我觉得比较容易被忽视的一个点
    • 什么是泛型,怎么用泛型
    • static能不能修饰threadLocal,为什么,这道题我当时一听到其实挺懵逼的
    • Comparable和Comparator接口是干什么的,其区别
    • 多态的原理是什么,感觉这个很容易被问到
    • 接口和抽象类,面试官问我是怎么理解的,我说接口对应功能,抽象类对应属性,然后面试官给我说了他的看法,说抽象类更偏向于一种模板~ 然后又交流了一下各自的想法
    • 如何通过反射和设置对象私有字段的值
    • 快速失败(fail-fast)和安全失败(fail-safe)的区别是什么
    • synchronized 的实现原理以及锁优化?
    • volatile 的实现原理?
    • Java 的信号灯?
    • synchronized 在静态方法和普通方法的区别?
    • 怎么实现所有线程在等待某个事件的发生才会去执行?
    • CAS?CAS 有什么缺陷,如何解决?
    • synchronized 和 lock 有什么区别?
    • Hashtable 是怎么加锁的 ?
    • List,Map,Set接口在取元素师,各有什么特点
    • 如何线程安全的实现一个计数器
    • 生产者消费者模式,要求手写过代码,还是要知道的
    • 单例模式,饿汉式,懒汉式,线程安全的做法,两次判断instance是否为空,每次判断的作用是什么。
    • 线程池,这个还是很重要的,在生产中用的挺多,四个线程池类型,其参数,参数的理解很重要,corepoolSize怎么设置,maxpoolsize怎么设置,keep-alive各种的,和美团面试官探讨过阻塞队列在生产中的设置,他说他一般设置为0,防止用户阻塞
    • cyclicbarrier 和countdownlatch的区别,个人理解 赛马和点火箭
    • 线程回调,这块 被问过让我设计一个RPC,怎么实现,其实用到了回调这块的东西
    • sleep 和yeild方法有什么区别
    • volatile关键字,可见性。
    • 乐观锁和悲观锁的使用场景
    • 悲观锁的常见实现方式:lock synchronized retreentlock
    • 乐观锁:CAS MVCC
    • 读写锁的实现方式,16位int的前八位和后八位分别作为读锁和写锁的标志位
    • 死锁的条件,怎么解除死锁,怎么观测死锁。
    • 希望大家能够好好看一下反射的原理,怎么确定类,怎么调方法
    • RPC框架,同步异步,响应时间,这些都被问到过,还让设计过
    • 同步,异步,阻塞,非阻塞 在深信服的面试中遇到过,最好再找一些应用场景加以理解

    1.2 JVM

    • 内存模型以及分区,需要详细到每个区放什么。
    • 堆里面的分区:Eden,survival (from+ to),老年代,各自的特点。
    • 对象创建方法,对象的内存分配,对象的访问定位。
    • GC 的两种判定方法
    • GC 的三种收集方法:标记清除、标记整理、复制算法的原理与特点,分别用在什么地方,如果让你优化收集方法,有什么思路?
    • GC 收集器有哪些?CMS 收集器与 G1 收集器的特点
    • Minor GC 与 Full GC 分别在什么时候发生?
    • JVM 内存分哪几个区,每个区的作用是什么?
    • 如和判断一个对象是否存活?(或者 GC 对象的判定方法)
    • java 中垃圾收集的方法有哪些?
    • 类加载器双亲委派模型机制?
    • java 内存模型,java 类加载过程?
    • 什么是类加载器,类加载器有哪些?
    • 简述 java 内存分配与回收策率以及 Minor GC 和Major GC

    02 数据库

    2.1 MySQL

    • 事务四大特性(ACID)原子性、一致性、隔离性、持久性?
    • 事务的并发?事务隔离级别,每个级别会引发什么问题,MySQL默认是哪个级别?
    • MySQL常见的三种存储引擎(InnoDB、MyISAM、MEMORY)的区别?
    • MySQL的MyISAM与InnoDB两种存储引擎在,事务、锁级别,各自的适用场景?
    • 查询语句不同元素(where、jion、limit、group by、having等等)执行先后顺序
    • 索引为什么要用B+树,B+树和B-树的区别是什么
    • mysql的默认事务级别,一共有哪些事务级别
    • mysql的一些语句,这些肯定需要掌握的
    • mysql锁,行锁,表锁 ,什么时候发生锁,怎么锁,原理
    • 数据库优化,最左原则啊,水平分表,垂直分表
    • 什么是临时表,临时表什么时候删除?
    • MySQL B+Tree索引和Hash索引的区别?
    • sql查询语句确定创建哪种类型的索引?如何优化查询?
    • 聚集索引和非聚集索引区别?
    • 有哪些锁(乐观锁悲观锁),select 时怎么加排它锁?
    • 非关系型数据库和关系型数据库区别,优势比较?
    • 数据库三范式,根据某个场景设计数据表?
    • 数据库的读写分离、主从复制,主从复制分析的 7 个问题?
    • 使用explain优化sql和索引?
    • MySQL慢查询怎么解决?
    • 什么是 内连接、外连接、交叉连接、笛卡尔积等?
    • mysql都有什么锁,死锁判定原理和具体场景,死锁怎么解决?
    • varchar和char的使用场景?
    • mysql 高并发环境解决方案?
    • 数据库崩溃时事务的恢复机制(REDO日志和UNDO日志)?

    03 Spring相关

    spring的两大特性- ioc aop,实现原理

    • 如果存在A依赖B,B依赖A,那么是怎么加到IOC中去的
    • beanFactory的理解,怎么加载bean
    • FactoryBean的理解
    • 基于注解的形式,是怎么实现的, 你知道其原理吗,说一下
    • 依赖冲突,有碰到过吗,你是怎么解决的~
    • bean的生命周期
    • spring中的自动装配方式
    • BeanFactory 和 FactoryBean
    • Spring IOC 的理解,其初始化过程?
    • BeanFactory 和 ApplicationContext?
    • Spring Bean 的生命周期,如何被管理的?Spring Bean 的加载过程是怎样的?
    • 如果要你实现Spring AOP,请问怎么实现?
    • 如果要你实现Spring IOC,你会注意哪些问题?
    • Spring 是如何管理事务的,事务管理机制?
    • Spring 的不同事务传播行为有哪些,干什么用的?
    • Spring 中用到了那些设计模式?
    • Spring MVC 的工作原理?
    • Spring 循环注入的原理?
    • Spring 如何保证 Controller 并发的安全?
    • 你一般是怎么对mvc项目进行分层的
    • dispatch-servlet的工作原理
    • 为什么有了springmvc还要在项目中使用spring?
    • springmvc的运行机制,dispatch -》 hanldermapping-—》handler -》handlerAdapter-》执行handler-》modelandview -》 返回mv -》 视图解析器-》返回view -》 渲染响应
    • 怎么防止依赖注入
    • 怎么让mapper 和xml对应
    • 如何自动包装对象
    • 和spring相比,做了什么改变
    • starter你知道哪些
    • 如何部署springmvc项目 以及如何部署springboot项目
    • springboot的插件,你使用过哪些

    04 中间件

    4.1 redis

    • Redis用过哪些数据数据,以及Redis底层怎么实现
    • Redis缓存穿透,缓存雪崩
    • 如何使用Redis来实现分布式锁
    • Redis的并发竞争问题如何解决
    • Redis持久化的几种方式,优缺点是什么,怎么实现的
    • Redis的缓存失效策略
    • Redis集群,高可用,原理
    • Redis缓存分片,Redis的数据淘汰策略
    • 为什么选择redis,有什么好处,基于内存,抗压
    • redis集群怎么进行数据分配,hash槽
    • redis的主从复制是怎么实现的
    • redis的数据结构 最常问 hash是什么, sorted set怎么实现的
    • 因为项目的原因,问我redis是怎么保证高可用的,主从和集群怎么加在一起
    • redis 和memcache的区别
    • redis 分布式锁的实现原理 setNX 啥的
    • redis模拟session,除了redis你还考虑过别的吗
    • redis的缓存击穿,怎么处理这个问题
    • redis是基于内存的,那么它有持久化吗,aof rdb
    • aof和rdb的优缺点,你在项目中使用的哪一个

    4.2 MQ

    • 为什么选择rabbitMQ, 社区活跃,高并发
    • 别的MQ也要了解,比如RocketMQ(阿里的,java开发,再次开发,并发高,分布式,出错少)
    • ActiveMQ, kafka
    • topic 和 block
    • MQ的作用,同步转异步,消除峰值
    • 如何保证数据一致性,即原子性,ack
    • 消息队列在项目中的应用

    4.3 nginx

    • 怎么配置负载均衡
    • 怎么限流
    • 怎么使用nginx缓存
    • 为什么使用nginx,有别的替代品吗
    • 请解释 x Nginx 如何处理 P HTTP 请求
    • 在 x Nginx 中,如何使用未定义的服务器名称来阻止处理请求? ?
    • 使用“ 反向代理服务器 ” 的优点是什么?
    • x Nginx 服务器上的 r Master 和 和 r Worker 进程分别是什么?
    • nginx的压力测试,你测试过吗,能抗住多少压力
    • 你如何通过不同于 0 80 的端口开启 Nginx?
    • 是否有可能将 x Nginx 的错误替换为 2 502 错误、 503
    • s stub_status 和 和 r sub_filter 指令的作用是什么? ?

    4.5 dubbo

    • 原理,怎么用
    • 和erueka有什么区别
    • 为什么要用dubbo,不用行不行?
    • 跨域请求的一些知识点
    • Dubbo 支持哪些协议,每种协议的应用场景,优缺点?
    • Dubbo 超时时间怎样设置?
    • Dubbo 集群的负载均衡有哪些策略
    • Dubbo 的主要应用场景?
    • Dubbo 服务注册与发现的流程?
    • Dubbo 中 中 zookeeper 做注册中心,如果注册中心集群都挂掉,发布者和订阅者之间还能通信么?
    • dubbo 服务负载均衡策略?

    05 其他插件

    5.1 shiro

    • 怎么做权限控制
    • 为什么使用shiro,你直接使用aop不也是一样的吗,shiro还有标签~各种扯
    • shiro的两个最重要的函数
    • 认证和授权是怎么做的

    5.2 docker

    • 和vmware的区别
    • 你一般是怎么部署的 IDEA,直接把项目部署到docker并打包到云服务器
    • docker的好处,小,快

    06 Linux

    • 常见的命令
    • sed 和 awk 感觉linux必考。。
    • linux的使用场景,你什么时候会用linux – 》 布置服务器
    • 怎么查看进程和杀死进程
    • 打印一个文件夹中的所有文件
    • float在计算机中是怎么存储的,当时被问到的时候,我也在问自己,怎么存的~~~ 佛了
    • 线程和进程的区别
    • 线程的通信方式,进程的通信方式
    • 系统线程的数量上限是多少
    • 页式存储的概念
    • 内存碎片,你有了解过吗,有想过解决方案吗~

    07 算法

    7.1 排序算法

    • 八大排序算法真的是面试宠儿
    • 最常考 快速排序 和归并排序
    • 哪些排序算法是稳定的 哪些是不稳定的
    • 堆排 也应该掌握

    7.2 树

    • 根据遍历结果恢复树,递归
    • 二叉搜索树第k大
    • 树的和为k的路径
    • 层次遍历
    • 根据层次遍历和后序遍历恢复树
    • 镜像树
    • 树的深度
    • 是不是平衡二叉树

    7.3 链表

    • 反转链表
    • 链表环的入口
    • 交叉链表的交点
    • 复杂链表的复制
    • 二叉搜索树变成双向链表

    7.4 回溯算法

    • 走迷宫
    • 游戏通关

    7.5 递推算法

    • 走台阶
    • 断钢筋

    7.6 背包问题

    • 装最多的东西

    7.7 贪心算法

    • 覆盖问题
    • 时间问题

    08 设计模式

    • 面试中设计模式其实也是挺重要的
    • Java 中什么叫单例设计模式?请用 Java 写出线程安全的单例模式
    • 在 Java 中,什么叫观察者设计模式(observer design pattern)
    • 使用工厂模式最主要的好处是什么?在哪里使用
    • 举一个用 Java 实现的装饰模式(decorator design pattern) ?它是作用于对象层次还是类层次?
    • 在 Java 中,什么时候用重载,什么时候用重写?
    • 举例说明什么情况下会更倾向于使用抽象类而不是接口
    • 观察者模式
    • 适配模式
    • 工厂模式

    知其然不知其所以然,大厂常问面试技术如何复习?

    1、热门面试题及答案大全

    面试前做足功夫,让你面试成功率提升一截,这里一份热门350道一线互联网常问面试题及答案助你拿offer

    面试宝典+书籍+核心知识获取:戳这里免费下载!诚意满满!!!

    2、多线程、高并发、缓存入门到实战项目pdf书籍

    3、文中提到面试题答案整理

    4、Java核心知识面试宝典

    覆盖了JVM 、JAVA集合、JAVA多线程并发、JAVA基础、Spring原理、微服务、Netty与RPC、网络、日志、Zookeeper、Kafka、RabbitMQ、Hbase、MongoDB 、Cassandra、设计模式、负载均衡、数据库、一致性算法 、JAVA算法、数据结构、算法、分布式缓存、Hadoop、Spark、Storm的大量技术点且讲解的非常深入

    覆盖了JVM 、JAVA集合、JAVA多线程并发、JAVA基础、Spring原理、微服务、Netty与RPC、网络、日志、Zookeeper、Kafka、RabbitMQ、Hbase、MongoDB 、Cassandra、设计模式、负载均衡、数据库、一致性算法 、JAVA算法、数据结构、算法、分布式缓存、Hadoop、Spark、Storm的大量技术点且讲解的非常深入

    [外链图片转存中…(img-1wyu218u-1621412775219)]

    [外链图片转存中…(img-yrgjGpN8-1621412775220)]

    [外链图片转存中…(img-Lbt5nLaa-1621412775221)]

    展开全文
  • 文档java代码规范

    2014-10-19 22:36:28
    文档java代码规范
  • 东华软件java代码开发规范文档
  • Java代码规范总结
  • java代码注释规范文档

    2018-09-18 10:33:34
    后端开发技术的代码注释规范 单行注释 多行注释 块注释 文档注释 标签注释等等
  • java代码审查规范文档

    2018-09-18 10:30:25
    Code Review是一种用来确认方案设计和代码实现的质量保证机制,通过这个机制我们可以对代码、测试过程和注释进行检查。 Code Review主要用来在软件工程过程中改进代码质量,通过Code Review可以达到如下目的: .在...
  • JAVA代码规范手册.doc
  • Java代码规范以SUN的标准Java代码规范为基础,本文档中没有说明的地方,请查看Sun公司的Java标准代码规范。
  • Java代码规范

    万次阅读 多人点赞 2018-01-10 10:06:02
    Java代码规范Java代码规范以SUN的标准Java代码规范为基础,为适应我们公司的实际需要,可能会做一些修改。本文档中没有说明的地方,请参看SUN Java标准代码规范。如果两边有冲突,以本文档为准。 1. ...

    Java代码规范

    本Java代码规范以SUN的标准Java代码规范为基础,为适应我们公司的实际需要,可能会做一些修改。本文档中没有说明的地方,请参看SUN Java标准代码规范。如果两边有冲突,以本文档为准。

    1. 标识符命名规范

    1.1 概述

    标识符的命名力求做到统一、达意和简洁。

    1.1.1 统一

    统一是指,对于同一个概念,在程序中用同一种表示方法,比如对于供应商,既可以用supplier,也可以用provider,但是我们只能选定一个使用,至少在一个Java项目中保持统一。统一是作为重要的,如果对同一概念有不同的表示方法,会使代码混乱难以理解。即使不能取得好的名称,但是只要统一,阅读起来也不会太困难,因为阅读者只要理解一次。

    1.1.2 达意

    达意是指,标识符能准确的表达出它所代表的意义,比如: newSupplier, OrderPaymentGatewayService等;而 supplier1, service2,idtts等则不是好的命名方式。准确有两成含义,一是正确,而是丰富。如果给一个代表供应商的变量起名是 order,显然没有正确表达。同样的,supplier1, 远没有targetSupplier意义丰富。

    1.1.3 简洁

    简洁是指,在统一和达意的前提下,用尽量少的标识符。如果不能达意,宁愿不要简洁。比如:theOrderNameOfTheTargetSupplierWhichIsTransfered 太长, transferedTargetSupplierOrderName则较好,但是transTgtSplOrdNm就不好了。省略元音的缩写方式不要使用,我们的英语往往还没有好到看得懂奇怪的缩写。

    1.1.4 骆驼法则

    Java中,除了包名,静态常量等特殊情况,大部分情况下标识符使用骆驼法则,即单词之间不使用特殊符号分割,而是通过首字母大写来分割。比如: SupplierName, addNewContract,而不是 supplier_name, add_new_contract。

    1.1.5 英文 vs 拼音

    尽量使用通俗易懂的英文单词,如果不会可以向队友求助,实在不行则使用汉语拼音,避免拼音与英文混用。比如表示归档,用archive比较好, 用pigeonhole则不好,用guiDang尚可接受。

    1.2 包名

    使用小写字母如 com.xxx.settlment,不要 com.xxx.Settlement
    单词间不要用字符隔开,比如 com.xxx.settlment.jsfutil,而不要com.xxx.settlement.jsf_util

    1.3 类名

    1.3.1 首字母大写

    类名要首字母大写,比如 SupplierService, PaymentOrderAction;不要 supplierService, paymentOrderAction.

    1.3.2 后缀

    类名往往用不同的后缀表达额外的意思,如下表:

    后缀名 意义 举例
    Service 表明这个类是个服务类,里面包含了给其他类提同业务服务的方法 PaymentOrderService
    Impl 这个类是一个实现类,而不是接口 PaymentOrderServiceImpl
    Inter 这个类是一个接口 LifeCycleInter
    Dao 这个类封装了数据访问方法 PaymentOrderDao
    Action 直接处理页面请求,管理页面逻辑了类 UpdateOrderListAction
    Listener 响应某种事件的类 PaymentSuccessListener
    Event 这个类代表了某种事件 PaymentSuccessEvent
    Servlet 一个Servlet PaymentCallbackServlet
    Factory 生成某种对象工厂的类 PaymentOrderFactory
    Adapter 用来连接某种以前不被支持的对象的类 DatabaseLogAdapter
    Job 某种按时间运行的任务 PaymentOrderCancelJob
    Wrapper 这是一个包装类,为了给某个类提供没有的能力 SelectableOrderListWrapper
    Bean 这是一个POJO MenuStateBean

    1.4 方法名

    首字母小写,如 addOrder() 不要 AddOrder()
    动词在前,如 addOrder(),不要orderAdd()
    动词前缀往往表达特定的含义,如下表:

    前缀名 意义 举例
    create 创建 createOrder()
    delete 删除 deleteOrder()
    add 创建,暗示新创建的对象属于某个集合 addPaidOrder()
    remove 删除 removeOrder()
    init或则initialize 初始化,暗示会做些诸如获取资源等特殊动作 initializeObjectPool
    destroy 销毁,暗示会做些诸如释放资源的特殊动作 destroyObjectPool
    open 打开 openConnection()
    close 关闭 closeConnection()<
    read 读取 readUserName()
    write 写入 writeUserName()
    get 获得 getName()
    set 设置 setName()
    prepare 准备 prepareOrderList()
    copy 复制 copyCustomerList()
    modity 修改 modifyActualTotalAmount()
    calculate 数值计算 calculateCommission()
    do 执行某个过程或流程 doOrderCancelJob()
    dispatch 判断程序流程转向 dispatchUserRequest()
    start 开始 startOrderProcessing()
    stop 结束 stopOrderProcessing()
    send 发送某个消息或事件 sendOrderPaidMessage()
    receive 接受消息或时间 receiveOrderPaidMessgae()
    respond 响应用户动作 responseOrderListItemClicked()
    find 查找对象 findNewSupplier()
    update 更新对象 updateCommission()

    find方法在业务层尽量表达业务含义,比如 findUnsettledOrders(),查询未结算订单,而不要findOrdersByStatus()。 数据访问层,find,update等方法可以表达要执行的sql,比如findByStatusAndSupplierIdOrderByName(Status.PAID, 345)

    1.5 域(field)名

    1.5.1 静态常量

    全大写用下划线分割,如


    public static find String ORDER_PAID_EVENT = "ORDER_PAID_EVENT";

    1.5.2 枚举

    全大写,用下划线分割,如

    public enum Events {
    ORDER_PAID,
    ORDER_CREATED
    }

    1.5.3 其他

    首字母小写,骆驼法则,如:

    public String orderName;

    1.6 局部变量名

    参数和局部变量名首字母小写,骆驼法则。尽量不要和域冲突,尽量表达这个变量在方法中的意义。

    2. 代码格式

    用空格字符缩进源代码,不要用tab,每个缩进4个空格。

    2.1 源文件编码

    源文件使用utf-8编码,结尾用unix n 分格。

    2.2 行宽

    行宽度不要超过130。

    2.3 包的导入

    删除不用的导入,尽量不要使用整个包的导入。在eclipse下经常使用快捷键 ctrl+shift+o 修正导入。

    2.4 类格式

    2.5 域格式

    每行只能声明一个域。
    域的声明用空行隔开。

    2.5 方法格式

    2.6 代码块格式

    2.6.1 缩进风格

    大括号的开始在代码块开始的行尾,闭合在和代码块同一缩进的行首,例如:

    package com.test;

    public class TestStyle extends SomeClass implements AppleInter, BananaInter {
    public static final String THIS_IS_CONST = "CONST VALUE";

    private static void main(String[] args) {
    int localVariable = 0;
    }

    public void compute(String arg) {
    if (arg.length() > 0) {
    System.out.println(arg);
    }

    for (int i = 0; i < 10; i++) {
    System.out.println(arg);
    }

    while (condition) {

    }

    do {
    otherMethod();
    } while (condition);

    switch (i) {
    case 0:
    callFunction();
    break;
    case 1:
    callFunctionb();
    break;
    default:
    break;
    }
    }
    }

    2.6.2 空格的使用

    2.6.2.1 表示分割时用一个空格

    不能这样:

    if ( a > b ) {
    //do something here
    };

    2.6.2.2 二元三元运算符两边用一个空格隔开

    如下:

    a + b = c;
    b - d = e;
    return a == b ? 1 : 0;

    不能如下:


    a+b=c;
    b-d=e;
    return a==b?1:0;

    2.6.2.3 逗号语句后如不还行,紧跟一个空格

    如下:

    call(a, b, c);

    不能如下:

    call(a,b,c);

    2.6.3 空行的使用

    空行可以表达代码在语义上的分割,注释的作用范围,等等。将类似操作,或一组操作放在一起不用空行隔开,而用空行隔开不同组的代码, 如图:

    order = orderDao.findOrderById(id);

    //update properties
    order.setUserName(userName);
    order.setPrice(456);
    order.setStatus(PAID);

    orderService.updateTotalAmount(order);

    session.saveOrUpdate(order);

    上例中的空行,使注释的作用域很明显.

    • 连续两行的空行代表更大的语义分割。
    • 方法之间用空行分割
    • 域之间用空行分割
    • 超过十行的代码如果还不用空行分割,就会增加阅读困难

    3. 注释规范

    3.1 注释 vs 代码

    • 注释宜少二精,不宜多而滥,更不能误导
    • 命名达意,结构清晰, 类和方法等责任明确,往往不需要,或者只需要很少注释,就可以让人读懂;相反,代码混乱,再多的注释都不能弥补。所以,应当先在代码本身下功夫。
    • 不能正确表达代码意义的注释,只会损害代码的可读性。
    • 过于详细的注释,对显而易见的代码添加的注释,罗嗦的注释,还不如不写

    • 注释要和代码同步,过多的注释会成为开发的负担
    • 注释不是用来管理代码版本的,如果有代码不要了,直接删除,svn会有记录的,不要注释掉,否则以后没人知道那段注释掉的代码该不该删除。

    3.2 Java Doc

    表明类、域和方法等的意义和用法等的注释,要以javadoc的方式来写。Java Doc是个类的使用者来看的,主要介绍 是什么,怎么用等信息。凡是类的使用者需要知道,都要用Java Doc 来写。非Java Doc的注释,往往是个代码的维护者看的,着重告述读者为什么这样写,如何修改,注意什么问题等。 如下:

    /**
    * This is a class comment
    */
    public class TestClass {
    /**
    * This is a field comment
    */
    public String name;

    /**
    * This is a method comment
    */
    public void call() {

    }
    }

    3.3 块级别注释

    3.3.1 块级别注释,单行时用 //, 多行时用 /* .. */。

    3.3.2 较短的代码块用空行表示注释作用域

    3.3.3 较长的代码块要用


    /*------ start: ------*/

    /*-------- end: -------*/

    包围
    如:

    /*----------start: 订单处理 ------- */
    //取得dao
    OrderDao dao = Factory.getDao("OrderDao");

    /* 查询订单 */
    Order order = dao.findById(456);

    //更新订单
    order.setUserName("uu");
    order.setPassword("pass");
    order.setPrice("ddd");

    orderDao.save(order);
    /*----------end: 订单处理 ------- */

    3.3.4 可以考虑使用大括号来表示注释范围

    使用大括号表示注释作用范围的例子:

    /*----------订单处理 ------- */
    {
    //取得dao
    OrderDao dao = Factory.getDao("OrderDao");

    /* 查询订单 */
    Order order = dao.findById(456);

    //更新订单
    order.setUserName("uu");
    order.setPassword("pass");
    order.setPrice("ddd");

    orderDao.save(order);
    }

    3.4 行内注释

    行内注释用 // 写在行尾

    4 最佳实践和禁忌

    4.1 每次保存的时候,都让你的代码是最美的

    程序员都是懒惰的,不要想着等我完成了功能,再来优化代码的格式和结构,等真的把功能完成,很少有人会再愿意回头调整代码。

    4.2 使用log而不是System.out.println()

    log可以设定级别,可以控制输出到哪里,容易区分是在代码的什么地方打印的,而System.out.print则不行。而且,System.out.print的速度很慢。所以,除非是有意的,否则,都要用log。至少在提交到svn之前把System.out.print换成log。

    4.3 每个if while for等语句,都不要省略大括号{}

    看下面的代码:

    if (a > b)
    a++;

    如果在以后维护的时候,需要在a > b 时,把b++,一步小心就会写成:

    if (a > b)
    a++;
    b++;

    这样就错了,因为无论a和b是什么关系,b++都会执行。 如果一开始就这样写:

    if (a > b) {
    a++;
    }

    相信没有哪个笨蛋会把b++添加错的。而且,这个大括号使作用范围更明显,尤其是后面那行很长要折行时。

    4.4 善用TODO:

    在代码中加入 //TODO: ,大部分的ide都会帮你提示,让你知道你还有什么事没有做。比如:

    if (order.isPaid()) {
    //TODO: 更新订单
    }

    4.5 在需要留空的地方放一个空语句或注释,告述读者,你是故意的

    比如:

    if (!exists(order)) {
    ;
    }

    或:


    if (!exists(order)) {
    //nothing to do
    }

    4.6 不要再对boolean值做true false判断

    比如:

    if (order.isPaid() == true) {
    // Do something here
    }

    不如写成:

    if (order.isPaid()) {
    //Do something here
    }

    后者读起来就很是 if order is paid, .... 要比 if order's isPaid method returns true, … 更容易理解

    4.7 减少代码嵌套层次

    代码嵌套层次达3层以上时,一般人理解起来都会困难。下面的代码是一个简单的例子:

    public void demo(int a, int b, int c) {
    if (a > b) {
    if (b > c) {
    doJobA();
    } else if (b < c) {
    doJobB()
    }
    } else {
    if (b > c) {
    if (a < c) {
    doJobC();
    }
    }
    }
    }

    减少嵌套的方法有很多:

    • 合并条件
    • 利用 return 以省略后面的else
    • 利用子方法

    比如上例,合并条件后成为:

    public void demo(int a, int b, int c) {
    if (a > b && b > c) {
    doJobA();
    }
    if (a > b && c > b) {
    doJobB();
    }
    if (a <= b && c < b && a < c) {
    doJobC();
    }
    }

    如果利用return 则成为:

    public void demo(int a, int b, int c) {
    if (a > b) {
    if (b > c) {
    doJobA();
    return;
    }
    doJobB()
    return;
    }

    if (b > c) {
    if (a < c) {
    doJobC();
    }
    }
    }

    利用子方法,就是将嵌套的程序提取出来放到另外的方法里。

    4.8 程序职责单一

    关注点分离是软件开发的真理。人类自所以能够完成复杂的工作,就是因为人类能够将工作分解到较小级别的任务上,在做每个任务时关注更少的东西。让程序单元的职责单一,可以使你在编写这段程序时关注更少的东西,从而降低难度,减少出错。

    4.9 变量的声明,初始化和被使用尽量放到一起

    比方说如下代码:

    int orderNum= getOrderNum();

    //do something withou orderNum here

    call(orderNum);

    上例中的注释处代表了一段和orderNum不相关的代码。orderNum的声明和初始化离被使用的地方相隔了很多行的代码,这样做不好,不如这样:

    //do something withou orderNum here

    int orderNum= getOrderNum();
    call(orderNum);

    4.10 缩小变量的作用域

    能用局部变量的,不要使用实例变量,能用实例变量的,不要使用类变量。变量的生存期越短,以为着它被误用的机会越小,同一时刻程序员要关注的变量的状态越少。实例变量和类变量默认都不是线程安全的,局部变量是线程安全的。比如如下代码:

    public class OrderPayAction{
    private Order order;

    public void doAction() {
    order = orderDao.findOrder();
    doJob1();
    doJob2();
    }

    private void doJob1() {
    doSomething(order);
    }

    private void doJob2() {
    doOtherThing(order);
    }
    }

    上例中order只不过担当了在方法间传递参数之用,用下面的方法更好:

    public class OrderPayAction{

    public void doAction() {
    order = orderDao.findOrder();
    doJob1(order);
    doJob2(order);
    }

    private void doJob1(Order order) {
    doSomething(order);
    }

    private void doJob2(Order order) {
    doOtherThing(order);
    }
    }

    4.11 尽量不要用参数来带回方法运算结果

    比如:

    public void calculate(Order order) {
    int result = 0;
    //do lots of computing and store it in the result

    order.setResult(result);
    }

    public void action() {
    order = orderDao.findOrder();
    calculate(order);

    // do lots of things about order
    }

    例子中calculate方法通过传入的order对象来存储结果, 不如如下写:

    public int calculate(Order order) {
    int result = 0;
    //do lots of computing and store it in the result

    return result;
    }

    public void action() {
    order = orderDao.findOrder();
    order.setResult(calculate(order));

    // do lots of things about order
    }


    展开全文
  • 包含两个文档,阿里巴巴规范开发手册pdf,java开发代码规范word两个文件,帮助企业应用开发中,java代码规范
  • 最全的Java代码规范、格式化和checkstyle检查配置文档
  • java代码规范

    2019-09-23 15:51:18
    Java代码规范Java代码规范以SUN的标准Java代码规范为基础,为适应我们公司的实际需要,可能会做一些修改。本文档中没有说明的地方,请参看SUN Java标准代码规范。如果两边有冲突,以本文档为准。 1. 标识符...

    Java代码规范

     

    本Java代码规范以SUN的标准Java代码规范为基础,为适应我们公司的实际需要,可能会做一些修改。本文档中没有说明的地方,请参看SUN Java标准代码规范。如果两边有冲突,以本文档为准。

    1. 标识符命名规范

    1.1 概述

    标识符的命名力求做到统一、达意和简洁。

    1.1.1 统一

    统一是指,对于同一个概念,在程序中用同一种表示方法,比如对于供应商,既可以用supplier,也可以用provider,但是我们只能选定一个使用,至少在一个Java项目中保持统一。统一是作为重要的,如果对同一概念有不同的表示方法,会使代码混乱难以理解。即使不能取得好的名称,但是只要统一,阅读起来也不会太困难,因为阅读者只要理解一次。

    1.1.2 达意

    达意是指,标识符能准确的表达出它所代表的意义,比如: newSupplier, OrderPaymentGatewayService等;而 supplier1, service2,idtts等则不是好的命名方式。准确有两成含义,一是正确,而是丰富。如果给一个代表供应商的变量起名是 order,显然没有正确表达。同样的,supplier1, 远没有targetSupplier意义丰富。

    1.1.3 简洁

    简洁是指,在统一和达意的前提下,用尽量少的标识符。如果不能达意,宁愿不要简洁。比如:theOrderNameOfTheTargetSupplierWhichIsTransfered 太长, transferedTargetSupplierOrderName则较好,但是transTgtSplOrdNm就不好了。省略元音的缩写方式不要使用,我们的英语往往还没有好到看得懂奇怪的缩写。

    1.1.4 骆驼法则

    Java中,除了包名,静态常量等特殊情况,大部分情况下标识符使用骆驼法则,即单词之间不使用特殊符号分割,而是通过首字母大写来分割。比如: SupplierName, addNewContract,而不是 supplier_name, add_new_contract。

    1.1.5 英文 vs 拼音

    尽量使用通俗易懂的英文单词,如果不会可以向队友求助,实在不行则使用汉语拼音,避免拼音与英文混用。比如表示归档,用archive比较好, 用pigeonhole则不好,用guiDang尚可接受。

    1.2 包名

    使用小写字母如 com.xxx.settlment,不要 com.xxx.Settlement
    单词间不要用字符隔开,比如 com.xxx.settlment.jsfutil,而不要com.xxx.settlement.jsf_util

    1.3 类名

    1.3.1 首字母大写

    类名要首字母大写,比如 SupplierService, PaymentOrderAction;不要 supplierService, paymentOrderAction.

    1.3.2 后缀

    类名往往用不同的后缀表达额外的意思,如下表:

    后缀名 意义 举例
    Service 表明这个类是个服务类,里面包含了给其他类提同业务服务的方法 PaymentOrderService
    Impl 这个类是一个实现类,而不是接口 PaymentOrderServiceImpl
    Inter 这个类是一个接口 LifeCycleInter
    Dao 这个类封装了数据访问方法 PaymentOrderDao
    Action 直接处理页面请求,管理页面逻辑了类 UpdateOrderListAction
    Listener 响应某种事件的类 PaymentSuccessListener
    Event 这个类代表了某种事件 PaymentSuccessEvent
    Servlet 一个Servlet PaymentCallbackServlet
    Factory 生成某种对象工厂的类 PaymentOrderFactory
    Adapter 用来连接某种以前不被支持的对象的类 DatabaseLogAdapter
    Job 某种按时间运行的任务 PaymentOrderCancelJob
    Wrapper 这是一个包装类,为了给某个类提供没有的能力 SelectableOrderListWrapper
    Bean 这是一个POJO MenuStateBean

    1.4 方法名

    首字母小写,如 addOrder() 不要 AddOrder()
    动词在前,如 addOrder(),不要orderAdd()
    动词前缀往往表达特定的含义,如下表:

    前缀名 意义 举例
    create 创建 createOrder()
    delete 删除 deleteOrder()
    add 创建,暗示新创建的对象属于某个集合 addPaidOrder()
    remove 删除 removeOrder()
    init或则initialize 初始化,暗示会做些诸如获取资源等特殊动作 initializeObjectPool
    destroy 销毁,暗示会做些诸如释放资源的特殊动作 destroyObjectPool
    open 打开 openConnection()
    close 关闭 closeConnection()<
    read 读取 readUserName()
    write 写入 writeUserName()
    get 获得 getName()
    set 设置 setName()
    prepare 准备 prepareOrderList()
    copy 复制 copyCustomerList()
    modity 修改 modifyActualTotalAmount()
    calculate 数值计算 calculateCommission()
    do 执行某个过程或流程 doOrderCancelJob()
    dispatch 判断程序流程转向 dispatchUserRequest()
    start 开始 startOrderProcessing()
    stop 结束 stopOrderProcessing()
    send 发送某个消息或事件 sendOrderPaidMessage()
    receive 接受消息或时间 receiveOrderPaidMessgae()
    respond 响应用户动作 responseOrderListItemClicked()
    find 查找对象 findNewSupplier()
    update 更新对象 updateCommission()

    find方法在业务层尽量表达业务含义,比如 findUnsettledOrders(),查询未结算订单,而不要findOrdersByStatus()。 数据访问层,find,update等方法可以表达要执行的sql,比如findByStatusAndSupplierIdOrderByName(Status.PAID, 345)

    1.5 域(field)名

    1.5.1 静态常量

    全大写用下划线分割,如


    public static find String ORDER_PAID_EVENT = "ORDER_PAID_EVENT";

    1.5.2 枚举

    全大写,用下划线分割,如

    public enum Events {
    ORDER_PAID,
    ORDER_CREATED
    }

    1.5.3 其他

    首字母小写,骆驼法则,如:

    public String orderName;

    1.6 局部变量名

    参数和局部变量名首字母小写,骆驼法则。尽量不要和域冲突,尽量表达这个变量在方法中的意义。

    2. 代码格式

    用空格字符缩进源代码,不要用tab,每个缩进4个空格。

    2.1 源文件编码

    源文件使用utf-8编码,结尾用unix n 分格。

    2.2 行宽

    行宽度不要超过130。

    2.3 包的导入

    删除不用的导入,尽量不要使用整个包的导入。在eclipse下经常使用快捷键 ctrl+shift+o 修正导入。

    2.4 类格式

    2.5 域格式

    每行只能声明一个域。
    域的声明用空行隔开。

    2.5 方法格式

    2.6 代码块格式

    2.6.1 缩进风格

    大括号的开始在代码块开始的行尾,闭合在和代码块同一缩进的行首,例如:

    package com.test;

    public class TestStyle extends SomeClass implements AppleInter, BananaInter {
    public static final String THIS_IS_CONST = "CONST VALUE";

    private static void main(String[] args) {
    int localVariable = 0;
    }

    public void compute(String arg) {
    if (arg.length() > 0) {
    System.out.println(arg);
    }

    for (int i = 0; i < 10; i++) {
    System.out.println(arg);
    }

    while (condition) {

    }

    do {
    otherMethod();
    } while (condition);

    switch (i) {
    case 0:
    callFunction();
    break;
    case 1:
    callFunctionb();
    break;
    default:
    break;
    }
    }
    }

    2.6.2 空格的使用

    2.6.2.1 表示分割时用一个空格

    不能这样:

    if ( a > b ) {
    //do something here
    };

    2.6.2.2 二元三元运算符两边用一个空格隔开

    如下:

    a + b = c;
    b - d = e;
    return a == b ? 1 : 0;

    不能如下:


    a+b=c;
    b-d=e;
    return a==b?1:0;

    2.6.2.3 逗号语句后如不还行,紧跟一个空格

    如下:

    call(a, b, c);

    不能如下:

    call(a,b,c);

    2.6.3 空行的使用

    空行可以表达代码在语义上的分割,注释的作用范围,等等。将类似操作,或一组操作放在一起不用空行隔开,而用空行隔开不同组的代码, 如图:

    order = orderDao.findOrderById(id);

    //update properties
    order.setUserName(userName);
    order.setPrice(456);
    order.setStatus(PAID);

    orderService.updateTotalAmount(order);

    session.saveOrUpdate(order);

    上例中的空行,使注释的作用域很明显.

    • 连续两行的空行代表更大的语义分割。
    • 方法之间用空行分割
    • 域之间用空行分割
    • 超过十行的代码如果还不用空行分割,就会增加阅读困难

    3. 注释规范

    3.1 注释 vs 代码

    • 注释宜少二精,不宜多而滥,更不能误导
    • 命名达意,结构清晰, 类和方法等责任明确,往往不需要,或者只需要很少注释,就可以让人读懂;相反,代码混乱,再多的注释都不能弥补。所以,应当先在代码本身下功夫。
    • 不能正确表达代码意义的注释,只会损害代码的可读性。
    • 过于详细的注释,对显而易见的代码添加的注释,罗嗦的注释,还不如不写

    • 注释要和代码同步,过多的注释会成为开发的负担
    • 注释不是用来管理代码版本的,如果有代码不要了,直接删除,svn会有记录的,不要注释掉,否则以后没人知道那段注释掉的代码该不该删除。

    3.2 Java Doc

    表明类、域和方法等的意义和用法等的注释,要以javadoc的方式来写。Java Doc是个类的使用者来看的,主要介绍 是什么,怎么用等信息。凡是类的使用者需要知道,都要用Java Doc 来写。非Java Doc的注释,往往是个代码的维护者看的,着重告述读者为什么这样写,如何修改,注意什么问题等。 如下:

    /**
    * This is a class comment
    */
    public class TestClass {
    /**
    * This is a field comment
    */
    public String name;

    /**
    * This is a method comment
    */
    public void call() {

    }
    }

    3.3 块级别注释

    3.3.1 块级别注释,单行时用 //, 多行时用 /* .. */。

    3.3.2 较短的代码块用空行表示注释作用域

    3.3.3 较长的代码块要用


    /*------ start: ------*/

    /*-------- end: -------*/


    包围
    如:

    /*----------start: 订单处理 ------- */
    //取得dao
    OrderDao dao = Factory.getDao("OrderDao");

    /* 查询订单 */
    Order order = dao.findById(456);

    //更新订单
    order.setUserName("uu");
    order.setPassword("pass");
    order.setPrice("ddd");

    orderDao.save(order);
    /*----------end: 订单处理 ------- */

    3.3.4 可以考虑使用大括号来表示注释范围

    使用大括号表示注释作用范围的例子:

    /*----------订单处理 ------- */
    {
    //取得dao
    OrderDao dao = Factory.getDao("OrderDao");

    /* 查询订单 */
    Order order = dao.findById(456);

    //更新订单
    order.setUserName("uu");
    order.setPassword("pass");
    order.setPrice("ddd");

    orderDao.save(order);
    }

    3.4 行内注释

    行内注释用 // 写在行尾

    4 最佳实践和禁忌

    4.1 每次保存的时候,都让你的代码是最美的

    程序员都是懒惰的,不要想着等我完成了功能,再来优化代码的格式和结构,等真的把功能完成,很少有人会再愿意回头调整代码。

    4.2 使用log而不是System.out.println()

    log可以设定级别,可以控制输出到哪里,容易区分是在代码的什么地方打印的,而System.out.print则不行。而且,System.out.print的速度很慢。所以,除非是有意的,否则,都要用log。至少在提交到svn之前把System.out.print换成log。

    4.3 每个if while for等语句,都不要省略大括号{}

    看下面的代码:

    if (a > b)
    a++;


    如果在以后维护的时候,需要在a > b 时,把b++,一步小心就会写成:

    if (a > b)
    a++;
    b++;


    这样就错了,因为无论a和b是什么关系,b++都会执行。 如果一开始就这样写:

    if (a > b) {
    a++;
    }


    相信没有哪个笨蛋会把b++添加错的。而且,这个大括号使作用范围更明显,尤其是后面那行很长要折行时。

    4.4 善用TODO:

    在代码中加入 //TODO: ,大部分的ide都会帮你提示,让你知道你还有什么事没有做。比如:

    if (order.isPaid()) {
    //TODO: 更新订单
    }

    4.5 在需要留空的地方放一个空语句或注释,告述读者,你是故意的

    比如:

    if (!exists(order)) {
    ;
    }

    或:


    if (!exists(order)) {
    //nothing to do
    }

    4.6 不要再对boolean值做true false判断

    比如:

    if (order.isPaid() == true) {
    // Do something here
    }


    不如写成:

    if (order.isPaid()) {
    //Do something here
    }


    后者读起来就很是 if order is paid, .... 要比 if order's isPaid method returns true, … 更容易理解

    4.7 减少代码嵌套层次

    代码嵌套层次达3层以上时,一般人理解起来都会困难。下面的代码是一个简单的例子:

    public void demo(int a, int b, int c) {
    if (a > b) {
    if (b > c) {
    doJobA();
    } else if (b < c) {
    doJobB()
    }
    } else {
    if (b > c) {
    if (a < c) {
    doJobC();
    }
    }
    }
    }


    减少嵌套的方法有很多:

    • 合并条件
    • 利用 return 以省略后面的else
    • 利用子方法

    比如上例,合并条件后成为:

    public void demo(int a, int b, int c) {
    if (a > b && b > c) {
    doJobA();
    }
    if (a > b && c > b) {
    doJobB();
    }
    if (a <= b && c < b && a < c) {
    doJobC();
    }
    }


    如果利用return 则成为:

    public void demo(int a, int b, int c) {
    if (a > b) {
    if (b > c) {
    doJobA();
    return;
    }
    doJobB()
    return;
    }

    if (b > c) {
    if (a < c) {
    doJobC();
    }
    }
    }


    利用子方法,就是将嵌套的程序提取出来放到另外的方法里。

    4.8 程序职责单一

    关注点分离是软件开发的真理。人类自所以能够完成复杂的工作,就是因为人类能够将工作分解到较小级别的任务上,在做每个任务时关注更少的东西。让程序单元的职责单一,可以使你在编写这段程序时关注更少的东西,从而降低难度,减少出错。

    4.9 变量的声明,初始化和被使用尽量放到一起

    比方说如下代码:

    int orderNum= getOrderNum();

    //do something withou orderNum here

    call(orderNum);

    上例中的注释处代表了一段和orderNum不相关的代码。orderNum的声明和初始化离被使用的地方相隔了很多行的代码,这样做不好,不如这样:

    //do something withou orderNum here

    int orderNum= getOrderNum();
    call(orderNum);

    4.10 缩小变量的作用域

    能用局部变量的,不要使用实例变量,能用实例变量的,不要使用类变量。变量的生存期越短,以为着它被误用的机会越小,同一时刻程序员要关注的变量的状态越少。实例变量和类变量默认都不是线程安全的,局部变量是线程安全的。比如如下代码:

    public class OrderPayAction{
    private Order order;

    public void doAction() {
    order = orderDao.findOrder();
    doJob1();
    doJob2();
    }

    private void doJob1() {
    doSomething(order);
    }

    private void doJob2() {
    doOtherThing(order);
    }
    }

    上例中order只不过担当了在方法间传递参数之用,用下面的方法更好:

    public class OrderPayAction{

    public void doAction() {
    order = orderDao.findOrder();
    doJob1(order);
    doJob2(order);
    }

    private void doJob1(Order order) {
    doSomething(order);
    }

    private void doJob2(Order order) {
    doOtherThing(order);
    }
    }

    4.11 尽量不要用参数来带回方法运算结果

    比如:

    public void calculate(Order order) {
    int result = 0;
    //do lots of computing and store it in the result

    order.setResult(result);
    }

    public void action() {
    order = orderDao.findOrder();
    calculate(order);

    // do lots of things about order
    }

    例子中calculate方法通过传入的order对象来存储结果, 不如如下写:

    public int calculate(Order order) {
    int result = 0;
    //do lots of computing and store it in the result

    return result;
    }

    public void action() {
    order = orderDao.findOrder();
    order.setResult(calculate(order));

    // do lots of things about order
    }

    展开全文
  • java课程资料,开发文档代码规范,请需要的人下载,可以免费传播!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,721
精华内容 688
热门标签
关键字:

java代码规范文档

java 订阅