7-18

7-18 7.序列化和反序列化 序列化和反序列化最常用的方式是将某个类实现Serializable接口，使用对象流进行相应的序列化和反序列化 重点需要注意的是

• 显式定义一个private static final long serialVersionUID且不要轻易修改这个值（达到向下兼容的目的）
• 使用transient修饰的变量，在序列化的时候会忽略他的值，在反序列化的时候会将其值设为初始值，int为0，引用类型为null

class  Data   implements Serializable {
    private static final long serialVersionUID = -1018436805097712788L;   
    
    private   int   n;
    public   Data(int   n)   {   this.n   =   n;   }
    @Override
    public   String   toString()   {   return   Integer.toString(n);   }
}

class   Worm   implements   Serializable   {
    public   static   void   main(String[]   args)
            throws   ClassNotFoundException, IOException {   //   序列话读入和写入Object可能会有这两个异常
        //   将你要序列化的object，保留到一个文件中
        Random rand   =   new   Random();
        Data   d   =   new   Data(rand.nextInt(10));   //构建你需要序列话的Object
        System.out.println("d   =   "   +   d);
        ObjectOutputStream out   =   new   ObjectOutputStream(new FileOutputStream("worm.out"));   //   准备写入的文件
        out.writeObject(d);
        out.flush();
        out.close();   //   执行到这里你可以看见worm.out这个文件，
        //   以下的代码读出你刚刚写入Object
        ObjectInputStream   in   =   new   ObjectInputStream(new   FileInputStream("worm.out"));   // 读你刚刚写入的文件
        Data   d2   =   (Data)in.readObject();   // 重新构建你刚刚写入的Object
        System.out.println("d2   =   "   +   d2);
    }

}

8.static 关键字

• 使用static修饰的可以是变量，代码块，内部类，方法
• 某个类被加载之后调用以上被static修饰的代码的顺序是：

1. 父类的静态代码块（若有多个，从上到下）
2. 子类的静态代码块（若有多个，从上到下）
   （上面两部只有类第一次初始化的时候会执行）
3. 父类的成员变量初始化
4. 父类的初始化代码块（若有多个，从上到下）
5. 父类的构造函数
6. 子类的成员变量初始化
7. 子类的初始化代码块（若有多个，从上到下）
8. 子类的构造函数

• 总结：在第一次加载某个类时，先加载父类的静态代码块；实例化的时候先加载父类的成员变量、初始化代码块、构造函数，再加载子类的

class StaticExample {

    public StaticExample() {
        System.out.println("hello");
    }

    //static block
    static{
        //can be used to initialize resources when class is loaded
        System.out.println("StaticExample static block");
        //can access only static variables and methods
        str="Test";
        setCount(2);
    }

    //multiple static blocks in same class
    static{
        System.out.println("StaticExample static block2");
    }

    //static variable example
    private static int count; //kept private to control it's value through setter
    public static String str;

    public int getCount() {
        return count;
    }

    //static method example
    public static void setCount(int count) {
        if(count == 0)
        StaticExample.count = count;
    }

    //static util method
    public static int addInts(int i, int...js){
        int sum=i;
        for(int x : js) sum+=x;
        return sum;
    }

    //static class example - used for packaging convenience only
    public static class MyStaticClass{
        public int count;

    }
}

class TestStatic {

    public static void main(String[] args) {
        StaticExample.setCount(5);

        //non-private static variables can be accessed with class name
        StaticExample.str ="abc";
        StaticExample se = new StaticExample();
        System.out.println(se.getCount());
        //class and instance static variables are same
        System.out.println(StaticExample.str +" is same as "+se.str);
        System.out.println(StaticExample.str == se.str);

        //static nested classes are like normal top-level classes
        StaticExample.MyStaticClass myStaticClass = new StaticExample.MyStaticClass();
        myStaticClass.count=10;

        StaticExample.MyStaticClass myStaticClass1 = new StaticExample.MyStaticClass();
        myStaticClass1.count=20;

        System.out.println(myStaticClass.count);
        System.out.println(myStaticClass1.count);
    }

}

