编写高质量代码改善java程序的151个建议——[1-3]基础?亦是基础

2022-02-10 12:08:54

　　　　　　　　　　　　　　　　　　　　原创地址: http://www.cnblogs.com/Alandre/ (泥沙砖瓦浆木匠),需要转载的,保留下! Thanks

The reasonable man adapts himself to the world;the unreasonable one persists in trying to adapt the world to himself. —萧伯纳

相信自己看得懂就看得懂了,相信自己能写下去,我就开始写了.其实也简单—泥沙砖瓦浆木匠

Written In The Font

Today , I am writing my java notes about <编写高质量代码改善java程序的151个建议> -秦小波.

Three pieces[1-3]:

1.Don‘t code by confusing letters in the constants and variables [不要在常量和变量中出现易混淆的字母]

2.Don‘t change the constants into the variable. [莫让常量蜕变成变量]

3.Make the the types of ternary operators the same. [三元操作符的类型务必一致]

Don‘t code by confusing letters in the constants and variables

from the book:

public class Client01 {
    public static void main(String [] args)
    {
        long i = 1l;
        System.out.println("i的两倍是："+(i+i));
    }
}

Outputs:

2　　

(unbelieved?just ctrl c + ctrl v run the code !)

In my words:

‘1l’is not ‘11’. But we always code by the confusing things . then bebug for a long time , finally we will laught at ourselves with the computer and codes face to face.”What fucking are the coder?”lol,smile ! carm down , because u r so lucky to read this . i will tell some excemples to keep them away. away ? really away?

Step 1: somthing about Coding Standards

★Constants should always be all-uppercase, with underscores to separatewords. [常量都要大写,用下划线分开]

See a case from my project ITP:

package sedion.jeffli.wmuitp.constant;

public class AdminWebConstant 
{
    
    public static final String ADMIN_BASE     = "/admin";
    public static final String WEB_BASE       = ADMIN_BASE + "/web";

    /**
     * view
     */
    public static final String ADMIN_LOGIN_VIEW = WEB_BASE   + "/login";
    public static final String ADMIN_INDEX_VIEW = ADMIN_BASE + "/index/index";
    
    /**
     * 返回String状态
     */
    public static final int RESULT_SUCCESS = 1;
    public static final int RESULT_FAIL    = 0;
}

★Camel Case:[变量命名驼峰原则,自然你也可以选择其他的法则等]

if u wanna do it , right now ! it can make your codes more beautiful and clean! amazing ! u learned it , keep on!!!

package sedion.jeffli.wmuitp.util;

import javax.servlet.http.HttpSession;

import sedion.jeffli.wmuitp.entity.TeacherInfo;
import sedion.jeffli.wmuitp.entity.UserLogin;

public class AdminUtil
{
    public static final String ADMIN        = "admin";
    public static final String ADMIN_ID     = "adminID";
    public static final String TEACHER_ID   = "teacherID";
    
    public static void saveAdminToSession(HttpSession session,UserLogin userLogin)
    {
        session.setAttribute(ADMIN, userLogin);
    }
    
    public static void saveAdminIDToSession(HttpSession session,UserLogin userLogin)
    {
        session.setAttribute(ADMIN_ID, userLogin.getUlId().toString());
    }
    public static UserLogin getUserLoginFromHttpSession(HttpSession session)
    {
        Object attribute = session.getAttribute(ADMIN);
        return attribute == null ? null : (UserLogin)attribute;
    }
    
    public static String getUserLoginIDFromHttpSession(HttpSession session)
    {
        Object attribute = session.getAttribute(ADMIN_ID);
        return attribute == null ? null : (String)attribute;
    }
    
}

#please remeber the camel , then u can write a nice code.

Step 2: somthing can make your program easier to understand

some letters should not be used with the numbers,like l O … they are the brother of the numbers.but we can do some to avoid. like use ‘L’ , and write some notes about them.

Don‘t change the constants into the variable

A magical demo:

public class Client02
{
    public static void main(String [] args)
    {
        System.out.println("const can change:  "+ Const.RAND_COSNT);
    }

    //接口常量

    interface Const
    {
       public static final int RAND_COSNT = new Random().nextInt();
    }
}

#I think the demo is bad. RAND_COSNT is not a constant and we never do that.

what is Constants ?

Constants are immutable values which are known at compile time and do not change for the life of the program.But if the project is too large to manage.There will be a problem.Let me show u!

example:

//file: A.java
public interface A
{
    String goodNumber = "0.618";
}

//file: B.java
public class B
{
    public static void main(String [] args)
    {
        System.out.println("Class A‘s goodNumber = " +A.goodNumber);
    }        
}

Outputs:

Class A‘s goodNumber = 0.618

Now we change A.java –> goodNumber to “0.6180339887”

//file: A.java
public interface A
{
    String goodNumber = "0.6180339887";
}

“javac A.java”then “java B” , we will find the outputs is the same:

Class A‘s goodNumber = 0.618

why??????????????????

just see the class of B, use “ javap –c B”:

Compiled from "B.java"
public class B {
  public B();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String Class A‘s goodNumber = 0.618
       5: invokevirtual #4                  // Method java/io/PrintStream.printl
n:(Ljava/lang/String;)V
       8: return
}

#3: ldc #3 // String Class A‘s goodNumber = 0.618

ok , we see! the last interface A was already in the class B. so we can “javac B.java”to deal.

All in all ,

Java Interface is usually the best place to store The Constants.

[Java Interface 通常是常量存放的最佳地点]

A best way store constants : static fianl XXX static Object getXXX()

it shows the Java dynamic advantage and a constant principle.

//file:A.java
public class A
{
    private static final String goodNumber = "0.6180339887";
    public static String getGoodNumber()
    {
        return goodNumber;
    }
}

//file:B.java
public class B
{
    public static void main(String [] args)
    {
        System.out.println("Class A‘s goodNumber = " +A.getGoodNumber());
    }        
}

Make the the types of ternary operators the same.

from the book:

public class Client03 {
    public static void main(String[] args) {
        int i = 80;
        String s  = String.valueOf(i<100?90:100);
        String s1 = String.valueOf(i<100?90:100.0);
        System.out.println(" 两者是否相等:"+s.equals(s1));
    }
}

Outputs:

false

see the compiled code ,use “javap –c Client03”,we will see:

      23: if_icmpge     32
      26: ldc2_w        #3                  // double 90.0d
      29: goto          35
      32: ldc2_w        #5                  // double 100.0d

the transformation rules about ternary operators.

三元操作符类型的转换规则：

        1.若两个操作数不可转换，则不做转换，返回值为Object 类型。

        2.若两个操作数是明确类型的表达式（比如变量），则按照正常的二进制数字来转换，int 类型转换为long 类型，long 类型转换为float 类型等。

        3.若两个操作数中有一个是数字S，另外一个是表达式，且其类型标示为T，那么，若数字S 在T 的范围内，则转换为T 类型；若S 超出了T 类型的范围，则T 转换为S类型（可以参考“建议22”，会对该问题进行展开描述）。

        4.若两个操作数都是直接量数字（Literal），则返回值类型为范围较大者。

Editor‘s Note

合抱之木，生于毫末；九层之台，起于累土；千里之行，始于足下. ---老子<<道德经>>

快来加入群【编程乐园】(365234583)。 http://t.cn/RvGAuJr

编写高质量代码改善java程序的151个建议——[1-3]基础?亦是基础,布布扣,bubuko.com