反射实际开发使用

//第一种方式 通过Class类的静态方法——forName()来实现
class1 = Class.forName("com.lvr.reflection.Person");
//第二种方式 通过类的class属性
class1 = Person.class;
//第三种方式 通过对象getClass方法
Person person = new Person();
Class<?> class1 = person.getClass();

Class<?> cls=Class.forName("com.yc.Person"); //forName(包名.类名)
Person p= (Person) cls.newInstance();

Class<?> cls = Person.class;
Person p=(Person)cls.newInstance();

Person p = new Person();
Class<?> cls= p.getClass();
Person p2=(Person)cls.newInstance();

//在AppBarLayout类中
public static class Behavior extends AppBarLayout.BaseBehavior<AppBarLayout>
//BaseBehavior的父类
protected static class BaseBehavior<T extends AppBarLayout> extends HeaderBehavior<T>

Class<?> superclass = AppBarLayout.Behavior.class.getSuperclass();

Class<?> superclass = AppBarLayout.Behavior.class.getSuperclass();
headerBehaviorType = superclass.getSuperclass();

//第一种方式 Class对象调用newInstance()方法生成
Object obj = class1.newInstance();
//第二种方式 对象获得对应的Constructor对象，再通过该Constructor对象的newInstance()方法生成
Constructor<?> constructor = class1.getDeclaredConstructor(String.class);//获取指定声明构造函数
obj = constructor.newInstance("hello");

private void method8() {
    try {
        Class<?> cl = Class.forName("com.ycbjie.other.ui.activity.Student");
        // 生成新的对象：用newInstance()方法
        Student obj = (Student) cl.newInstance();
        String student1 = obj.getStudent();
        LogUtils.i("反射调用类的方法1:"+student1);
        //首先需要获得与该方法对应的Method对象
        Method method = cl.getDeclaredMethod("setAge", int.class);
        //设置权限
        method.setAccessible(true);
        //调用指定的函数并传递参数
        method.invoke(obj, 28);
        String student2 = obj.getStudent();
        LogUtils.i("反射调用类的方法2:"+student2);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }
}

//打印值
2019-06-11 18:24:40.146 23666-23666/com.ycbjie.other I/yc: 反射调用类的方法1:yc---26
2019-06-11 18:24:40.146 23666-23666/com.ycbjie.other I/yc: 反射调用类的方法2:yc---28

private void method9() {
    try {
        Class<?> cl = Class.forName("com.ycbjie.other.ui.activity.Student");
        // 生成新的对象：用newInstance()方法
        Student obj = (Student) cl.newInstance();
        int age = obj.getAge();
        LogUtils.i("反射访问成员变量值1:"+age);
        //获取age成员变量
        //Field field = cl.getField("age");
        Field field = cl.getDeclaredField("age");
        //设置权限
        field.setAccessible(true);
        //将obj对象的age的值设置为10
        field.setInt(obj, 10);
        //获取obj对象的age的值
        int anInt = field.getInt(obj);
        LogUtils.i("反射访问成员变量值2:"+anInt);

        //反射修改私有变量
        // 获取声明的 code 字段，这里要注意 getField 和 getDeclaredField 的区别
        Field gradeField = cl.getDeclaredField("name");
        // 如果是 private 或者 package 权限的，一定要赋予其访问权限
        gradeField.setAccessible(true);
        // 修改 student 对象中的 Grade 字段值
        gradeField.set(obj, "逗比");
        Object o = gradeField.get(obj);
        LogUtils.i("反射访问成员变量值3:"+o.toString());
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    }
}



2019-06-11 19:06:59.380 12313-12313/com.ycbjie.other I/yc: 反射访问成员变量值1:26
2019-06-11 19:06:59.380 12313-12313/com.ycbjie.other I/yc: 反射访问成员变量值2:10
2019-06-11 19:06:59.380 12313-12313/com.ycbjie.other I/yc: 反射访问成员变量值3:逗比

public class Student {

	private String name;

	private int age;

	public Student() {

	}

	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		System.out.println("调用了getName方法，Name：" + name);
		return name;
	}

	public int getAge() {
		System.out.println("调用了getAge方法，Age：" + age);
		return age;
	}

	private void setName(String name) {
		this.name = name;
		System.out.println("调用了setName方法,name:" + name);
	}

	private void setAge(int age) {
		this.age = age;
		System.out.println("调用了setAge方法，age:" + age);
	}
}

public class Main {

	public static void main(String[] args) throws Exception {
		Class cl = Class.forName("com.czy.demo.Student");
		// 指定构造函数
		Constructor constructor = cl.getConstructor(String.class, Integer.TYPE);
		// 根据指定的构造函数来获取对象
		Object object = constructor.newInstance("杨充逗比", 25);

		// 指定方法名称来获取对应的公开的Method实例
		Method getName = cl.getMethod("getName");
		// 调用对象object的方法
		getName.invoke(object);

		// 指定方法名称来获取对应的公开的Method实例
		Method getAge = cl.getMethod("getAge");
		// 调用对象object的方法
		getAge.invoke(object);
	}
}

调用了getName方法，Name：杨充逗比
调用了getAge方法，Age：25

public class Main {
	public static void main(String[] args) throws Exception {
		Class cl = Class.forName("com.czy.demo.Student");
		// 指定构造函数
		Constructor constructor = cl.getConstructor(String.class, Integer.TYPE);
		// 根据指定的构造函数来获取对象
		Object object = constructor.newInstance("杨充逗比", 25);

		// 指定方法名称来获取对应的私有的Method实例
		Method setName = cl.getDeclaredMethod("setName", String.class);
		setName.setAccessible(true);
		setName.invoke(object, "潇湘剑雨");
		
		// 指定方法名称来获取对应的私有的Method实例
		Method setAge = cl.getDeclaredMethod("setAge", Integer.TYPE);
		setAge.setAccessible(true);
		setAge.invoke(object, 100);
	}
}

调用了setName方法,name:潇湘剑雨
调用了setAge方法，age:100