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:
|
1 |
|
(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:
|
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:
|
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:
|
1 |
|
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） ，则返回值类型为范围较大者。