注解与反射（注解简述，反射创建运行时对象，反射操作属性方法，反射操作注解）

注解与反射

1.1 注解（annotation）简述

注解是从jdk5.0开始引入的技术，和注释相同，也能起到解释程序的作用，不过与注释不同的是，注解可以被编译器解释，可以内置代码。

注解是一个特殊的接口，其继承了java.lang.annotation.Annotation接口

注解可以在包上，类上，方法上，属性上等使用，对它们起到约束作用，可以通过反射机制，实现对这些元数据的访问

内置注解——java常用注解：

1. @Override:重写
2. @Deprecated：废弃的
3. @SuppressWarnings:抑制警告，参数"all"最为常用

元注解——注解的注解，负责解释注解的代码段（4个标准的meta-annotation类型）：

1. @Target：描述注解的使用范围
2. @Retention：描述注解最久可以存活的时间（三个时间段：Source(源码)–>Class(编译后class文件)–>Runtime（运行时））
3. @Documented：该注解是否被加到javadoc文档中
4. @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私有属性或方法