zoukankan      html  css  js  c++  java

  • Java代码规范

    一：不允许使用汉语拼音命名
    欠规范代码示例：
        public void zengJiaYongHu(){}  拼音方法名称
    规范代码示例:
        public void addUser(){}
        解析：应当使用国际化语言，拼音使得代码难懂

    二：Package名必须全部小写，并且一定要域名的反转,尽量使用单个单词,不要以关键字或者熟悉的词开头,譬如java,javax,ognl,不然会引起莫名其妙的异常
    欠规范代码示例：    
        com.lxit.daoImpl  单词大写了,daoImpl多个单词 java.manager ognl.test.
      规范代码示例:
        com.easytopit.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;
         }
     }

     

        解析：数据库连接应当单独出去出来，以便其它类可以复用
           
    十二： id一般不用int类型，用Long类型
        欠规范代码示例：
        int id;           int 类型的关于人员的id
        规范代码示例:
        Long id;
        解析：随着id的增长，当增长的id超出int的范围的时候就会出现异常

     
    十三：sql语句一定要用占位符，不能用拼写组成的语句（否则会引起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(?,?,?,?)" //？则代表占位符
           //可用预处理来发送sql语句
    }

    解析：很容易出现错误，而且不清晰，不容易让人读懂。

    十四：当一个变量在每个方法里面使用,并且每个方法里面包含的内容不一样,那么这个变量不要用字段变量,要用局部变量,譬如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)
       {
            .......
        }

     

    解析：参数多容易出现错误。尤其是调用的时候，如果参数的顺序传错了，将是一个非常大的麻烦，而且没有拓展性

    三十六：值类或值对象必须重写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<User>对象，则返回类型要用List<User>。（父类或接口声明，子类实现）
        欠规范代码示例：

    //返回一个只能是保存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) {
                log.error("...."+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=Tools.getConnection();;
            public void addClass()
            {
               conn.add();
            }
            public void deleteById(int ID){
               conn.delete();
            }
            ............
        }
    		 
       解析：增加代码的可读性，

    五十二：程序代码中不要出现魔法数字。
    欠规范代码示例：

    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语句；

    五十四：方法命名的时候一定要力求精准，比如:查询的时候要命名为queryAll或者queryByID.
       欠规范代码示例：

       //查询所有用户如果有多个查询方法的话 public void query(){- - - } //未免太过模糊

     
  规范代码示例： 
  //根据ID来查找用户；
   public void queryById(Long id){ //代码块 }
   //查询所有用户
   public void queryAll(){} 

       解析：如果只有一个query太模糊了很难知道是查什么用的.

    五十六: 有返回类型的方法,不能返回一个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,则要写一个自定义的异常.返加这个自定义异常. 或者用集合工具类的emptyList方法返回一个空集合。
    五十七: 类里面不能写空方法.如果有必要,则在方法里面要加一个注释
       欠规范代码示例：
       //写了一个空的方法

     public void init(){ }

    规范代码示例：
      //在方法里面加上注释

     public void init(){ //TODO 该方法还没有写完,待完成. }

       解析：如果一个方法里面什么都没有写,那么要删除. 如果是实现过来的必须要重写该方法而不做会事的,应该要加注释.


    五十九:如果是在PersonDAO 类里面,写增加方法就不用加后缀了.
       欠规范代码示例：  

    //本类里面写增加方法还加了后缀  
    public Person addPerson(){
        Person person = new Person();
        ......
        return person;
      }

    规范代码示例：  

    //本类里面增加方法直接用add 就可以了 
      public Person add(){
         Person person = new Person();
         ......
         return person;
       }

    解析：在本类里面增加方法则不需要在后面加Person了,删除、修改、查询也是一样.

    六十:用Long来定义ID要比用基本类型long要好
       欠规范代码示例：

     long id;

       规范代码示例：

     Long id;

       解析：Long初始化后返回的是null。long初始化后返回的是0，是有值的,等价于默认的赋值给它

    六十一:逻辑表达式里有多个判断可能时要用小括号括起来
       欠规范代码示例：

    if(id!=null&&id!=""){
     
      }

       规范代码示例：

    if((id!=null) && (id!="")){
     
      }

     

    六十三:如果性能要求比较高,就要用StringBuffer,用append进行字符串叠加.在不影响性能的情况下用加号连接字符串是允许的,
       解析：既然没有影响那么它就是可以存在的

     String id = "ISOB"+number+001;

    六十四:每个模块都会用到的代码要放到 公共包 （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(){ //...代码 }

       解析：类似六十七条的解析

    七十一:当一个表达式超过两个时就要用变量抽取出来,并且变量名就是这个表达式的意思

    欠规范代码

    if ((age==20) && (title==10) && (address==5)){
    System.out.println("....");
    }

    规范代码

    boolean isSuccess=((age==20) && (title==10) && (address==5));
    if (isSuccess){
    System.out.println("....");
    }


       解析：让人更能够清晰的看出表达式所表达的意思

    七十二:不要随便更改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];

    解析：单个字母非常不清晰，别人根本看不出是什么意思，但在for循环，遍历还有迭代的时候可以除外，譬如i++

    七十八。集合或者数组后面要加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;

    八十二.如果有黄色警告,尽量要取消。
    解析： 黄色警告的意思是 可能会发生错误。要及时处理，避免小错 将来养成 大错。

     八十三.当一个常量和变量用equals比较的时候，常量在先，如果变量在先的话，如果这个变量为null，会抛空指针异常

    错误代码:
    if ( (userName != null) && (password != null) && (!userName.equals("")) && (!password.equals("")) ) {
    status = shoppingService.register(userName, password);
    }
    正确代码:
    if ( (!"".equals(userName)) && (!"".equals(password)) ) {
    status = shoppingService.register(userName, password);
    }

    八十四:尽量避免 不需要的强转。

    解析：如果一定要转到时候，要长度小的转长度大的，子类转化成父类或者父接口，否则就有 数据溢出 等错误。

    八十五:如果要用一个常量接口里面的常量，不要去实现这个接口来获得常量，会造成耦合度高，代码污染，正确的做法是用<接口.常量>来引用

     错误代码
    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();
  • 相关阅读:
    单元测试——破除依赖
    单元测试——基础概念
    2015年9月书单推荐
    菜鸟vimer成长记——第4.2章、编程插件
    克服弱点，愈发完美-自我篇——《人性的弱点》读后感
    菜鸟vimer成长记——第4.0章、Vim插件管理利器-Vundle
    菜鸟vimer成长记——第3章、文件
    阿里IPO法律咨询费达1580万美元 为Facebook六倍
    新移民漫画家 以幻想构筑奇妙世界
    请教Amazon FBA里面Label Service, Stickerless, Commingled Inventory是什么意思?
  • 原文地址：https://www.cnblogs.com/t0404/p/10291002.html
Copyright © 2011-2022 走看看