反射的常见操作

测试类

在这里插入代码片
```public class Person {
	//姓名
		private String name;
		//年龄
		private int age;
		
		public Person() {
			System.out.println("执行了无参构造");
		}
		
		public Person(String name,int age) {
			super();
			this.name = name;
			this.age = age;
			System.out.println("执行了有参构造");
		}

		public String getName() {
			return name;
		}
		
		public void setName(String name) {
			this.name=name;
		}

		@Override
		public String toString() {
			return "Person [name=" + name + ", age=" + age + "]";
		}
		
		//吃
		public void eat() {
			System.out.println(name+"正在吃东西.......");
		}
		//带参的方法
		public void eat(String food) {
			System.out.println(name+"开始吃...."+food);
		}
		//私有的方法
		private void privateMethod() {
			System.out.println("这是一个私有方法");
		}
		//静态方法
		public static void staticMethod() {
			System.out.println("这说一个静态方法");
		}
}

```main方法测试

```java
在这里插入代码片
```public class TestPerson {
	public static void main(String[] args) throws Exception {
		//invokeAny()方法
//		Properties properties=new Properties();
//		invokeAny(properties, "setProperty", new Class[] {String.class,String.class},"username","张三");
//		System.out.println(properties.toString());
		
		reflectOpe4();
	}
	
	//获取类对象的三种方式
	public static void  getclass() throws Exception{
			//1使用对象获取类对象
		Person zhangsan=new Person();
		Class<?> c1=zhangsan.getClass();
		System.out.println(c1.hashCode());
		//2.使用类名.Class属性
		Class<?> c2=Person.class;
		System.out.println(c2.hashCode());
		//3.使用Class的静态方法[推荐使用]
		Class<?> c3=Class.forName("my.Person");
		System.out.println(c3.hashCode());
	}
	//1使用反射获取类的名字,包名,父类,接口
	public static void reflectOpe1() throws Exception{
		
	}
	//2使用反射获取类的构造方法.创建对象
	public static void reflectOpe2()throws Exception{

		//(1)获取类的类对象
		Class<?> c1=Class.forName("my.Person");
		//(2)获取类的构造方法Constructor
//		Constructor<?>[] cons=c1.getConstructors();
//		for (Constructor<?> c : cons) {
//			System.out.println(c.toString());
//		}
		//(3)获取类中无参构造
		Constructor<?> con=c1.getConstructor();
		Person zhangsan=(Person)c1.newInstance();
		Person lisi=(Person)con.newInstance();
		System.out.println(zhangsan.toString());
		System.out.println(lisi.toString());
		//简化方法
		Person wangwu=(Person)c1.newInstance();
		System.out.println(wangwu.toString());
		//(4)获取类中带参的构造方法
		Constructor<?> con2=c1.getConstructor(String.class,int.class);
		Person xiaoli=(Person)con2.newInstance("晓丽",20);
		System.out.println(xiaoli.toString());
		
		
	}

	//3使用反射获取类中的方法,并调用方法
	public static void reflectOpe3() throws Exception{

		//(1)获取类的对象
		Class<?> c1=Class.forName("my.Person");
		//(2)获取方法Mothod对象
		//2.1getMethods()获取公开的方法,包括从父类继承的方法
		//Method[] method=c1.getMethods();
		//2.2getDeclaredMethods()获取类中的所有方法,包括私有的,默认,保护的,不包含继承的方法
//		Method[] methods=c1.getDeclaredMethods();
//		for (Method method2 : methods) {
//			System.out.println(method2.toString());
//		}
		//(3)获取单个方法
		//3.1
		Method eatMethod=c1.getMethod("eat");
		//调用方法
		//正常调用方法 Person zhangsan=new Person();	zhangsan.eat
		Person zhangsan=(Person)c1.newInstance();
		eatMethod.invoke(zhangsan);//相当于zhangsan.eat();
		System.out.println("-----------------");
		//3.2toString
		Method toStringMethod=c1.getMethod("toString");
		Object result=toStringMethod.invoke(zhangsan);
		System.out.println(result);
		System.out.println("-----------------");
		//3.3带参的eat
		Method eatMethod2=c1.getMethod("eat",String.class);
		eatMethod2.invoke(zhangsan, "鸡腿");
		//3.4获取私有方法
		Method privateMethod=c1.getDeclaredMethod("privateMethod");
		//设置访问权限无效
		privateMethod.setAccessible(true);
		privateMethod.invoke(zhangsan);
		//3.5获取静态方法
		Method staticMethod=c1.getMethod("staticMethod");
		staticMethod.invoke(null);
	}
	
	
	//4使用反射实现一个可以调用任何对象方法的通用方法
	private static Object invokeAny(Object obj,String methodName,Class<?>[] types,Object...args)throws Exception{
		//获取类的对象
		Class<?> c1=obj.getClass();
		//获取方法
		Method method=c1.getMethod(methodName, types);
		//调用
		return method.invoke(obj, args);
	}

	//使用反射获取类中的属性
	public static void reflectOpe4()throws Exception{
		//(1)获取类的对象
		Class<?> c1=Class.forName("my.Person");
		//(2)获取属性(字段)公开的字段,父类继承的字段
		//Field[] fields=c1.getFields();
		//getDeclaredFields()获取所有的属性,包括私有,默认,包含
//		Field[] fields=c1.getDeclaredFields();
//		System.out.println(fields.length);
//		for (Field field : fields) {
//			System.out.println(field.toString());
//		}
		//(3)获取name属性
		Field namefield=c1.getDeclaredField("name");
		namefield.setAccessible(true);
		//(4)赋值 正常调用Person zhangsan=new Person();zhangsan.name="张三
		Person zhangsan=(Person)c1.newInstance();
		namefield.set(zhangsan, "张三");
		//(5)获取值
		System.out.println(namefield.get(zhangsan));///zhangsan.name
		
	}
}