Java代码规范

最新推荐文章于 2024-05-06 23:18:53 发布
最新推荐文章于 2024-05-06 23:18:53 发布
阅读量3.2k 收藏 5
点赞数 1
分类专栏： 代码规范

一：不允许使用汉语拼音命名
欠规范代码示例：
    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();

t0404
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
delete用法解析
huahualaly的博客
12-14 3万+
使用delete语句一次只能删除整行记录，不能删除某个字段。 与insert和update一样，删除一个表中的记录可能会导致与其他表的引用完整性问题，当对数据库进行修改时一定要记着这一影响。 delete只会删除记录，不会删除表。如果要删除整张表，需要使用droptable命令。 如果要一次性清楚表中的数据，并且不需要撤销删除，可以使用truncate一次性对表数据进行清除。 delete语法如下： delete [from] table [where condition]; table指定要删除的表名称，
Java编程规范(代码规范)--精选
IT利刃出鞘的博客
05-22 2476
本文介绍精选的Java编程规范（代码规范）。遵守这些规范，代码的bug数将会大幅减少，代码可维护性、可读性、扩展性会大幅上升。
【编码规范篇】 C#编码规范 代码规范总结，包括命名规范，代码规范 注释规范等_c(2)
最新发布
2401_84170414的博客
05-06 773
4.编写位置记录时，对参数使用 pascal 大小写，因为它们是记录的公共属性。
Java开发编码规范
qq_24577585的博客
01-27 4345
java 开发规范
Java编码规范
qq_24868375的博客
08-24 296
Java编码规范
JAVA轻量级错误码设计最佳实践
java_lujj的博客
09-07 1075
目前公司团队项目中返回异常都没有错误码，如果遇到错误提示只会返回一个错误信息。随着微服务组件越来越多，这样给不同团队之间沟通交流、排查错误带来了极大的困难。于是在网上搜索了一番以后，决心要重新设计下错误码机制.本文主要讲解了错误码设计的方案，希望对大家有帮助，如果有更好的方案设计，也可以留言，一起成长提高。
java代码规范
10-30
Java代码规范是编程实践中至关重要的一环，它不仅有助于提高代码的可读性和可维护性，还能促进团队间的协作，确保代码质量。以下是一些关于Java代码规范的关键知识点： 1. **命名规范**： - 类名：使用驼峰式命名...
Java代码规范.pdf
07-17
Java开发代码规范，用于行业内部开发的准则，包括开发标准和开发技巧。
JAVA代码规范1
08-08
首先，标识符命名规范是Java代码规范的基础。标识符应该做到统一、达意和简洁。这意味着对于同一个概念，应该在整个项目中使用相同的表示方法，例如，对于供应商，选择supplier或provider，但是一旦选定，就要保持...
Java代码规范, 详细
09-05
Java 代码规范详细版 Java 代码规范是指在编写 Java 代码时需要遵守的一系列规则和约定，以确保代码的可读性、可维护性和可扩展性。在本文中，我们将详细介绍 Java 代码规范的各个方面，包括标识符命名规范、包名...
JAVA编码规范
Crazy_Cw的博客
09-21 3428
命名风格 1. 代码命名不能以下划线或者美元符号开头或者结尾 2. 代码命名不能以中文拼音或者中文拼音与英文混合方式 3. 类名使用UpperCamCamelCase风格，但DO、PO、DTO、VO、BO等除外 4. 方法名、参数名、变量名统一使用lowerCamelCase，必须遵守驼峰命名 5. 常量名全部大写，单词间用下划线隔开 6. 抽象类必须以Abstract或者Base开头，异常类必须以Exception结尾，测试 类以测试的类的名称开头Test结尾 7
Java编码规范，技巧与建议
07-09
我看到的几篇很不错的关于Java编程规范和技巧方面的文章： JAVA代码编写的30条建议 Java代码规范那些事儿 常见的8种Java不规范代码和相应的规范代码
【Java里面常见的一些错误代码】
学无止境
02-24 1363
【Java里面常见的一些错误代码】
java的书写规范
kekeke764的博客
09-17 2218
java的书写规范
Java初级程序员编码规范——异常处理
xzp_12345的博客
10-11 1278
          对于一个大的项目，最怕两件事情：                 1. 系统出现问题我们不知道，等到问题慢慢变大，用户开始投诉后才知道“哦，我们系统出现问题了呀！”。 多么可怕！！！                 2. 系统出了问题，但是就是找不出来哪里出现了问题。           对于第一个问题，如果出现，后果非常的严重。 因此，为了尽量避免这样的问题，我们需要...
JavaBean
B_qxzb的专栏
06-29 1080
JavaBean规范 JavaBean类是一个特殊的类 它必须满足以下条件， 1.属性私有 2.读写方法公有 3.必须要有无参构造器，而且只能有这一个构造器 JavaBean的历史 现在大多都是从web开发起步的，可能对swing不是很了解。java bean分四种，最早是用作swing的，作为一个控件，类似VB，可以直接拖放，他会定义一系列属性，方法，和事件
Java命名规范（建议收藏）
qq_46209845的博客
01-28 3362
一、 所有命名规范都必须遵循以下规则： 1、名称只能由字母、数字、下划线、$符号组成 2、不能以数字开头 3、名称不能使用JAVA中的关键字 4、坚决不允许出现中文及拼音命名 二、命名规范： 1、项目名称全部用小写 2、包名全部用小写 3、 类名首字母大写，如果类名由多个单词组成，每个单词的首字母都要大写。 如: public class MyBinarySearch {} 4、变量名、方法名首字母小写，如果名称由多个单词组成，除首单词外其余单词的首字母都要大写（驼峰命名法） 如：int l
java 代码规范
10-13
Java 代码规范是一种约定俗成的编码规范，它可以提高代码的可读性和可维护性。以下是一些常见的 Java 代码规范： 1. 类名使用大驼峰命名法，即每个单词首字母大写，如：MyClass。 2. 方法名使用小驼峰命名法，即第...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值