最后执行的结果
StaticExample static block
StaticExample static block2
hello
0
abc is same as abc
true
10
20

9.注解

• 元注解有6个：

1. @Target：表示这个注解用在什么地方
2. @Retention：保留策略，有SOURCE,CLASS,RUNTIME
3. @Dcoumented：将此注解保留在javadoc中
4. @Inherited：是否可以被继承
5. @Repeatable：是否允许一个注解在一个元素上出现多次
6. @Native：修饰成员变量，表示成员变量可以被本地代码使用

• 自定义注解

使用@interface

• 注解与反射的结合

//获取一个类上的注解信息
//关键方法：isAnnotationPresent判断是否存在注解
//          getAnnotation获得注解
Class clz = bean.getClass();
Method[] methods = clz.getMethods();
for (Method method : methods) {
    if (method.isAnnotationPresent(EnableAuth.class)) {
        String name = method.getAnnotation(EnableAuth.class).name();
    }
}

10.泛型

• 定义：泛型是JDK5引入的一个新特性，允许在定义类和接口的时候使用类型参数。声明的参数类型在调用时传入具体的类型。常用于集合类型框架中。最大的好处就是提高代码的复用性，如需要在List中放Integer,String，使用泛型只需要定义一个公共的接口
• 泛型擦除：指的是在编译的时候将泛型去掉，最终留下最基本的原生类型，如方法重载是基于泛型的话，在编译的时候会进行泛型擦除，导致编译报错

public class GenericTypes {  

    public static void method(List list) {  
        System.out.println("invoke method(List list)");  
    }  

    public static void method(List list) {  
        System.out.println("invoke method(List list)");  
    }  
}  

• 泛型中K T V E Object等的作用E - Element (在集合中使用，因为集合中存放的是元素)

1. T - Type（Java 类） 2. K - Key（键） 3. V - Value（值） 4. N - Number（数值类型） 5. ？ - 表示不确定的java类型（无限制通配符类型） 6. S、U、V - 2nd、3rd、4th types 7. Object - 是所有类的根类，任何类的对象都可以设置给该Object引用变量，使用的时候可能需要类型强制转换，但是用使用了泛型T、E等这些标识符后，在实际用之前类型就已经确定了，不需要再进行类型强制转换。

• 限定通配符和非限定通配符

1. 上界： 类型必须为T类型或其子类
2. 下界： 类型必须为T类型或其父类
3. 泛型必须使用限定内的类型进行初始化，否则会编译出错
4. 非限定通配符表示可以使用任意泛型类型来代替
5. extends 和 super的用法，在使用泛型时，存取元素时用super,获取元素时，用extends。频繁往外读取内容的，适合用上界Extends。经常往里插入的，适合用下界Super。

public class Food {}
public class Fruit extends Food {}
public class Apple extends Fruit {}
public class Banana extends Fruit{}

public class GenericTest {

    public void testExtends(List list){

        //报错,extends为上界通配符,只能取值,不能放.
        //因为Fruit的子类不只有Apple还有Banana,这里不能确定具体的泛型到底是Apple还是Banana，所以放入任何一种类型都会报错
        //list.add(new Apple());

        //可以正常获取
        Fruit fruit = list.get(1);
    }

    public void testSuper(List list){

        //super为下界通配符，可以存放元素，但是也只能存放当前类或者子类的实例，以当前的例子来讲，
        //无法确定Fruit的父类是否只有Food一个(Object是超级父类)
        //因此放入Food的实例编译不通过
        list.add(new Apple());
//        list.add(new Food());

        Object object = list.get(1);
    }
}

• List 是一个未知类型的List，而List 其实是任意类型的List。你可以把List, List赋值给List，却不能把List赋值给 List。

Regarding List