Java笔记 —— 反射

获取Class类型对象

既然获取了一个class类的Class对象，就可以获得这个类的全部信息，那么我们该如何获得这个Class对象呢？

1. 通过Object中的getClass()方法获取，返回该Object的运行时类

2. 通过类名获取静态属性class

3. Class类中的静态方法 public static 类<?> forName(String className)（通常使用这个方法）

package test.reflexDemo;

public class Student {

private String name;

int age;

public String hobby;

public Student(){

}

private Student(String name){

this.name = name;

}

Student(String name,int age){

this.name = name;

this.age = age;

}

public Student(String name,int age,String hobby){

this.name = name;

this.age = age;

this.hobby = hobby;

}

public void test(){

System.out.println(“public修饰的无参的方法”);

}

public String show(String name,int age){

System.out.println(“public修饰的含参的方法”);

return name + “—” + age;

}

void function(String name){

System.out.println("默认修饰符的含参的方法，姓名是 "+name);

}

private void demo(String hobby){

System.out.println("private修饰的含参的方法，爱好是 "+hobby);

}

@Override

public String toString() {

return “Student{” +

“name=’” + name + ‘’’ +

“, age=” + age +

“, hobby=’” + hobby + ‘’’ +

‘}’;

}

}

这里的Student就相当于Class，这里的s就相当于Class类型对象

package test.reflexDemo;

public class Demo1 {

public static void main(String[] args) throws ClassNotFoundException {

//这里的Student就相当于Class，这里的s就相当于Class类型对象

Student s = new Student();

//方式一，getClass()方法,获得该对象的运行时类

Class<? extends Student> c1 = s.getClass();

Student s1 = new Student();

Class<? extends Student> c2 = s1.getClass();

System.out.println(c1==c2); // true

//这里结果为true的原因，同一个class可以new出来多个对象，但是只会对应一个Class类型对象

//所以c1和c2是一样的，但是s和s1是不一样的

System.out.println(s==s1); // false

System.out.println("-----------------------------");

//方式二，通过类名获得静态属性class

Class c3 = Student.class;

System.out.println(c3 == c1); //true

System.out.println(c3 == c2); //true

System.out.println("-----------------------------");

//方式三，利用Class类中的静态方法forName(String className)

//这个方法会返回给定字符串名称className的类或接口相关联的类对象，然后通过类对象调用类的方法和变量

//注意这里的className需要写类在项目中的具体位置

Class<?> c4 = Class.forName(“test.reflexDemo.Student”);

System.out.println(c4 == c3); //true

System.out.println(c4 == c2); //true

System.out.println(c4 == c1); //true

//Class后面的泛型可以不添加

//这样看起来更直接一些，c5是Class类型

Class c5 = Class.forName(“test.reflexDemo.Student”);

System.out.println(c5 == c4); //true

}

}

根据Class类型对象来创建类的实例

上面成功获得了Class类型对象，那么如何通过Class类型对象来创建对应的class类的对象呢？

思路是通过Class类型对象，来获得对应类的构造方法，然后再用构造方法来创建类的实例。

批量获取构造方法

package test.reflexDemo;

import java.lang.reflect.Constructor;

public class Demo2 {

public static void main(String[] args) throws ClassNotFoundException {

Class c = Class.forName(“test.reflexDemo.Student”);

//public Constructor<?>[] getConstructors()

// 返回文件中的所有public修饰的构造方法，不会获取private或者默认修饰的构造方法

Constructor[] constructors = c.getConstructors();

for (Constructor constructor : constructors) {

System.out.println(constructor);

}

System.out.println("----------------------");

//public Constructor<?>[] getDeclaredConstructors()

//返回所有的构造方法，包括private和默认修饰的构造方法

//另外这里获取的private修饰的构造方法也可以构建对象

Constructor[] dcs = c.getDeclaredConstructors();

for (Constructor d : dcs) {

System.out.println(d);

}

}

}

获取单个的构造方法

package test.reflexDemo;

import java.lang.reflect.Constructor;

public class Demo3 {

public static void main(String[] args) throws Exception {

Class c = Class.forName(“test.reflexDemo.Student”);

//public Constructor getConstructor(Class<?>… parameterTypes)

//括号里的参数是指具体数据类型对应的类，比如String要写成String.class

//什么都没写就是获取默认无参构造方法

Constructor cons1 = c.getConstructor();

System.out.println(“无参构造方法”+cons1);

Constructor cons2 = c.getConstructor(String.class,int.class,String.class);

System.out.println(“有参构造方法”+cons2);

//同样的，这样只能获得public类型,要想获得private类型需要改为

//getDeclaredConstructor

Constructor cons3 = c.getDeclaredConstructor(String.class);

System.out.println(“private修饰的有参构造方法”+cons3);

System.out.println("--------------------------");

//根据获得的构造方法创建实例

//public T newInstance(Object… initargs)

//括号里面写要传入构造方法中的参数

Object o1 = cons1.newInstance();

System.out.println(o1);

//这里可以向下转型

Student s = (Student)o1;

System.out.println(s);

//虽然获得了Private修饰的构造方法，但不能直接写入，会报权限不足的异常

//需要强行获取权限，暴力访问

cons3.setAccessible(true);

Object o2 = cons3.newInstance(“张”);

System.out.println(o2);

}

}

结果为

获取成员变量

批量获得成员变量

package test.reflexDemo;

import java.lang.reflect.Field;

public class Demo4 {

public static void main(String[] args) throws Exception{

Class c = Class.forName(“test.reflexDemo.Student”);

//获取所有的成员变量

//getFields()返回一个Field类型的数组，包含所有public修饰的成员变量

Field[] fields = c.getFields();

for (Field field : fields) {

System.out.println(field);

}

System.out.println("--------------------");

//getDeclaredFields()获取所有的成员变量，包括被private和默认修饰等类型修饰的变量

Field[] declaredFields = c.getDeclaredFields();

for (Field declaredField : declaredFields) {

System.out.println(declaredField);

}

}

}

获取单个成员变量并修改变量的值

package test.reflexDemo;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

public class Demo5 {

public static void main(String[] args) throws Exception{

Class c = Class.forName(“test.reflexDemo.Student”);

//getField(String name)根据变量名获取变量

Field hobby = c.getField(“hobby”);

System.out.println(hobby);

//set(Object obj, Object value)将指定obj对象的类的变量的值改为value

//这个方法由上面获取的Field变量对象来调用

Constructor constructor = c.getConstructor();

Object o = constructor.newInstance();

hobby.set(o,“敲代码”);

System.out.println(o);

System.out.println("------------------------");

//如果要修改被private修饰的变量，同样需要强行修改权限

Field name = c.getDeclaredField(“name”);

name.setAccessible(true);

name.set(o,“姓名是张”);

System.out.println(o);

}

}

结果是

获取成员方法

批量获取成员方法

package test.reflexDemo;

import java.lang.reflect.Method;

public class Demo6 {

public static void main(String[] args) throws Exception{

Class c = Class.forName(“test.reflexDemo.Student”);

//批量获取成员方法