反射和注解
1 注解
注解入门
内置注解
自定义注解，元注解
1.1 什么是注解
- 作用
Annotation,和comments一样可以对程序做出解释，除此之外还可以被其他程序（如：编译器）读取，有检查约束的功能 - 格式
"@注释名" 在代码中存在，还可以添加一些参数值， 例@SuppressWarnings(value = "unchecked") - 在哪使用
在package,class,method,field上添加额外辅助信息，可以通过反射机制实现对这些元数据的访问
1.2 内置注解
- @Override 修饰方法，重写父类
- @Deprecated 修饰方法，属性，类，弃用不鼓励使用
- @SuppressWarnings 抑制编译时的警告信息，需要使用参数，修饰方法类，字段等等
- @SuppressWarnings("all")
- @SuppressWarnings("unchecked")
- @SuppressWarings(value={"unchecked","deprecation"})
1.3 元注解meta-annotation
- 负责注解其他注解，提供对其它annotation类型的说明
- 常见4个元注解
- @Target: 注解可以用在什么地方
- @Rentention: 描述注解的生命周期，SOURCE<CLASS<RUNTIME（一般用自定义用RUNTIME，运行时可用）
- @Inherited: 说明子类可以继承父类中该注解
- @Document: 说明该注解被包含在javadoc文档注释中
例 元注解
package annotation;
import java.lang.annotation.*;
@MyAnnotation
public class Test01 {
@MyAnnotation
public void test(){
}
}
//照猫画虎，跟着@override源码写，此处自定义注解可以用在方法和类上
@Target(value = {ElementType.METHOD,ElementType.TYPE})
//表示直至运行都有效
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@interface MyAnnotation{
}
1.4 自定义注解
- 使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口
- 格式 public @interface 注解名
- {定义内容}是用来声明配置参数的，格式和声明方法类似,方法名实际上是参数名 格式： 参数类型 参数名（）default XX；
- 方法的返回值类型是参数的类型，只能是基本类型
- 可以通过default来声明参数的默认值,如果有默认值，可以不给参数赋值，否则必须赋值
- 如果只有一个参数成员，一般参数名为value,这样赋值时才可以省略参数名
- 注解元素必须要有值，通常使用空字符串，0作为默认值
package annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
public class Test03 {
@MyAnnotation2(name = "lala",schools={"Tsinghua","Peking"})
public void test(){};
//只有要给名字为value的参数，参数名可以省略
@MyAnnotation3("ddddd")
public void test2(){}
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
//parameter of annotation
String name() default "";
int age() default 0;
int ID() default -1;
String[] schools();
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
String value();
}
2 反射机制 java.Reflection
java 反射机制概述
理解Class类并获取Class实例
类的加载与ClassLoader （程序运行时外挂利用发射注入代码）
创建运行时类的对象
获取运行时类的完整结构
调用运行时类的指定结构
2.1 静态 VS 动态语言
动态语言
- 在运行时可以根据某些条件改变其结构的语言：如新的函数，对象设置代码可以被引进，已有的函数可以被删除或者时其结构上的变化。
- Object-C, C#, JavaScript, PHP, Python等
静态语言 - 运行时结构不可变，如JAVA,C,C++
- JAVA不是动态语言但是“准动态语言”，可以利用反射机制获得类似动态语言的特性
2.2 Java Reflection
-
Reflectinon反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并直接操作任意对象的内部属性及方法
Class c =Class.forName("java.lang.String"） -
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了完整的类的结构信息。
这个对象就像镜子反射一样，通过它可以看到类的结构，称之反射
![]()
-
反射机制功能
- 在运行时判断任意一个对象所属的类
- ：：：：构造任意一个类的对象
- ：：：：判断任意一个类所具有的成员变量和方法
- ：：：：获取泛型信息
- ：：：：调用任意一个对象的成员变量和方法
- ：：：：处理注解
- 生成动态代理
- ....
-
优缺点
- 优点： 实现动态常见对象和编译，灵活性强
- 缺点： 影响性能。它是一种解释操作，告诉JVM需要什么，这类操作慢于直接执行相同的操作
-
主要API
- Java.lang.Class代表一个类
- java.lang.reflect.Method 代表类的方法
- java.lang.reflect.Field 成员变量
- java.lang.reflect.Constructor 构造器
...
package annotation;
public class Test{
public static void main(String[] argvs) throws ClassNotFoundException{
//通过类名获得类对象，且hashcode一致，内存里一个类只有一个类对象
Class c1 = Class.forName("annotation.User");
Class c2 = Class.forName("annotation.User");
Class c3 = Class.forName("annotation.User");
Class c4 = Class.forName("annotation.User");
//only have one Class object in memory
//Once the class is loaded, all its structure will be packaged into Class object
System.out.println(c1.hashCode());
System.out.println(c2.hashCode());
System.out.println(c3.hashCode());
System.out.println(c4.hashCode());
}
}
//Entity class: have attributes
// pojo attributes and set/get method
class User {
private String name;
private int id;
private int age;
public User(String name, int id, int age) {
super();
this.name = name;
this.id = id;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
2.3 Class 类
在Object类中定义了getClass方法，该方法被所有子类继承
public final Class getClass()
该方法返回值是Class,通过对象.getClass反射求出类的名称，这是反射的源头。
*特点
-
Class 本身也是一个类
-
Class对象只能由系统创建，一个类加载到JVM里有且只有一个Class实例
-
一个Class对象对应JVM中一个.class文件
-
先获得相应的Class对象，才能动态加载运行类，获取类结构
-
Class类常用的方法
![]()
2.3.3 获取Class类的实例
a) 已知具体的类，通过类的class属性获取
Class clazz = Person.class
b) 已知某个类的实例，实例调用getClass方法获取Class对象
Class clazz = person.getClass();
c) 已知全类名，通过Class.forName获取，可能抛出ClassNotFoundException
Class Clazz = Class.forName("java.lang.String");
d) 内置基本数据类型 类名.Type
e) 还可以用ClassLoader（后面讲）
package reflection;
//测试Class类的创建方式有哪些
public class Test03 {
public static void main(String[] args) throws ClassNotFoundException {
Person person = new Student();
System.out.println("这个人是"+person);
//方法一 通过对象获取
Class c1 = person.getClass();
//方法二 通过全类名获得
Class c2 = Class.forName("reflection.Student");
//方法三 通过类获得
Class c3 = Student.class;
//方法四 基本内类型的包装类都有一个Type属性
Class c4 = Integer.TYPE;
//获得父类类型
Class c5 = c1.getSuperclass();
System.out.println(c1.hashCode());
System.out.println(c2.hashCode());
System.out.println(c3.hashCode());
System.out.println(c4);
System.out.println(c5);
}
}
class Person{
public String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
class Student extends Person{
public Student() {
this.name = "学生";
}
}
class Teacher extends Person{
public Teacher() {
this.name = "老师";
}
}
2.3.2 哪些类型可以有Class对象
- class:外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
- interface:接口
- []: 数组
- enum: 枚举
- annotation: 注解@interface
- primitive type :基本数据类型
- void
例
package reflection;
import javax.xml.bind.Element;
import java.lang.annotation.ElementType;
public class Test04 {
public static void main(String[] args) {
Class c1 = Object.class; //类
Class c2 = Comparable.class; //接口
Class c3 = String[].class;//一维数组
Class c4 = int[][].class;//二维数组
Class c5 = Override.class;//注解
Class c6 = ElementType.class;//枚举
Class c7 = Integer.class;//基本数据类型
Class c8 = void.class;//void
Class c9 = Class.class;//Class
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
System.out.println(c6);
System.out.println(c7);
System.out.println(c8);
System.out.println(c9);
//只要元素类型和维度一样，那他们就是同一个class
int[] a = new int[10];
int[] b = new int[100];
System.out.println(a.getClass().hashCode());
System.out.println(b.getClass().hashCode());
}
}
输出结果
class java.lang.Object
interface java.lang.Comparable
class [Ljava.lang.String;
class [[I
interface java.lang.Override
class java.lang.annotation.ElementType
class java.lang.Integer
void
class java.lang.Class
21685669
21685669
2.4 Java加载
内存分析
2.4.1 类的加载过程
- 加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，
然后生成一个代表这个类的java.lang.Class对象 - 链接： 将Java类的二进制代码合并到JVM的运行状态之中
- 验证： 确保加载的类信息符合JVM规范，没有安全方面的问题
- 准备： 正式为类变量（static)分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配
- 解析： 虚拟机常量池内的符号引用（常量名）替换为直接引用(地址）的过程
- 初始化
- 执行类构造器clinit()方法的过程，类构造器clinit()方法是由编译器自动收集类中所有类变量的赋值操作和静态代码块中的语句合并产生的。
（类构造器是构造类信息的，不是构造该类对象的构造器。此处只涉及静态变量，静态代码块） - 当初始化一个类的时候，如果发现器父类还没有进行初始化，则需要先触发其父类的初始化
- 虚拟机会保证一个类的clinit（）方法在多线程环境中被正确加锁和同步
例
- 执行类构造器clinit()方法的过程，类构造器clinit()方法是由编译器自动收集类中所有类变量的赋值操作和静态代码块中的语句合并产生的。
- 加载到内存中，会产生一个类对应Class对象
- 链接，链接结束后m=0
- 初始化
clinit(){
System.out.println("Static block initailize in Class A");
m = 300;
m = 100;
}
初始化后 m = 100
package annotation;
public class Test05 {
public static void main(String[] args){
A a = new A();
System.out.println(A.m);
}
}
class A{
static{
System.out.println("Static block initailize in Class A");
m = 300;
}
static int m = 100;
public A(){
System.out.println("no-parameter constructer of Class A");
}
}
输出结果
Static block initailize in Class A
no-parameter constructer of Class A
100
2.4.2 什么时候会发生类初始化
- 类的主动引用（一定会发生类的初始化）
- 当虚拟机启动，先初始化main方法所在的类
- new 一个类的对象
- 调用类的静态成员（除了final常量）和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类，如果其父类没有被初始化，则先初始化它的父类
- 类的被动引用（不会发生类的初始化）
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化
- 通过数组定义类引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）
例
package reflection;
public class Test06 {
public static void main(String[] args) throws ClassNotFoundException {
//1.主动引用 new
//main类被加载 -- 父类被加载 --子类被加载
//Son son = new Son();
//2.主动引用 反射
//main类被加载 -- 父类被加载 --子类被加载
//Class.forName("reflection.Son");
//不会产生类的引用的方法
//main类被加载--父类被加载--2
//System.out.println(Son.b);
//数组定义只是给一片空间命名，并不会加载类
//输出： main类被加载
//Son[] array = new Son[5];
//引用的常量
//main类被加载
//1
System.out.println(Son.M);
}
static {
System.out.println("main类被加载");
}
}
class Father{
static int b = 2;
static {
System.out.println("父类被加载");
}
}
class Son extends Father{
static {
System.out.println("子类被加载");
m=300;
}
static int m = 100;
static final int M = 1;
}
2.4.3 类加载器的作用
- 类加载作用： 将class字节码内容加载到内存中，并将这些静态数据转换成方法去的运行时数据结构，然后再队中生成一个代表这个类
的java.lang.Class对象，作为方法去数据的访问入口 - 类缓存：标准的JavaSe类加载器可以按照要求查找类，但一旦某个类被加载到类加载器中，它将维持缓存一段时间。
不过JVM垃圾回收机制可以回收这些Class对象
![]()
加载类时如果不使用自定义加载器，则采用双亲委派机制。
如自定义的class，先判断是否已加载过，加载过不用再加载。
然后appClassloader不是自己尝试去加载,而是调用父加载器ext扩展加载器去加载。
扩展加载器也会交由父加载器去加载，最终bootStrapClassLoader去加载。
这个机制优点：
- 避免核心类库被篡改，只由bootStrap去加载，自定义的java.lang.String是不会被读取的
- 避免重复加载：父类构造器加载过多不用再加载
注：核心库包为rt.jar
System Classloader 又称为 AppClassloader 加载项目类和jar包
package reflection;
public class Test07 {
public static void main(String[] args) throws ClassNotFoundException {
//Get System ClassLoader
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
//Get father Class of System ClassLoader-->Extension Classloader
ClassLoader parent = systemClassLoader.getParent();
//Get root ClassLoader-->c/c++ write,can't read, will return null
ClassLoader root = parent.getParent();
System.out.println(systemClassLoader);
System.out.println(parent);
System.out.println(root);
//test current class's classloader
ClassLoader classLoader =
Class.forName("reflection.Test07").getClassLoader();
System.out.println(classLoader);
ClassLoader objClassLoader =
Class.forName("java.lang.Object").getClassLoader();
System.out.println(objClassLoader);
//获得系统加载器的加载路径
//C:\Program Files\Java\jdk1.8.0_102\jre\lib\charsets.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\deploy.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\ext\access-bridge-64.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\ext\cldrdata.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\ext\dnsns.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\ext\jaccess.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\ext\jfxrt.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\ext\localedata.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\ext\nashorn.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\ext\sunec.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\ext\sunjce_provider.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\ext\sunmscapi.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\ext\sunpkcs11.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\ext\zipfs.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\javaws.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\jce.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\jfr.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\jfxswt.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\jsse.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\management-agent.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\plugin.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\resources.jar;
// C:\Program Files\Java\jdk1.8.0_102\jre\lib\rt.jar;
// C:\Users\***\IdeaProjects\TCP\out\production\TCP;
// C:\Users\***\IdeaProjects\TCP\src\lib\commons-io-2.8.0.jar;
// C:\Users\***\IdeaProjects\TCP\src\chat\commons-io-2.8.0.jar;
// C:\Program Files\JetBrains\IntelliJ IDEA Community Edition 2020.3.2\lib\idea_rt.jar
System.out.println(System.getProperty("java.class.path"));
}
}
结果：
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@14ae5a5
null
sun.misc.Launcher$AppClassLoader@18b4aac2
null
***class见上面折叠注释
2.5 创建运行时类的对象
2.5.1 获取运行时类的完整结构
Field,Method,Constructor,Superclass,Interface,Annotation
例
package reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
//获得类的信息
public class Test08 {
public static void main(String[] args) throws Exception {
Class cl = Class.forName("reflection.User");
User user = new User();
cl = user.getClass();
//获得类名
System.out.println(cl.getName()); //包名+类名
System.out.println(cl.getSimpleName()); //类名
System.out.println("=====================");
//getFields只能找到public属性，所以打印不出来fields，getDeclaredFields找到所有属性。
/*
Field[] fields = cl.getFields();
for(Field field : fields){
System.out.println(field);
}*/
//获得属性
Field[] fields = cl.getDeclaredFields();
for(Field field : fields){
System.out.println(field);
}
//不能获取非public属性
//Field name = cl.getField("name");
Field name = cl.getDeclaredField("name");
System.out.println(name);
//获得方法
Method[] methods = cl.getMethods();//获得本类及其父类的所有public方法
for(Method method: methods){
System.out.println(method);
}
System.out.println("===");
methods = cl.getDeclaredMethods();//获得本类的所有方法
for(Method method: methods){
System.out.println(method);
}
//获得指定方法,getMethod除了方法名外还要传入参数，因为java可以重载
Method getName = cl.getMethod("getName", null);
Method setName = cl.getMethod("setName", String.class);
System.out.println(getName);
System.out.println(setName);
System.out.println("=======");
Constructor[] constructors = cl.getConstructors();
for(Constructor constructor: constructors){
System.out.println(constructor);
}
constructors = cl.getDeclaredConstructors();
for(Constructor constructor: constructors){
System.out.println(constructor);
}
cl.getDeclaredConstructor(String.class, int.class, int.class);
System.out.println(declaredConstructor);
}
}
2.5.2 反射创建对象
- 调用Class对象的newInstance()方法创建
1)类必须有一个无参构造器
2)类的构造器的访问权限需要足够 - 没有无参构造器，先获取构造器，再掉哦那个newInstance()去创建
1)通过Class类的getDeclaredConstructor(Class ... parameterTypes)取得本类的指定形参类型的构造器
2)向构造器的形参中传递一个对象数组进去，里面包含构造器所需的各个参数
3)通过Constructor实例化对象
package reflection;
import java.lang.reflect.Constructor;
//通过反射动态创建对象
public class Test09 {
public static void main(String[] args) throws Exception {
Class c1 = Class.forName("reflection.User");
//类对象调用newInstance,构造一个对象,本质上调用无参构造器
User user = (User) c1.newInstance();
System.out.println(user);
//获取有参数构造器再newInstance创建对象
Constructor constructor = c1.getDeclaredConstructor(String.class,int.class,int.class);
User user1 = (User) constructor.newInstance("xiaolan",125,18);
System.out.println(user1);
}
}
User{name='null', id=0, age=0}
User{name='xiaolan', id=125, age=18}
2.5.3 反射调用方法
1.通过Class类的getMethod(String name,Class...parameterTypes)方法取得一个Method对象，
并设置此方法操作时所需要的参数类型
2. 创建对象 A
3. 通过Object invoke(Object A,Object[]args)进行调用，并向方法中传递要设置的obj对象的参数信息
//通过反射获取方法
User user3 = (User) c1.newInstance();
Method setName = c1.getDeclaredMethod("setName", String.class);
Method setAge = c1.getDeclaredMethod("setAge", int.class);
Method setId = c1.getDeclaredMethod("setId", int.class);
//知道方法，传递方法参数和调用该方法的对象
setName.invoke(user3,"xiaoqing");
setAge.invoke(user3,12);
setId.invoke(user3,10);
System.out.println(user3);
Object invoke（Object obj, Object... args)激活方法注意点
- 没有返回值则第一个Object为null
- 若是静态方法，此时形参Object obj为null
- 若是形参列表为空，则Oject[]args为null
- 若原方法声明为Private，需要先显示调用setAccessible(true)打开访问权限，再调用invoke().
2.5.4 反射获取属性
//通过反射获取属性
User user4 = (User) c1.newInstance();
Field age = c1.getDeclaredField("age");
//私有的属性要设置打开访问权限（属性或者方法setAccessible），才可以赋值
setName.setAccessible(true);
age.set(user4,10);
System.out.println(user4);
setAccessible(true) 打开访问权限
- Method,Field,Constructor对象都有setAccessible()方法
- 可以提高反射效率
package reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
//分析性能问题
public class Test10 {
//普通方式调用
public void test01(){
User user = new User();
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
user.getName();
}
long endTime = System.currentTimeMillis();
System.out.println("普通方式执行10亿次：" + (endTime-startTime));
}
//反射方式调用
public void test02() throws Exception {
User user = new User();
Class aClass = user.getClass();
Method getName = aClass.getDeclaredMethod("getName",null);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
getName.invoke(user,null);
}
long endTime = System.currentTimeMillis();
System.out.println("反射方式调用：" + (endTime-startTime));
}
//关闭检查，反射方式调用
public void test03() throws Exception {
User user = new User();
Class aClass = user.getClass();
Method getName = aClass.getDeclaredMethod("getName",null);
getName.setAccessible(true);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
getName.invoke(user,null);
}
long endTime = System.currentTimeMillis();
System.out.println("关闭检查，反射方式调用：" + (endTime-startTime));
}
public static void main(String[] args) throws Exception {
Test10 test = new Test10();
test.test01();
test.test02();
test.test03();
}
}
输出结果：
普通方式执行10亿次：4
反射方式调用：2346
关闭检查，反射方式调用：1286
2.5.5 反射操作泛型
- Java采用泛型擦除机制来引入泛型，java中的泛型仅仅是给编译器javac使用的确保数据的安全性和免去强制类型转换问题。
但是一旦编译完成，所有和泛型与有关的类型全部擦除。 - 为了通过反射操作这些类型，java新增了ParameterizedTpe,GenericArrayType,TypeVariable和WildcardType几种类型来
代表不能被归一到Class类型但是又和原始类型齐名的类型- ParameterizedType:参数化类型比如Collection
- GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
- TypeVariable:是各种类型变量的公共父接口
- WildcardType:代表一种通配符类型表达式
例 反射获取/操作泛型（了解）
- ParameterizedType:参数化类型比如Collection
package reflection;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
public class Test11 {
public void test01(Map<String,User> map, List<User> list){
System.out.println("test01");
}
public Map<String,User> test02(){
System.out.println("test02");
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
Method method = Test11.class.getMethod("test01", Map.class, List.class);
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
System.out.println("#"+genericParameterType);
if(genericParameterType instanceof ParameterizedType){
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
System.out.println("========");
method = Test11.class.getMethod("test02",null);
Type geneticReturnType = method.getGenericReturnType();
if(geneticReturnType instanceof ParameterizedType){
Type[] actualTypeArguments = ((ParameterizedType) geneticReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
}
扩展 泛型
- 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
- 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前.
3.泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型
reference:https://www.runoob.com/java/java-generics.html
public static < E > void printArray( E[] inputArray )
{
// 输出数组元素
for ( E element : inputArray ){
System.out.printf( "%s ", element );
}
System.out.println();
}
2.5.6 反射操作注解
- getAnnotations
- getAnnotation
![]()
根据反射获取注解拼成SQL语句，然后就可以生成一张表，框架就是这样做的然后操作数据库
package reflection;
import java.lang.annotation.*;
//练习反射操作注解
public class Test12 {
public static void main(String[] args) throws Exception {
//通过反射获得注解
Class c1 = Class.forName("reflection.Student2");
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
//获得注解的值
Table table = (Table)c1.getAnnotation(Table.class);
System.out.println(table.value());
java.lang.reflect.Field name = c1.getDeclaredField("name");
FieldAnnotation annotation = name.getAnnotation(FieldAnnotation.class);
System.out.println(annotation.columnName());
System.out.println(annotation.length());
System.out.println(annotation.type());
}
}
@Table("db_student")
class Student2{
@FieldAnnotation(columnName = "db_id",type = "int",length = 10)
private int id;
@FieldAnnotation(columnName = "db_age",type = "int",length = 10)
private int age;
@FieldAnnotation(columnName = "db_name",type = "varchar",length = 3)
private String name;
public Student2(){
}
public Student2(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
public int getId() {
return id;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
public void setId(int id) {
this.id = id;
}
public void setAge(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student2{" +
"id=" + id +
", age=" + age +
", name='" + name + '\'' +
'}';
}
}
//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table{
String value();
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldAnnotation {
String columnName();
String type();
int length();
}
博客有点圆
浙公网安备 33010602011771号