Java实操必坑指南二、java泛型、反射、编译优化

1. 实现了Serialzable接口却报错了

1. 序列化和反序列化概念

1. 序列化： 将对象写入IO流中

2. 反序列化 ：从IO流中恢复对象

3. Serialzable 是一个标记接口，不用实现任何方法，标记当前对象是可以序列化的

2. 序列化考虑的问题

1. 子类实现序列化接口，父类没有实现，那么子类可以序列化么

   解决方案，父类没有实现序列化接口，需要调用无参构造

2. 类中存在引用对象，那么，这个类在什么情况下可以实现序列化

3. 同一个对象多次序列化（之间有属性更新），会影响序列化么？

3. coding

package com.maidou.learning.escape.serialzation;


import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.io.Serializable;

@ToString
@Getter
@Setter
public class Student implements Serializable{
    private String name;

    public Student(String name) {
        this.name = name;
    }
}


package com.maidou.learning.escape.serialzation;

import java.io.*;

@SuppressWarnings("all")
public class Test {

    private static void testSerializableStudent() throws Exception {

        // 存储序列化为的文件
        File file = new File("D:/test/student_1.java_");

        Student student = new Student("测试");

        // 创建输出流
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(file));

        // 输出可序列化对象
        objectOutputStream.writeObject(student);

        // 关闭输出流
        objectOutputStream.close();

        // 创建输入流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));

        // 得到反序列化的对象信息
        Object readObject = ois.readObject();

        ois.close();

        System.out.println(readObject);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

2. 泛型不仅仅是规定集合类型那么简单

1. 定义， 泛型就是参数化类型，就是将原来具体的参数类型参数化

2. 能够在不创建新类型的情况下，通过泛型指定不同类型

3. 不要使用原始类型来定义

4. coding

package com.maidou.learning.escape;


import java.util.ArrayList;
import java.util.List;

/**
 * @Author maichen
 * @Description : 泛型
 * @Date 0:25 2022/10/20
 **/
public class Genericity {


    /**
     * @Author maicheng
     * @Description 泛型是先检查后编译
     * @Date 0:36 2022/10/20
     **/
    private static void simple() {
        List<String> left = new ArrayList<>();
        List<Integer> right = new ArrayList<>();

        System.out.println(left.getClass());

        // 类型参数
        System.out.println(right.getClass() == left.getClass());
    }

    private static void test() {
        List list  = new ArrayList();

        list.add(1);
        list.add("猪");
        list.add(2.1);
        System.out.println(list);
    }

    public static void main(String [] args) {
        test();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

3. 反射

1. 定义

允许运行中的Java获取自身的信息，并且可以操作类或者对象的属性

2. 适用场景

开发通用框架，动态代理，注解，可扩展性功能

3. 存在缺陷