Java编码规范

编码规范对于程序员而言尤为重要，有以下几个原因：

• 一个软件的生命周期中，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();