反射
反射
类是程序中的一部分，每一个类都有一个Class对象亦本身就是Class对象，比如：Student类（封装有属性和函数），对应的Class类的对象就是Student类本身，Student实例化时：Student xx = new Student(); ，在实例化的同时JVM也会对Student这个对象进行一次实例化：Class Student = new Class();。只有第一次调用该类（Student类）的同时，会在内存中开辟一块属于这个Class对象（Student类）的空间，这是自动创建且用一个类一次执行中只创建一次，当下一次调用该类的属性、方法或实例化时，就不会再开辟新空间。
--------------类的调用加载图：
java程序在运行之前并没有被完全加载，各个类只在需要的时候才将该类的Class对象载入内存，该Class对象被用来创建这个类的所有对象。通过下面的代码可以证明以上内容：
public class ClassDX {
/**
*
*/
public ClassDX() {
}
/**
* @param args
*/
public static void main(String[] args) {
int i = Class1.i;
try {
Class.forName("Class2");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
new Class3();
}
public String toString(){
return null;
}
}
class Class1{
static int i;
static {
System.out.println("执行Class1");
}
}
class Class2{
static {
System.out.println("执行Class2");
}
}
class Class3{
static {
System.out.println("执行Class3");
}
}
/**
* output
* 执行Class1
* 执行Class2
* 执行Class3
*/
其中static{}是静态块，在类被加载的时候会执行，第一个输出是我们是用Class1中的静态成员i而加载了Class1类，而第二个输出我们调用了Class类的一个静态方法forName();，参数是一个类的名称，返回的是该类名的类的Class2对象，该方法还有一个作用就是若该类未被加载则加载它，最后使用了new关键字创建Class3的对象即调用了类的构造器，也对Class3进行了加载输出了第三行。
–通过反射获取Class对象–
一个类的3种获取Class对象的方法：
- 调用Class类的静态方法forName(“全类名”)；
- 类名.class，又称为类字面常量，推荐使用，简单安全，在编译时就会被检查是否正常；
- 类的实例.getClass();，继承的父类Object类中的方法。
具体使用如下：
try {
//classloader 类加载器
Class clazz=Class.forName("com.entity.Student");
//调用类的class属性 保证在内存中只有一份 sync(.class){} this .class static var
Class clazz2=Student.class;
//创建类的实例 调用对象.getClass方法
Class clazz3=new Student().getClass();
getSuperClassAndInterface(clazz);
getFields(clazz);
getMethods(clazz);
getConstructor(clazz);
} catch (Exception e) {
e.printStackTrace();
}
反射获取继承的父类及实现的接口
在java语言中，继承只能有一个，保留了多继承的概念，转换为接口去多实现。
获取继承的父类的方法：Class对象.getSuperclass();，就可以获取父类，返回一个Class对象（注：当无继承时默认父类为Object类，当继承其他类时，返回的Class对象就不是Object类）
获取实现的接口的方法：
首先要了解接口可以多实现，所以存储多个对象所要用到的是数组。用到的方法是：Class对象.getInterfaces();，返回一个Class类型的数组，数组值就是实现的接口Class对象。
public static void getSuperClassAndInterface(Class clazz){
//getSuperClass:Class 对象 java只支持单继承
System.out.println("该类继承的父类是:"+clazz.getSuperclass().getName());
//允许实现多个接口
Class[] clazzes=clazz.getInterfaces();
for(Class item:clazzes){
System.out.println(item.getSimpleName());
}
}
/*
* output
* 该类继承的父类是:java.lang.Object
* Serializable
* Cloneable
*/
反射获取类中的成员属性和赋值
运用上面方法获取类的Class对象之后，获取成员属性的方法有4种：
getField(); getFields(); 不能获得私有属性
getDeclaredField(); getDeclaredFields(); 能获得所有属性（推荐）
用“s”结尾的方法返回成员属性数组；
非“s”结尾的方法必须将属性名作为参数传进去，将这个属性作为一个Field对象返回回来。
成员属性赋值方法：
- 运用前面的Class对象返回该类的一个对象，要用到**Class对象.newInstance();**方法： Object obj = clazz.newInstance();
- 通过调用非“s”结尾的**getDeclaredField(“成员属性名”);**方法获取该属性：Field field = clazz.getDeclaredField(“birthday”);
- 调用**setAccessible(true);**方法，屏蔽私有特性，这样才能获取到想要的私有属性：field.setAccessible(true);
- 对属性进行赋值，调用Field类的**set(类的实例，所需要赋予属性的值);**方法去赋值：field.set(obj,new Date());
- 输出时需要强转实例对象为对应类型的对象：Student s = (Student)obj;，再通过正常的s.属性或者s.属性的get方法获取属性值。
具体的实现过程代码：
//2、获取类中的所有字段
public static void getFields(Class clazz) throws Exception {
//4个方法
// getFields getField 不能获得私有的字段
// getDeclaredFields getDeclaredField 能获得所有字段
Field[] fields1= clazz.getFields();
Field[] fields2=clazz.getDeclaredFields();
//lambda表达式 JDK1.8 出现的强大语法
for (Field item:fields1){
//获取访问修饰符
int result=item.getModifiers();
System.out.println(Modifier.toString(result)+" "+item.getType().getSimpleName()+" "+item.getName()+";");
}
System.out.println(Arrays.toString(fields1));
for (Field item:fields2){
//获取访问修饰符
int result=item.getModifiers();
System.out.println(Modifier.toString(result)+" "+item.getType().getSimpleName()+" "+item.getName()+";");
}
System.out.println(Arrays.toString(fields2));
//给字段赋值
//面向对象的时候 如何在一个类的外部给这个类的成员赋值哪？ 必须需要类的实例
Object obj=clazz.newInstance(); //实例化
Field field=clazz.getDeclaredField("birthday");
field.setAccessible(true);//屏蔽私有特性
field.set(obj,new Date());
Student stu=(Student)obj;
System.out.println("生日是:"+stu.getBirthday());
}
/*
* output
* []
* private String name;
* private int age;
* private Date birthday;
* [private java.lang.String com.entity.Student.name, private int com.entity.Student.age, private java.util.Date com.entity.Student.birthday]
* 生日是:Tue Oct 02 21:04:20 CST 2018
*/
反射获取类中的函数并给有参函数传参
获取类中函数的方法和获取属性一样是4种
getMethod(); getMethods();---------能获取父类的属性
getDeclaredMethod(); getDeclaredMethods();------只能获取本身属性
给有参函数传参的过程：
- 实例化该类：Object obj=clazz.newInstance();
- 调用Class类的getDeclaredMethod(“方法名”，参数类);方法，返回Method类型的对象：Method method=clazz.getDeclaredMethod(“setName”,String.class);
- 调用该类的方法时需要用到Method类中的Method对象.invoke(“对象”,参数值);方法：method.invoke(obj,“会飞的鱼”);
public static void getMethods(Class clazz) throws Exception {
//获取类中所有方法
for(Method method:clazz.getMethods()){
System.out.println("方法名:"+method.getName());
}
System.out.println("===============================================");
for(Method method:clazz.getDeclaredMethods()){
System.out.printf("方法名:%s,返回值类型:%s",method.getName(),method.getReturnType().getSimpleName());
//获取所有参数类型
for(Class item:method.getParameterTypes()){
System.out.print("参数类型:"+item.getSimpleName());
}
}
Object obj=clazz.newInstance(); //实例化
//不定长参数:一定要把不定长参数放在参数列表的末尾处
Method method=clazz.getDeclaredMethod("setName",String.class);
//调用方法 invoke方法调用
method.invoke(obj,"会飞的鱼");
}
/*
* output
* 方法名:toString
* 方法名:getName
* 方法名:setName
* 方法名:getBirthday
* 方法名:getAge
* 方法名:setAge
* 方法名:setBirthday
* 方法名:wait
* 方法名:wait
* 方法名:wait
* 方法名:equals
* 方法名:hashCode
* 方法名:getClass
* 方法名:notify
* 方法名:notifyAll
* ===============================================
* 方法名:toString,返回值类型:String方法名:getName,返回值类型:String方法名:setName,返回值类型:void参数类型:String
* 方法名:getBirthday,返回值类型:Date方法名:getAge,返回值类型:int方法名:setAge,返回值类型:void参数类型:int
* 方法名:setBirthday,返回值类型:void参数类型:Date
* set方法已被调用！
*/
反射获取构造函数并调用
获取构造函数的方法：
A.1：获取构造方法的数组：
public Constructor[] getConstructors():获得所有公共构造方法
public Constructor[] getDeclaredConstructors():获得所有构造方法（推荐）
A.2：获取单个构造方法(用于非私有的构造方法)
public Constructor getConstructor(Class… parameterTypes)
参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
注：根据传入的参数不同，返回的构造不同，无参构造无需传参。
A.3：获取单个构造方法（用于私有的构造方法，推荐）
public Constructor getDeclaredtConstructor(Class… parameterTypes)
参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
注：根据传入的参数不同，返回的构造不同，无参构造无需传参。
B.1：初始化构造方法的实例：(用于非私有的构造方法)
public newInstance(Object… initargs) 注意：Object… initargs表示的是你要实例化的指定参数
使用此 Constructor对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
B.2：初始化构造方法的实例：(用于私有的构造方法)
先用： public void setAccessible(boolean flag)：flag的值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。
再用： public newInstance(Object… initargs)
使用构造方法
- 调用“s”结尾的方法，能获取所有构造方法：
Constructor[] cons = clazz.getDeclaredConstructors();； - 根据构造函数数组，选取构造函数，用Class类的getDeclaredtConstructor(Class… parameterTypes)；方法，
根据对应参数返回Construtor类型的对象： Constructor con=clazz.getConstructor(String.class,int.class,Date.class);
（注：不传参数为无参构造）； - 实例化并传入参数：Object obj = con.newInstance(“会飞的鱼”,18,new SimpleDateFormat(“yyyy-MM-dd”).parse(“2002-10-01”));（注：这里参数根据2步骤参数来传入）；
- 强转类型：Student stu = (Student)obj;；
具体代码：
public static void getConstructor(Class clazz) throws Exception {
Constructor[] cons = clazz.getDeclaredConstructors();
for (Constructor con:cons) {
System.out.println(con);
}
Constructor con=clazz.getDeclaredConstructor(String.class,int.class,Date.class);//构造方法的参数类型
Object obj = con.newInstance("会飞的鱼",18,new SimpleDateFormat("yyyy-MM-dd").parse("2002-10-01"));
Student student=(Student)obj;
System.out.println(student);
}
/*
* output
* public com.entity.Student(java.lang.String,int,java.util.Date)
* public com.entity.Student()
* Student{name='会飞的鱼', age=18, birthday=Tue Oct 01 00:00:00 CST 2002}
*/
下面为本次代码调用的Student类
import java.io.Serializable;
import java.util.Date;
/**
* Created by cmy on 2018/9/27.
*/
public class Student extends Object implements Serializable,Cloneable {
//字段（属性）
private String name;
private int age;
private Date birthday;
//方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
System.out.println("set方法已被调用！");
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
//构造
public Student(String name, int age, Date birthday) {
this.name = name;
this.age = age;
this.birthday = birthday;
}
//core(核心) source(源码) doc
public Student(){
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", birthday=" + birthday +
'}';
}
}