Java反射机制

Java反射机制

1.获取class对象

/**

 * 反射机制

 * 通过类或者对象，可以获取到类的所有结构信息

 * （修饰符、构造方法、方法、字段、类名、判断信息）

 * 通过对象，可以动态设置类的信息，动态执行方法

 * 反射机制是通过运行时类（class）进行操作

 * 每个类只有一个Class对象，Class对象是在类加载的时候就已经存在了，JVM分配的

 * 获取class对象的三种方法

 * 1.类名.class

 * 2.对象.getClass();

 * 3.Class.forName("类的全限定名称");

 * */

 

package day30.reflect;

public class ReflectDemo {

 

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

// 获取类的class对象

//第一种

Class<?> rClass=ReflectDemo.class;

//第二种

Class<?> rClass1=new ReflectDemo().getClass();

//第三种

Class<?> rClass2=Class.forName("day30.reflect.ReflectDemo");

System.out.println("rClass=="+rClass);

System.out.println("rClass1=="+rClass1);

System.out.println("rClass2=="+rClass2);

}

}

输出结果：

2.通过反射获取构造方法

 

package day30.reflect;

 

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Parameter;

//通过反射获取构造方法

public class ReflectDemo1 {

String name;

int age;

public ReflectDemo1() {

// TODO 自动生成的构造函数存根

}

private ReflectDemo1(String name) {

this.name=name;

}

ReflectDemo1(int age){

this.age=age;

}

public ReflectDemo1(String name,int age) {

this.name=name;

this.age=age;

}

@Override

public String toString() {

System.out.println(this.name+"\t"+this.age);

return super.toString();

}

 

public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

// 1.获取class对象

Class myClass=ReflectDemo1.class;

//反射获取带参数的构造方法

Constructor<ReflectDemo1>cons=myClass.getConstructor(String.class,int.class);

//获取构造方法的名称

System.out.println(cons.getName());

//获取构造方法参数列表的个数

System.out.println(cons.getParameterCount());

//通过构造方法对象创建类的对象

ReflectDemo1 ref=cons.newInstance("qq",21);

ref.toString();

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

//获取当前类公开的构造方法

//Constructor<?>[]conss=myClass.getConstructors();

//获取所有的构造方法

Constructor<?>[]conss=myClass.getDeclaredConstructors();

//遍历所有的构造方法对象

for (Constructor<?> constructor : conss) {

System.out.println("构造方法名称："+constructor.getName());

System.out.println("构造方法修饰符："+constructor.getModifiers());

System.out.println("构造方法参数个数："+constructor.getParameterCount());

System.out.println("构造方法的类型");

Parameter[]pars=constructor.getParameters();

for (Parameter parameter : pars) {

System.out.println(parameter.getName()+"\t"+parameter.getType());

}

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

}

}

}

输出结果：

3.通过反射获取类的所有方法

 

package day30.reflect;

 

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Parameter;

 

//通过反射获取类的所有方法

public class ReflectDemo2 {

 

public void meithod1() {

System.out.println("公共无参数方法");

}public static void method2() {

System.out.println("静态公共无参数方法");

}public void method3(String name) {

System.out.println("name:"+name);

}protected String value() {

return "Hello";

}void method3(int age,String name){

System.out.println(name+"\t"+age);

}private void method4() {

System.out.println("4");

}

 

public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

// 获取类的class对象

Class<?> myClass=ReflectDemo2.class;

//通过反射获取class的公共方法

/**

 * name:方法名

 * type：参数类型

 * */

Method mt=myClass.getMethod("method3", String.class);

System.out.println("方法的描述："+mt.toGenericString());

//调用方法

Object obj=myClass.newInstance();//默认的构造方法，创建对象

mt.invoke(obj, "qwe");

//获取当前类的所有方法

//Method[]methods=myClass.getMethods();//获取所有公开的包括继承父类的

Method[]methods=myClass.getDeclaredMethods();//获取当前类所有的方法

for (Method method : methods) {

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

System.out.println("方法名称："+method.getName());

System.out.println("方法参数个数："+method.getParameterCount());

System.out.println("方法的修饰符："+method.getModifiers());

System.out.println("方法的返回值class："+method.getReturnType());

System.out.println("方法的抛出异常类型：");

Class<?>[]arr=method.getExceptionTypes();

for (Class<?> class1 : arr) {

System.out.println("\t"+class1.getSimpleName());

}System.out.println("方法的参数列表：");

Parameter[]pars=method.getParameters();

for (Parameter parameter : pars) {

System.out.println(parameter.getName()+"\t"+parameter.getType());

}

}

}

}

输出结果：

4.通过反射获取字段

 

package day30.reflect;

 

//通过反射获取字段

public class ReflectDemo3 {

public static String msg;

public int age;

private String name;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public String toString() {

System.out.println(this.name+"\t"+this.age+"\t"+this.msg);

return super.toString();

}

}

 

package day30.reflect;

 

import java.lang.reflect.Field;

 

public class TsetDemo {

 

public static void main(String[] args) throws NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException {

//获取class对象

Class<?>myClass=ReflectDemo3.class;

//反射获取公共字段

Field field=myClass.getField("msg");//通过字段名称获取一个字段对象

System.out.println("字段名称："+field.getName());

//获取所有的成员

//Field[]fields=myClass.getFields();//获取所有的public成员

Field[]fields=myClass.getDeclaredFields();//所有成员

for (Field field2 : fields) {

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

System.out.println("字段名称："+field2.getName());

System.out.println("字段的修饰符："+field2.getModifiers());

System.out.println("字段类型："+field2.getType());

}

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

//字段取值或者设置值

//初始化对象

Object obj=myClass.newInstance();

//赋值，找到字段

Field f1=myClass.getDeclaredField("age");

f1.setInt(obj, 21);

f1=myClass.getDeclaredField("msg");

f1.set(obj, "Hello Java!");

f1=myClass.getDeclaredField("name");

//给私有成员赋值，需要打开权限

f1.setAccessible(true);

f1.set(obj, "qas");

//取值

System.out.println(f1.get(obj));

f1=myClass.getDeclaredField("age");

System.out.println(f1.get(obj));

//查看

obj.toString();

}

}

输出结果：