改善java程序之java通用方法和准则

1.不要在常量和变量中出现易混淆的字母：

    包名全小写，类名首字母大写；

    常量全部大写并用下划线分隔，变量采用驼峰命名法命名；

    字母“l”作为长整型标识时，务必要大写。

2.莫让常量蜕变为变量：

public class Client {

    public static void main(String[] args) {

        System.out.println("常量会变哦："+Const.RAND_CONST);

    }

}  

/* 接口常量 */

interface Const {

    //这还是常量嘛？

    public static final int RAND_CONST = new Random().nextInt();

}

    务必让常量的值在运行期保持不变。

3.三元操作符的类型务必一致

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

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

    ②若两个操作数中有一个是数字S，另一个是表达式，且其类型标示为T，那么，若数字S在T的范围内，则转换为T类型；若S超出了T类型的范围，则T转换为S类型；

    ③若两个操作数是明确类型的表达式(比如变量)，则按照正常的二进制数字来转换；

    ④若两个操作数都是直接量数字(Literal)，则返回值类型为范围较大者。

package com.nari.memoop.test;


public class Client {


/**
* @param args
*/
public static void main(String[] args) {
//向上转型
Base base = new Sub();
base.fun(100,50);
//不转型
/*Sub sub = new Sub();
sub.fun(100,50);*/
//覆写的方法参数与父类相同，不仅仅是类型、数量，还包括显示形式
/*int[] dis = {50,50};
sub.fun(100,dis);*/
int count = 0 ;
for(int i = 0;i < 10;i++){
// count = count++;//注意count每次都是0
count++;
}
System.out.println("count = "+count);

int cnt = 0;
for(int j = 0;j < 10;++j){
// cnt = ++cnt;
++cnt;
}
System.out.println("cnt = "+cnt);


}

}
//基类
class Base{
void fun(int price,int... discounts){
System.out.println("Base......fun");
}
}
//子类，覆写父类方法
class Sub extends Base{
@Override
void fun(int price,int[] discounts){
System.out.println("Sub......fun");
}
}

自增陷阱

package com.nari.memoop.test;


public class Consumer {


/**
* @param args
*/
public static void main(String[] args) throws Exception{
//反序列化
Person person = (Person)SerializationUtils.readObject();
System.out.println("name = "+person.getName());
System.out.println("person = "+person.toString());
System.out.println("person = "+person.getClass());
}


}

package com.nari.memoop.test;


import java.io.Serializable;


public class Person implements Serializable {
private String name;


/**
* @return the name
*/
public String getName() {
return name;
}


/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}

}

package com.nari.memoop.test;


public class Producer {
public static void main(String[] args) throws Exception{
Person person = new Person();
person.setName("混世魔王");
//序列化，保存到磁盘上
SerializationUtils.writeObject(person);
}
}

package com.nari.memoop.test;


import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;


public class SerializationUtils {
private static String FILE_NAME = "D:/obj.bin";
//序列化
public static void writeObject(Serializable person){
try {
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream(FILE_NAME));
oos.writeObject(person);
oos.close();
} catch (Exception e) {
e.printStackTrace();
}
}

//反序列化
public static Object readObject(){
Object obj = null;
try {
ObjectInput input = new ObjectInputStream(
new FileInputStream(FILE_NAME));
obj = input.readObject();
input.close();
} catch (Exception e) {
e.printStackTrace();
}
return obj;
}
}

最好要显式声明SerialVersionUID流标识符(Stream Unique Identifier)，即类的版本定义private static final long serialVersionUID = XXXL;隐式声明是编译器在编译的时候生成的，依据是通过包名、类名、继承关系、非私有的方法和属性，以及参数、返回值等诸多因子计算得出的，基本上这个值是唯一的。

serialVersionUID的作用：JVM在反序列化时，会比较数据流中的serialVersionUID与类的serialVersionUID是否相同，如果相同，则认为类没有发生变化，可以把数据流load为实例对象；如果不相同，抛出异常InvalidClassException。这是一个校验机制，可以保证一个对象即使在网络或磁盘中“滚过”一次，仍能做到“出淤泥而不染”，完美地实现类的一致性。 依靠显示声明serialVersionUID，向JVM撒谎说“我的类版本没有变更”，就实现了向上兼容。

注意：显式声明serialVersionUID可以避免对象不一致，但尽量不要以这种方式向JVM“撒谎”。

反序列化时，构造函数不会执行。

反序列化的执行过程：JVM从数据流中获取一个Object对象，然后根据数据流中的类文件描述信息(在序列化时，保存到磁盘的对象文件中包含了类描述信息，注意是类描述信息，不是类)查看，发现是final变量，需要重新计算。