注解与反射
1.1 注解(annotation)简述
注解是从jdk5.0开始引入的技术,和注释相同,也能起到解释程序的作用,不过与注释不同的是,注解可以被编译器解释,可以内置代码。
注解是一个特殊的接口,其继承了java.lang.annotation.Annotation接口
注解可以在包上,类上,方法上,属性上等使用,对它们起到约束作用,可以通过反射机制,实现对这些元数据的访问
内置注解——java常用注解:
- @Override:重写
- @Deprecated:废弃的
- @SuppressWarnings:抑制警告,参数"all"最为常用
元注解——注解的注解,负责解释注解的代码段(4个标准的meta-annotation类型):
- @Target:描述注解的使用范围
- @Retention:描述注解最久可以存活的时间(三个时间段:Source(源码)–>Class(编译后class文件)–>Runtime(运行时))
- @Documented:该注解是否被加到javadoc文档中
- @Inherited :表明子类可以继承其父类的注解
自定义注解:
模式:public @interface 注解名{value},下面是实例:
package bin;
import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ ElementType.TYPE, ElementType.METHOD }) // 可以用在类接口或枚举类型和方法上
@Retention(RetentionPolicy.RUNTIME) // 运行时仍可以存在
public @interface MyAnnotation {
// 相当于定义了一个方法
String value();// 属性名为value可以省略
String[] name() default { "1", "2" };// 可以使用默认值
int num() default 1;
}
class Test {
// @MyAnnotation(value = "hello world", num = 1) // 因name有默认值,所以不用填写
@MyAnnotation("hello world") // 当只有一个注解且属性名为value时,可以省略属性名
void test() {
}
}
1.2反射(Reflection)简述
反射可以使java程序在运行期间通过相应的反射类api获取方法或属性信息,也可以操作其中的方法,因为反射的存在,使java勉强称为了“动态语言”
反射的形象理解:
正常访问一个类的属性和方法:引入包名----------->new 实例对象------------>通过 点 一个对象调用
反射访问一个类的属性和方法:实例化对象--------->getClass()方法得到类------->调用相关信息
反射的核心类:java.lang.Class类 所有对象的共有方法:getClass(),获取这个对象的本类
1.2.1 获取类对象
实例展示:
package bin;
public class TestReflection {
public static void main(String[] args) throws ClassNotFoundException {
//Class stud = Student123.class;
//Student123 s1= new Student123(); Class s2 = s1.getClass();
//Class num = Integer.TYPE;
Class stud = Class.forName("bin.Student123");//字符串:包名+类名
//一个Class类对应的是一个编译后的java文件所生成的class文件
System.out.println(stud); //class bin.Student123
System.out.println(stud.getName()); //bin.Student123
System.out.println(stud.getPackageName()); //bin
System.out.println(stud.getSimpleName()); //Student123
System.out.println(stud.getMethods()); //只能获得所有的public 方法
for (Method method : stud.getMethods()) {
System.out.println(method);
}
for(Method method:stud.getDeclaredMethods()) {//可以获取所有方法,包括私有方法
System.out.println(method);
}
// 属性相同
// 获取指定的方法
// System.out.println(stud.getMethod("test", String.class));获取public方法
System.out.println(stud.getDeclaredMethod("test", String.class));
System.out.println(stud.getMethod("test", null));
try {
//stud.newInstance()方法已被废弃,因为只能调用无参构造器
Student123 s = (Student123) stud.getDeclaredConstructor().newInstance();
//生成一个新的本类对象,可以调用多个构造器
System.out.println(s);//bin.Student123@5680a178
} catch (Exception e) {
e.printStackTrace();
}
}
}
//实体类,pojo
class Student123{
private int num;
public String name="123";
public void test() {
System.out.println("123456");
}
}
本质:当一个对象被创建之前,JVM会将这个对象的本类Class对象通过类加载器加载到内存中,然后在根据这个Class对象创建相应的类对象,此时所有的静态代码块和静态常量,都会在加载Class对象时执行完毕。
通过类名调用相应的静态常量或静态方法,不会创建一个新的对象,不会进行类的加载
1.2.2 类加载器的概念
简介:类加载器作用是把类(class)装载进内存当中的。每个类加载器也是一个对象,它们存在这样的关系:系统加载器对象----继承---->扩展类加载器对象----继承---->引导类加载器
共有三种类型的加载器:
- 引导类加载器:C++编写,负责java核心库 【重要】(无法直接获取)
- 扩展类加载器:主要负责JVM中lib包下的jar包加载工作
- 系统类加载器:将工程额外的jar包载入工作,是最常用的加载器
实例演示:
package bin;
public class ClassLoaderDemo {
public static void main(String[] args) throws ClassNotFoundException {
// 获取系统加载器,最低一级加载器
ClassLoader c1= ClassLoader.getSystemClassLoader();
// 获取扩展类加载器
ClassLoader c2 =c1.getParent();
// 获取引导类加载器(根加载器,由c++/c编写而成)
ClassLoader c3 = c2.getParent();
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
// 测试当前类是由那个类加载器加载而成的
ClassLoader c4 = Class.forName("bin.ClassLoaderDemo").getClassLoader();
System.out.println(c4);//系统类加载器
// 测试jdk内部类是由那个加载器进行加载的
ClassLoader c5 = Class.forName("java.lang.Object").getClassLoader();
System.out.println(c5);//引导类加载器
}
}
返回结果
- jdk.internal.loader.ClassLoaders$AppClassLoader@6659c656
- jdk.internal.loader.ClassLoaders$PlatformClassLoader@123772c4
- null
- jdk.internal.loader.ClassLoaders$AppClassLoader@6659c656
- null
1.2.3 动态操作类属性方法
实体类:
package bin;
/**
*
* @author 86155
* student类,管理学生信息
*/
public class Student implements Comparable<Student>{
private int id;
private String name;
private String sex;
private String subject;
private int grade;
public Student(int id, String name, String sex, String subject, int grade) {
super();
this.id = id;
this.name = name;
this.sex = sex;
this.subject = subject;
this.grade = grade;
}
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;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
@Override
public String toString() {
return "id:"+id+" name:"+name+" sex:"+sex+" subject:"+subject+" grade:"+grade;
}
@Override
public int compareTo(Student o) {
return this.id-o.getId();
}
}
操作过程:
package bin;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ClassDemo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
// 1、将这个类加载到内存中
Class stud = Class.forName("bin.Student");
// 2、实例化这个类的对象
Student s1 = (Student) stud.getDeclaredConstructor(int.class,String.class,String.class,String.class,int.class).newInstance(1,"张三","boy","程序员",98);
// 3、获取到相应的属性或方法,如果要访问私有属性或方法,必须调用setAccessible(true)方法调用
Field name = stud.getDeclaredField("name");
name.setAccessible(true);//关闭安全检测
name.set(s1, "Mr.Wang");//设置其name属性值为Mr.Wang
// 4、操作其方法
Method method = stud.getDeclaredMethod("setGrade", int.class);
method.invoke(s1,100);//调用s1对象里面的方法,第二个代表参数的值,无参就写null
System.out.println(s1);
}
}
输出结果🆔1 name:Mr.Wang sex:boy subject:程序员 grade:100
总结
新增知识点
- 反射核心类Class,通过类加载器加载Class对象的四种方式
- 内置注解–>元注解—>自定义注解
- 通过反射可以获得注解和属性、方法
- 通过反射创建运行时对象,操作其方法
- 各种类加载器之间的联系和区别
- 如何通过反射调用无参和有参构造器
- 如何通过反射调用private私有属性或方法