编码规范对于程序员而言尤为重要，有以下几个原因：
- 一个软件的生命周期中，80%的花费在于维护。
- 几乎没有任何一个软件，在其整个生命周期中，均由最初的开发人员来维护。
- 编码规范可以改善软件的可读性，可以让程序员尽快而彻底地理解新的代码。
一：不允许使用汉语拼音命名
欠规范代码示例：
public void zengJiaYongHu(){} //拼音方法名称规范代码示例:
public void addUser(){}
解析：命名应使用国际化语言，拼音会使得代码显得很别扭。
二：Package名必须全部小写，并且一定要域名的反转，尽量使用单个单词，不要以关键字 或者熟悉的词开头，譬如java.avax.ognl，不然会引起莫名其妙的异常。**
欠规范代码示例：
com.lxit.DAOImpl //单词大写了
DAOImpl //涉及多个单词
规范代码示例:
com.xxcompany.dao.impl
解析：这是一个大家都认同的习惯写法，也是一个默认的规范。
三：局部变量及输入参数不要与类成员变量同名(get/set方法与构造函数除外)
欠规范代码示例：
//类字段和方法参数名相同
public class UserDAOImpl{
private int count;
pubic void page(int count){}
} 规范代码示例:
public class UserDAOImpl{
private int count;
pubic void page(int pageCount){}
}解析：类变量会引起逻辑错误，引起覆盖。
四：尽量不要在变量后面加魔法数字，英文单个字母和没有实际意义的英文数字单词来区分变量
欠规范代码示例：
String One; // 命名一个英文数字的变量
User user1 = new User();
User user2 = new User();规范代码示例：
User userAdd = new User();
User userUpdate = new User();解析：这样会降低代码的可读性，非常不利与日后维护。
五：包，类，变量命名不要加下划线（常量除外）
欠规范代码示例：
com.tag_test.dao.jdbc_impl //有下划线的包名
int user_age ; //带下划线的变量名
public class Class_ {} //带下划线的类名规范代码示例:
com.tag.test.dao.jdbc.impl
int userAge ;
public class Classes {}六：常量命名要大写,单词之间要用下划线分开.
欠规范代码示例：
public static final String teamAdd = "teamAdd"; //小写且没有下划线规范代码示例:
public static final String TEAM_ADD = "teamAdd";解析：容易区分变量和常量
七：方法名第一个字母小写（构造方法除外）
欠规范代码示例：
public void Function(){} //大写的方法名规范代码示例:
public void function(){}解析：习惯用法，默认的规范
八：两个单词以上的变量名要驼峰命名
欠规范代码示例：
int userage; //age 单词'a' 小写规范代码示例：
int userAge；解析：能够更清晰的看懂变量所带代表的意思。
九：每个变量要用别人看得懂的词语来描述，尽量不要省略。
欠规范代码示例：
private Student stu; //把student 简写成 stu规范代码示例:
private Student student；解析：使代码看起来清晰易懂。
**十:类的命名一般是名词(有些ing的动词,形容词除外)，并且是单数，变量名也是一样。
函数的命名必须是动宾短语(构造词除外).**
欠规范代码示例：
public class Manage{} // 动词类命规范代码示例:
public class UserManager {}解析：能使别人一看到类名就知道这个类大概是做什么的。
**十一：数据库连接对象的生成不能跟Model层混搅，必须将其放在一个单独的类里，
用单例模式来实现数据库的连接:**
欠规范代码示例：
public class UserDAOImpl(){
private static Connection connection;
public static synchronized Connection getConnection() {
if (connection == null) {
try{}catch (SQLException e){}
catch (ClassNotFoundException e)
{ e.printStackTrace() }
}
return connection;
}
}规范代码示例:
public class DBConnectionTools {
private static Connection connection;
private DBConnectionTools(){}
public static synchronized Connection getConnection() {
if (connection == null) {
try {
Class.forName(Constants.MYSQL_DRIVER);
connection = DriverManager.getConnection(Constants.MYSQL_URL, Constants.MYSQL_USER_NAME,
Constants.MYSQL_PASSWORD);
}catch (SQLException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
return connection;
}
}解析：Connection对象应当单独进出，以便其它类可以复用。
十二： id一般不用int类型，用Long类型
欠规范代码示例：
int id; //int 类型的关于人员的id规范代码示例:
Long id;解析：随着id的增长，当增长的id超出int的范围的时候就会出现异常
十三：sql语句一定要用占位符，不能用拼写组成的语句
欠规范代码示例：
public void addUser(User user){
String sql="insert into student(ID,name,sex,address) values("+user.getId()+","+user.getName()+","+user.getSex()+","+user.getAddress()+")" ;
//？则代表占位符
}规范代码示例:
public void addUser()
{
sql="insert into student(ID,name,sex,address) values(?,?,?,?)"
}解析：很容易出现错误，而且不清晰，不容易让人读懂。
十四：当一个变量在每个方法里面使用,并且每个方法里面包含的内容不一样,那么这个变量不要用字段变量,要用局部变量,譬如PreparedStatement 最好不要声明为类字段.
欠规范代码示例：
public class UserDAOImpl()
{
private PreparedStatement preparedStatement;
}规范代码示例:
public class UserDAOImpl{
public void addUser(){
PreparedStatement preparedStatement =new PreparedStatement(sql);
}
}解析：虽然很多类都使用到了PrepareStatement对象，但各个方法里用到的PrepareStatement对象都是不同的， 所以不能作为类字段，抽取出来做类字段的话会出现数据混乱的问题。
十五：做主键的列没有任何业务逻辑，没有任何实际意义，而且任何时候都不能修改。
欠规范主键示例：主键用一个身份证号码，或者学号
规范主键示例：主键用id，唯一性的，不可改变的。
解析：虽然身份证号码和学号也是唯一性的，但是他们是有意义的列，而且在程序升级时是可以更改的，而id主要就是用来做主键的。
十六：取记录的时候，拿数据库条件语句去比较，不要自己用Java代码去比较.
欠规范代码示例：
public void deleteById(Long id){
String sql = "select id,name,age from user";
//........................
ResultSet result = ResultSet.executeQuery();
where(result.next()){
if(result.getLong("id")==id){
//..........................................删除
}
}
}规范代码示例:
public void deleteById(Long id)
{
String sql = "delete from user where id = ?";
//删除操作
}解析：一旦取出的数据量过大，而用java代码的if判断的话，会影响运行速率，还可能导致内存不足等错误。
二十二：两个不同的包不能出现相同的文件名
欠规范示例：
packge com.lxitedu.work.MyWork.java
packge com.lxitedu.task.MyWork.java
规范示例：
packge com.lxitedu.work.MyWork.java
packge com.lxitedu.task.Work.java
解析：当系统规模到一定程度时，很可能引起混淆
二十三：提交代码前如果有TODO标签,要删除掉,如果要标记没有做完的任务或者以后要改进的任务,用LXTODO.
二十四：注释掉的代码提交前要删除,一般删除自己的注释的代码,但不要删除别人注释的代码。
欠规范代码示例：
/*
public void add(){
if(true){
System.out.println("这段代码已
经给注释掉了，程序中没有用到");
}
}
*/ 提交前没有删除这段代码
规范代码示例：删掉就行了
解析：既然代码在程序中没有用到的话就要删除，以免其他开发人员误解和浪费他人时间来读这段代码。
二十六：PreparedStatement、ResultSet、Statement.对象用完之后必须进行调用close()将会关闭(在finally关闭),立即释放此 Statement 对象的数据库和 JDBC 资源，不然会占用系统很多资源.
// 此规范可以用适配器模式解决，不必手动去关闭了
二十七：尽量不要在构造方法里初始化代码.
欠规范代码示例：
public class Person{
public Person(){
Person person = new Person();
add();
}
}规范代码示例:
public class Person{
public Person()
Unknown macro: { //尽量少做些不必要的事情 }
}解析：因为在构造器里初始化没办法控制，构造器多了也容易出现混乱。如果有反射机制，也许会跳过构造方法。
二十八：函数的返回值类型（如果有的话）要和其功能相匹配，要符合常规思维.
欠规范代码示例：
//得到一个用户的姓名
public String getPeopleName（）
{
return "userName";
}规范代码示例:
//得到一个用户的姓名的方法
public String getUserName(){
return "userName";
}解析：是得到一个用户的姓名，而不是得到一个人的姓名，因为人不一定是用户，所以用getUserName更准确一点
二十九：内部类的变量不要设为全局变量(public 字段变量)，尽量少用全局变量,多用局部变量
欠规范代码示例：
public class Test {
class InnerClass{
public String string="HELLO WORD!";
public void print(){
System.out.println(string);
}
}
}规范代码示例:
public class Test {
class InnerClass{
public void print(){
String string="HELLO WORD!";
System.out.println(string);
}
}
}解析：暂无
三十：如果是布尔型的变量则最好在命名用is或has开头。例如：isVisible,isExists等.
欠规范代码示例：
boolean flag=resultSet.next();规范代码示例:
boolean hasNext=resultSet.next();解析：难懂，且没有任何意义。
三十一：如果变量命名要加注释，说明命名不是很准确(如果公司需要强制写注释，或者这个变量比较复杂除外)。
欠规范代码示例
//配置文件的路径
String path="java/tomcat/web.txt";规范代码示例:
String configFilePath="java/tomcat/web.txt";解析：命名清晰可以增强代码的可读性，节省编辑和阅读时间。
三十二：任何类字段除非必要(例如常量)，否则都要私有化.
欠规范代码示例：
public class Person
{
String name;
String sex;
int age;
}规范代码示例:
public class ClassName
{
private String name;
private String sex;
private int age;
}解析：没有为程序的安全考虑。可以被其他的类访问。
三十三：尽量减少一个类属性的作用域，在离使用它的最近的地方定义.
欠规范代码示例：
int index = 1;//类似这种情况 变量生命离使用地方有点远
String sql = "insert into student(ID,name,password,sex,address) values(?,?,?,?,?)";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(index++, user.getID());
preparedStatement.setString(index++, user.getName());
preparedStatement.setString(index++, user.getPassword());
preparedStatement.setString(index++, user.getSex());
preparedStatement.setString(index++, user.getAddress());
preparedStatement.executeUpdate();
preparedStatement.close();规范代码示例:
String sql = "insert into student(ID,name,password,sex,address) values(?,?,?,?,?)";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
int index = 1;
preparedStatement.setString(index++, user.getID());
preparedStatement.setString(index++, user.getName());
preparedStatement.setString(index++, user.getPassword());
preparedStatement.setString(index++, user.getSex());
preparedStatement.setString(index++, user.getAddress());
preparedStatement.executeUpdate();
preparedStatement.close();解析：当别人维护易引起混淆，容易引发错误
三十四：单例模式的使用必须要考虑到同步.
欠规范代码示例：
//没有使用到同步
public static Connection getConnection() throws ClassNotFoundException, SQLException{
if(conn==null){
Class.forName("com.p6spy.engine.spy.P6SpyDriver");
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root", "root");
}
return conn;
} 规范代码示例:
//最熟悉的得到一个Connection连接
public static synchronized Connection getConnection() throws ClassNotFoundException, SQLException{
if(conn==null){
Class.forName("com.p6spy.engine.spy.P6SpyDriver");
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root", "root");
}
return conn;
}解析：当有多个用户并发使用的时候会造成数据混乱，导致线程不安全
三十五：方法里面参数最好不要超过三个.
欠规范代码示例：
public void update (int id ,String name,String code,String sex)
{
// ........
}规范代码示例:
public void update (int id,String name,String sex)
{
// .........
}or：如果超过三个 必须把数据封装成一个pojo
如下把上面update方法中参数封装起来
public class User(){
private int id;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code= code;
}
public void setId(int id) {
this.id = id;
}
public int getId() {
return id;
}
}
public void update (User user)
{
//.......
}
解析：参数多容易出现错误。尤其是调用的时候，如果参数的顺序传错了，将是一个非常大的麻烦，而且没有拓展性。
三十六：值类或值对象(bean)必须重写toString方法.
欠规范代码示例：
public class Code {
private int id;
private String name;
private String sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return viscera;
}
public void setSex(String sex) {
this.viscera = viscera;
}
public void setId(int id) {
this.id = id;
}
public int getId() {
return id;
}
}规范代码示例：
public class Person{
private int id;
private String name;
private String sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex= sex;
}
public void setId(int id) {
this.id = id;
}
public int getId() {
return id;
}
public String toString() {
return new StringBuffer().append(id+",").append(name+",").append(sex).toString();
}
}解析：toString的作用是一字符串的形式来返回它的实例信息，因为不同的类的信息是不同的，所以要重写，不能全部都继承Object的toString方法。
三十七：重写equals方法的时候，必须重写hashCode方法.
欠规范代码示例：
public class People
{
//必要的属性
//必要的get和set方法
//toString 方法
//没有hashCode方法
//没有equals方法
}规范代码示例:
public class People{
//必要的属性
//必要的get和set方法
//toString 方法
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((viscera == null) ? 0 : viscera.hashCode());
return result;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Code other = (Code) obj;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (viscera == null) {
if (other.viscera != null)
return false;
}else if (!viscera.equals(other.viscera))
return false;
return true;
}
}解析：重写equals和hashcode方法是为了像Set一样不能存储重复的元素，实现serializable是为了使这个类可以序列化。
三十八：单元测试的时候必须是对象比较,如果一个字段有100个字，有时候数据库会自动删除一些，此时我们就不知道程序那出bug了。
三十九：单元测试类名后面要加Test.
欠规范代码示例：
//这是一个UserDAO的单元测试类
public class UserDAO{}规范代码示例:
public class UserDAOTest{}解析：这样写让别人知道这个类是用做测试的，清晰易懂。
四十：操作提示颜色，成功用蓝色字体，错误用红色字体.
四十一：控制层不能调用model层除了最顶级的接口外任何内容。要通过new顶级接口才能调用
欠规范代码示例：
public class UserServiceImpl{
private UserDAOImpl userDAOImpl;
public UserServiceImpl(){
userDAOImpl = new UserDAOImpl();
}
public void deleteById(Long id){
userDAOImpl.deleteById(id);
}
}规范代码示例:
public class UserServiceImpl{
private UserDAOuserDAO;
public UserServiceImpl(){
userDAO = DAOFactory.getUserDAO();
}
public void deleteById(Long id){
userDAO.deleteById(id);
}
}解析：这样做不仅是为了程序的灵活着想，更是为了使代码的层次结构清晰明了
四十二：返回类型尽量是父类接口或是抽象类，例如：要取得一个arrayList对象，则返回类型要用List。
欠规范代码示例：
//返回一个只能是保存User对象元素的list public ArrayList query(){
ArrayList arrayList=new ArrayList();
………………………………
return arrayList;
}
规范代码示例:;
public List query(){
List list=new ArrayList();
………………………………
return list;
}
解析：扩大对象的接受范围，更有拓展性。
四十三：SQL程序里命名要注意，不能把关键词作为属性.
欠规范代码示例：
create tableName{
id bigint primary key,
describe varchar(20)
} 规范代码示例:
creat tableName{
id bigint not null primary key,
classDescribe varchar(20)
}解析:SQL语句里字段名为关键字时，执行时就可能会出现问题，出错了很难找，所以在开始的时候就要注意。
四十四：使用try…catch时，一般在finally里面的close()可以不捕获异常,但一定要在catch处理异常(类似于治病打麻醉药)
欠规范代码示例：
try {
//代码块
}catch (Exception e) {
}规范代码示例:
try {
//代码块
}catch (Exception e) {
e.printStackTrace();
}解析:如果程序出现了异常，而catch块又没有任何错误输出，那么你的程序将永远不会报错，就无法发现错误,但是你的程序总是有问题的，却又很难发现错误在哪里。
四十五：当能够用工厂实例化对象的时候不要用构造器生成对象，要用工厂方法去代替。
欠规范代码示例：
UsreDAO userDAO = new UserDAOImpl();规范代码示例:
UserDAO userDAO = DAOFactory.getUserDAO();解析：为了程序扩展性考虑，当构造器里的改变的时候，比如说增加一个参数，可能会因为系统过于庞大而忘记了修改，而用工厂模式可以一劳永逸。
四十六：属性不能成为一个类 也不能成为一个函数名。
欠规范代码示例：
public class Name{
public void sex(){
// - - -
}
}规范代码示例
public class Person{
public void addPerson(){
// - - -
}
}解析：对象的属性只能作为属性，不能单独做一个类。
四十七：如果一个方法的返回值是用来做判断的，返回值最好不要用字符串，要用int，
欠规范代码示例：
//比如说修改后要提示修改该成功
public String updateUser(User user){
………………………………
if(true){
//成功
return “修改成功”;
}else{
//失败
return “”修改失败;
}
}
规范代码示例:
public int updateUser(User user){
………………………………
if(){
//成功
return 1;
}else{
//失败
return 0;
}
}
解析：因为字符串容易引发潜在的错误，比如失误的操作使得字符串多了个空格等等。
四十八：在eclipse中，一次启动的工程最好不要超过两个以上。
不可取的操作：
在tomcat中一次加载多个（两个以上）工程
正确的操作：
加载的工程最多不要超过两个，不用的工程关闭
解析：启动多了占用资源，出错了检查也不方便，也容易起冲突。
五十一：在类中，重复了两次以上且公用的变量一般都要抽出成为类字段。
欠规范代码示例：
public class ClassDAOImpl{
public void addClass()
{
Connection conn=Tools.getConnection();
}
public void deleteById(int ID){
Connection conn = Tools.getConnection();
}
} 规范代码示例：
public class ClassDAOImpl{
private Connection conn;
public void addClass()
{
conn = Tools.getConnection();
}
public void deleteById(int ID){
conn = Tools.getConnection();
}
// ............
}解析：增强代码的可读性。
五十二：程序代码中不要出现魔法数字。
欠规范代码示例：
if(mark==6){
System.out.println("6是魔法数字。");
}规范代码示例：
int addOperation=6; //声明一个变量表示数字6所代表的含义
if(mark==addOperation){
System.out.println("this is add handle");
}解析：凭空出现的数字没人知道它是什么。很难使人读懂。
五十三：数据库语句中,不要用*来代替也不能出现用变量拼写的语句
欠规范代码示例：
//一个sql查询语句
String sql = "select * from student where id ="+ user.getId();规范代码示例：
String sql = "select id,name,sex,age from student where id =?";解析：
1.用属性名而不用*让语句看起来更加清析易懂。
2.在增加或删除属性的时候出错的机率更少，也容易找出问题来。
3.一般情况不要去拼凑sql语句，有SQL注入的风险，应当用占位符，预处理来发送sql语句；
4. 请按需取值，能用字段就用字段，尽量避免全表扫描。
五十四：方法命名的时候一定要力求精准。
比如:查询的时候要命名为queryAll或者queryByID.
欠规范代码示例：
//查询所有用户如果有多个查询方法的话
public void query(){- - - } //未免太过模糊 规范代码示例：
//根据ID来查找用户；
public void queryById(){ //代码块 }
//查询所有用户
public void queryAll(){} 解析：方法命名应做到别人一眼就能读懂其用途。
五十五: 有返回类型的方法,不能返回一个null
欠规范代码示例：
//返回类型为null的
public static StudentDAO getStudentDAO(String type) {
if(DAOFactory.DAO_TYPE_JDBC.equals(type)){
return new StudentDAOJdbcImpl();
}
return null;
}规范代码示例：
//返回一个自定义的异常 public static StudentDAO getStudentDAO(String type) {
if(DAOFactory.DAO_TYPE_JDBC.equals(type)){
return new StudentDAOJdbcImpl();
}
return new LxitException();
}解析：一个方法有返回类型,就不能返回null或0，如果要返回null时或0，则要写一个自定义的异常，返回这个自定义异常。
五十六: 类里面不能写空方法.如果有必要,则在方法里面要加一个注释
欠规范代码示例：
//写了一个空的方法
public void init(){ } 规范代码示例：
//在方法里面加上注释
public void init(){ //TODO 该方法还没有写完,待完成. } 解析：如果一个方法里面什么都没有写，那么要删除.。如果是实现过来的必须要重写该方法但不实现其功能的，应该要加注释。
五十七:如果是在Person 类里面,写增加方法就不用加后缀了。
欠规范代码示例：
//本类里面写增加方法还加了后缀 public Person addPerson(){
Person person = new Person();
......
return person;
}规范代码示例：
//本类里面增加方法直接用add 就可以了 public Person add(){
Person person = new Person();
......
return person;
}解析：在本类里面增加方法则不需要在后面加类名作为后缀了，删除，修改，查询也是一样。
五十八:用Long来定义ID要比用基本类型long要好
欠规范代码示例：
long id;
规范代码示例：
Long id;
解析：Long初始化后返回的是null。long初始化后返回的是0，是有值的，等价于赋了默认值给它。
五十九:逻辑表达式里有多个判断可能时要用小括号括起来
欠规范代码示例：
if(id!=null&&id!=""){}规范代码示例：
if((id!=null) && (id!="")){}六十:如果性能要求比较高，就要用StringBuffer.append进行字符串拼接，在不影响性能的情况下用加号连接字符串是允许的。
六十一:每个模块都会用到的代码要放到 公共包 （base包里），而不是某个模块的公共包里。放置位置应按常识来安排
六十二:属性里的set和get方法要用 自动生成 的，不要手动更改，在eclipse里有很多自动生成的方法会相互依据，一旦更改再自动生成会出现问题。
六十三:常量类里的属性修饰不能私有化,不需要public,不需要static
欠规范代码示例：
public interface Constant(){
private static final String URL="/image/";
}规范代码示例：
public interface Constant(){
String URL="/image/";
}解析：常量类里的常量本来就是为了方便才提取出来放到它里面的，要是私有再使用方法得到就违背了它的原则
六十四:类变量初始化时不可直接调用方法
欠规范代码示例：
public interface Constant(){
private Connection connection=DBtool.getConnection();
}规范代码示例：
public interface Constant(){
private Connection connection=null;
}解析：容易发生死循环。
六十五:在catch(打印异常)里打印的log4j要用error方法
解析：提高它的错误级别，以便以后更改打印的错误级别也能打印
六十六:常量类要用接口，而且默认的修饰不用写
欠规范代码示例：
public class Constant(){ //...代码 } 规范代码示例：
public interface Constant(){ //...代码 } 六十七:当一个表达式超过两个时就要用变量抽取出来，并且变量名就是这个表达式的意思，让人更能够清晰的看出表达式所表达的意思
六十八:不要随便更改windows里的主题和显示颜色，容易于eclipse里发生混淆。
六十九:不可以同时打开两个eclipse，容易在eclipse之间发生混淆。
七十：常量类里的每一项都要添加注释，便于维护和增强代码的可读性。
七十一：简单的表达式要用内联(Inline)，复杂表达式抽取为变量，变量名就是注释。
欠规范的代码：
public void getUserName(){
User user=new User();
String userName=user.getName();
returen userName;
}规范代码：
public void getUserName(){
User user=new User();
returen user.getName();
}七十二：不能用单个字母命名
错误代码
Goods g=(Goods)objects[0];正确代码
Goods goods=(Goods)objects[0];解析：除非是循环迭代用的临时变量，不然请避免这种命名。
七十三：集合或者数组后面要加s或者后缀list set等
错误代码
private String[] user;正确代码
private String[] users;七十四：不要在系统里面写System.out.println
解析：System.out.print直接回打印到控制台，一个是影响性能，另外客户端输出很多客户看不懂的数值，所以一般用Log4j来代替，它可以解决这个问题。
七十五：不要在控制台直接打出异常
错误代码：
} catch (SQLException e) {
// EEE 异常不能直接打印,要捕获
e.printStackTrace();
}
正确代码
} catch (SQLException e) {
logger.error(e);
}七十六：如果一个属性是数值类型，那么就用数值类型定义这个变量，如果是是否类型，那么就要用boolean去定义这个数值，千万不要用String。
错误代码：
private String count;正确代码
private int count;七十七：Eclipse如果有黄色警告，尽量要解决，黄色警告就代表着风险，要及时处理，避免积小成大。
七十八：当一个常量和变量用equals比较的时候，常量在先。
欠规范的代码:
if ( (userName != null) && (password != null) && (!userName.equals("")) && (!password.equals("")) ) {
status = shoppingService.register(userName, password);
}正确代码:
if ( (!"".equals(userName)) && (!"".equals(password)) ) {
status = shoppingService.register(userName, password);
}解析：如果变量在先的话，如果这个变量为null，会抛空指针异常。
七十九：尽量避免 不需要的强转。
解析：如果一定要转，要长度小的转长度大的，子类转化成父类或者父接口，否则会有溢出的风险。
八十:如果要用一个常量接口里面的常量，不要去实现这个接口来获得常量，会造成耦合度高，代码污染，正确的做法是用<接口.常量>来引用。
欠规范的代码：
public interface ActionResultName {
//用于ShoppingAction类中 的字符串常量,login 表示 返回 购物车系统的登录页面
String SHOPPING_LOGIN="login";
}
public class ShoppingAction implements ActionResultName{
method（）{
...
return SHOPPING_LOGIN;
} 规范代码:
public class ShoppingAction {
method（）{
...
return ActionResultName.SHOPPING_LOGIN;
}
}八十一：对于一些Bean，如果不是命名重复或者有特殊意义的情况，就不要在Bean后面加上Info ，Data等通用名称。
欠规范的代码：
UserInfo userInfo=new UserInfo();规范代码：
User user=new User();
4933
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
