注解与反射—总结
什么是注解?
- 不是程序本身,可以对程序作出解释
- 可以被其他程序读取,例如编译器
- 注解是以“@注解名”在代码中存在,还可以添加参数值,例如
@SuppressWarning(value=”unchecked” )
- 可以在package、class、method、field等使用,添加额外信息
- 反射机制编程实现对这些元数据的访问
内置注解
-
@Override 重写: 定义在java.lang.Override中,该注解用于修辞方法,表示一个方法声明重写超类中的另一个方法声明
-
@Deprecated 废弃: 定义在java.lang.Deprecated中,可以用于修饰类、方法、属性、表示不支持程序员使用这种元素,因为有更好的选择。
-
-
@SupressWarning(“all”)
- 定义在java.lang.SuppreWarning中,用来抑制编译时所产生的警告信息。该注解需要添加参数
- SupressWarning(“unchekced”)
- SupressWarning({“unchecked”, “deprecation”})
元注解
负责注解其它注解
- @Target() 参数:
{ElementType.TYPE, ElementType.METHOD}
, 用于描述注解的使用范围,例如:类、方法 - @Retention() 参数:
RetentionPolicy: SOURCE|CLASS|RUNTIME
, 表示需要在什么级别保存该注释信息,用于描述注解的生命周期,一般在Runtime中 - @Document() 说明该注解将被包含在javadoc中
- @Inherited() 说明子类可以继承父类中的该注解
自定义注解
格式: public @interface A{...}
@Retention(RetentionPolicy.RUNTIME) // 元注解
@Target({ElementType.TYPE, ElementType.METHOD}) // 元注解
public @interface A {
// 每一个方法实际上就是配置了一个参数
String name() default ""; // name 参数名, String 参数类型 default '' 默认为空
int age() default 0;
}
public @interface A {
// 只有一个参数,一般用value命名,传参的时候,不需要写 value = xxx, 直接将xxx传放入
String value();
}
反射概述
反射实际上就是java视为动态语言的关键,借助反射,我们可以在代码执行期间,通过Class类去操纵任何类的内部信息,比如内部属性或方法,甚至可以去操作私有属性!
但是对性能有影响!
Class类 的概念下面讲!
Java反射机制提供的功能:
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时获取泛型信息
- 在运行时处理注解
- 生成动态代理
Class 类
注意Class 的首字母大写,代表一种类!(小写class 有其它作用)
首先呢,本身也是一个对象!由系统创建,在加载器将你写的代码定义的类加载到堆内存中的时候,就创建了这个对象。而它呢,是用来描述你写的代码中类的结构的 (比如:属性,构造器,方法,接口,枚举,注解….),你写的类不论创建(new)多少对象,这些对象都只拥有一个Class 对象!而我们呢,就可以通过对象的反射指向这个Class对象,得到这个Class对象,从而在执行期间去改变或者去获取关于你写的这个类的信息
- Class类对应一个 JVM中的一个Class实例
- 一个Class对象对应的是一个加载到JVM中的一个.class文件
获取Class类的一些方法
public class A {...}
A a = new A()
- Class c1 = A.class;
- Class c2 = a.getClass();
- Classs c3 = Class.forName(“xxx.xx.A”);
- 基础类型的 Class c4 = Integer.TYPE;
- 通过ClassLoader获得
//方法1 _通过对象获得
Class c1 = person.getClass();
//方法2 _通过forname
Class c2 = Class.forname("com.kuang.reflection.Student");
//方法3 _通过类名.class
Class c3 = Student.class;
//通过父类也能获得
Class c4 = c1.getSuperclass();
哪些类型可以拥有Class对象?
Java 内存分析
主要分为三个:
- 栈内存 : 存放基本变量类型 ,以及对象的指针
- 堆内存: 主要存放new的对象和数组,可以被所有线程共享
- 方法区: 包含了所有class和static变量的数据结构,可以被所有进程共享
关于一个类的加载过程
主要分三步:
- 加载阶段
- 这个阶段主要由加载器来工作,也就是ClassLoader, 加载器的概念等下再说!
- 完成的工作呢就是:
- 1、将class文件的字节码存到内存当中去,变成方法区的运行时数据结构,如上图方法区的样子
- 2、在堆内存中生成java.lang.Class对象
- 链接阶段
- 完成的工作呢就是:
- 1、为类变量(static) 分配内存以及赋予上默认初始值!比如 static int a = 0; static String b = “”;这样子。
- 2、为类的常量值进行赋值 先这么理解吧,也就是说,在这个阶段,常量值是可以使用的!
- 完成的工作呢就是:
- 初始化阶段
- 这个阶段调用类构造器,完成的工作,好比上图
- 1、将类变量进行真正的赋值,也就是你写的代码这个变量到底等于多少!
- 2、将静态代码块中的语句进行合并!
- 3、初始一个类的时候,父类没初始化,则先触发父类的初始化
- 这个阶段调用类构造器,完成的工作,好比上图
首先来说加载器的概念
类加载器的作用:也就是在上面加载阶段所完成的事
类缓存:一旦类被加载到内存中,则会存在一段时间,然后再被回收!
加载器分为三种:
-
系统加载器 : 你写的用户自定义类的加载器,也是我们用的最多的加载器,父加载器是扩展加载器,可以获得引用
-
// 获取系统类加载器 ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
-
-
扩展加载器: 存放在 jre/lib/ext目录下jar包里面类的加载器,父加载器就是根加载器,可以获得引用
-
// 获取系统类加载器的父类加载器>>扩展加载器 ClassLoader sysParent = systemClassLoader.getParent();
-
-
根加载器 : Java的核心类,是通过这个加载器获得,我们并能获取它的引用, 为null
-
//获取扩展类加载器的父类加载器>>根加载器 但是获取的值为null ClassLoader extParent = sysParent.getParent();
-
再来说下初始化阶段的发生阶段
- 类的主动引用(一定会发生类的初始化)
- 虚拟机启动,执行main方法所在的类 ,这个类会到初始化阶段
- new A() 也会发生初始化
- 调用类的静态方法和静态属性(除了final 常量)
- 使用java.lang.reflect包的方法,也就是获取Class的方法,也会将该类进行初始化
- 初始化子类的时候,父类如果没有初始化,则会先初始化父类
- 类的被动引用 (不会发生类的初始化)
- 子类引用父类的静态变量,子类不会初始化
- 数组定义分配空间,也不会引起该类的初始化
Son[] son1 = new Son[5]
- 引用常量也不会触发此类的初始化,因为再类加载的过程的第二阶段链接阶段,常量就已经可以用了
如何在运行时获得类的完整结构
实际上我们就是通过反射,也就是拿到Class类,然后执行Class类的方法,就可以获得运行时你自己写的类的完整的数据结构了,包括:接口、所继承的父类、全部构造器、全部方法、全部属性、注解….
Class类的一些方法:
package com.ClassLoader.Demo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
*/
public class Demo2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
// Class c1=Class.forName("com.ClassLoader.Demo.User");
User user=new User();
Class c1=user.getClass();
System.out.println(c1.getSimpleName());
System.out.println("*************************");
// 获取类的名字 +详细路径
System.out.println(c1.getName());
// 得到类的名字
System.out.println(c1.getSimpleName());
// 得到该类的属性
Field[] fields=c1.getFields(); //能够找到public属性
fields=c1.getDeclaredFields(); //能够找到全部属性
for (Field field:fields) {
System.out.println(field);
}
Field name=c1.getDeclaredField("name");
System.out.println(name);
System.out.println("*************************");
// 得到类的方法
Method[] methods=c1.getDeclaredMethods();
for (Method method : methods) { //获得奔雷及其父类的所有方法
System.out.println("getDeclaredMethods:"+method);
}
System.out.println("*************************");
Method[] methods1=c1.getMethods();
for (Method method : methods1) { //获得本类的的所有方法
System.out.println("getMethods:"+method);
}
System.out.println("*************************");
// 获得指定的方法
// 重载
Method getName=c1.getMethod("getName",null);
Method setName=c1.getMethod("setName", String.class);
System.out.println(getName);
System.out.println(setName);
System.out.println("*************************");
// 获得指定实例对象的构造器
Constructor[] constructors=c1.getConstructors();//获得public方法
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
Constructor[] constructors1=c1.getDeclaredConstructors();//获得全部方法
for (Constructor constructor : constructors1) {
System.out.println(constructor);
}
System.out.println("*************************");
//获得指定构造器
Constructor declareConstructor=c1.getDeclaredConstructor(String.class,int.class,double.class);
System.out.println(declareConstructor);
}
}
除了获得类的完整结构,得到了Class对象,我们还能干什么?
-
创建类的对象,也就是实例,平常我们通过new A()的方式创建的实例,我们现在可以通过反射创建
-
// 利用 Class类的newInstance()方法,调用了无参构造器创建实例 Class aClass=Class.forName("com.ClassLoader.Demo.User"); User user1=(User) aClass.newInstance();
-
// 非只能用无参构造器创建对象,用有参构造器也可以 // 先通过Class类的getDeclaredConstructor(对应的参数)方法获得有参构造器 // 然后调用有参构造器的newInstance()方法,就可以创建实例了 Constructor constructor=aClass.getDeclaredConstructor(String.class,int.class,double.class); User user2=(User) constructor.newInstance("xxx",xx,xx);//参数数量要一致否则出现异常
-
-
通过反射,去操作实例的方法和属性
-
// 通过反射调用普通方法 User user= (User) aClass.newInstance(); // 通过反射获取一个方法 Method setName=aClass.getDeclaredMethod("setName", String.class); // inoke激活,将实例作为第一个参数传入,修改的数据作为第二个参数 setName.invoke(user,"xxx"); System.out.println(user.getName());
-
// 通过反射操作属性,不能直接操作私有属性,可以通过关闭程序的安全检测关掉 User user4=(User) aClass.newInstance(); Field name=aClass.getDeclaredField("name"); name.setAccessible(true); //可通过的意思。private修饰的变量有安全保护机制, name.set(user4,"xxx"); System.out.println(user4.getName()); }
-
通过反射操作泛型 就省略了!
重点: 通过反射操作注解
package com.AnnotationReflect.Demo;
import java.lang.annotation.*;
import java.lang.reflect.Field;
/**
* @Description TODO
* @Author Y
*/
public class Demo1 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1=Class.forName("com.AnnotationReflect.Demo.Student1");
// 通过反射获得注解
Annotation[] annotations=c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
// 获得类的注解value参数的值
TableY tableY=(TableY)c1.getAnnotation(TableY.class);
String value=tableY.value();
System.out.println(value);
// 获得类具体指定属性的注解
Field field=c1.getDeclaredField("name");
FiledStudent annotation=field.getAnnotation(FiledStudent.class);
System.out.println(annotation.columName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@TableY("studentinfo")
class Student1{
@FiledStudent(columName = "Sno",type="int",length = 10)
private int id;
@FiledStudent(columName = "Sname",type="int",length = 10)
private String name;
@FiledStudent(columName = "Sex",type="int",length = 10)
private String sex;
public Student1(int id, String name, String sex) {
this.id = id;
this.name = name;
this.sex = sex;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FiledStudent{
String columName();
String type();
int length();
}
//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableY{
String value();
}
turn sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FiledStudent{
String columName();
String type();
int length();
}
//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableY{
String value();
}