package com.reflect.other;

import java.io.Serializable;

/**
 * 简单pojo类(测试用,无具体意义)
 * 
 * @author edgewalk
 * @date 2017年6月5日
 */
public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}
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
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

package com.reflect.other;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * 父类
 * 
 * @author edgewalk
 * @date 2017年6月5日
 * @param <T>泛型,可以由之类继承传递
 */
public class Parent<T> {
    /**
     * 用于接收传递的clazz
     */
    private Class clazz;

    // 获取子类传递给他的具体泛型类型
    public Parent() {
        // 1获取子类的class(在创建子类对象的时候,会返回父类的构造方法)
        Class<? extends Parent> clazz = this.getClass(); // Student
        // 2获取当前类的带有泛型的父类类型
        ParameterizedType type = (ParameterizedType) clazz.getGenericSuperclass();
        // 3返回实际参数类型(泛型可以写多个)
        Type[] types = type.getActualTypeArguments();
        // 4 获取第一个参数(泛型的具体类) Person.class
        clazz = (Class) types[0];
    }
}
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
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

package com.reflect.other;
/**
 * 子类
 * @author edgewalk
 * @date  2017年6月5日
 */
public class Student extends Parent<Person> {
    /**
     * 当我们创建本类对象的时候,会先创建一个student类的空参构造,
     * 然后会返回父类的空参构造(Parent),此时父类就会获取到子类传递给他的泛型,在父类中执行相关操作
     */
}
1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6
7
8
9
10
11
12
13