<Java>反射笔记

Class类

Class类：字节码文件对应的对象
获取Class类的实例
方法一：
对象.getClass()——>Class类的实例对象
Class cls1 = p1.getClass();
方法二：
类名.class——>Class类的实例对象
Class cls2 = Person.class;
方法三：
Class类提供了一个静态的方法：forName()
Class cls3 = Class.forName(“包名.类名”);

三种获取Class对象方式

Constructor

1、获取所有的public 的构造方法：数组
Constructor<?>[] getConstructors()  
2、获取单个的public 的构造方法：具体的某一个构造方法
Constructor<T> getConstructor(Class<?>... parameterTypes) 
    
3、获取所有的构造方法：数据
Constructor<?>[] getDeclaredConstructors()  
4、获取单个构造方法：具体的某一个构造方法
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)  

T newInstance(Object... initargs) 
使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。

Field

思路：
//step1：获取Class类的实例
//step2：获取Field类实例，表示属性
//step3：访问实例的属性，进行赋值

获取Field实例

3.Field getDeclaredField(String name)
返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。 /
//4.Field[] getDeclaredFields()
返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。

操作属性：

A：设置是否可以访问：
field.setAccessible(true);
B：设置某个实例的该属性值
field.set(对象，数据);

Method(常用)

Method getMethod(String name, Class<?>... parameterTypes) 
 返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。 
 Method[] getMethods() ;//本类的和父类的public类型的方法。
返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。 

 Method getDeclaredMethod(String name, Class<?>... parameterTypes)
    返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。 
 Method[] getDeclaredMethods() //获取本类中所有的方法，但是不包括继承来的 
   返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。 

非静态方法：无参，无返回值，对象调用

public class method1 {
//1.非静态方法：无参，无返回值，对象调用
	public static void main(String[] args) throws Exception {
			Class<?> cs=Person.class;
			
			Constructor<?> constructor = cs.getConstructor();
			Person p = (Person) constructor.newInstance();
			Method mm = cs.getMethod("test1");
		
			mm.invoke(p); 
				}
}

非静态：有参，有返回值

public class method {

	public static void main(String[] args) throws Exception {
		//1,获取Class
		Class<?> ss=Person.class;
		//2,获取Method
		Method mm = ss.getMethod("test2", String.class,int.class);
		System.out.println(mm);
		//执行这个构造方法
		Constructor<?> constructor = ss.getConstructor();
		Person p = (Person) constructor.newInstance();
		String str	=(String) mm.invoke(p, "hello",100);
				System.out.println(str);

	}

}

静态方法，第一个参数表示调用该方法的对象，null即可

public class Test4ReflectionMethod {

	public static void main(String[] args)throws Exception {
		Class<?> cls1 = Person.class;
		
		Method method5 = cls1.getMethod("fun");
		System.out.println(method5);
		
		//静态方法，第一个参数表示调用该方法的对象，null即可。
		method5.invoke(null);
	}

}

public class Test3ReflectionMethod {

	public static void main(String[] args) throws Exception{
		//step1.获取Class类
		Class<?> cls1 = Person.class;
		//step2：获取Method类
		Method method4 = cls1.getDeclaredMethod("test4");
		System.out.println(method4);
		//step3：执行方法
		Constructor<?> constructor = cls1.getConstructor();
		Person p = (Person) constructor.newInstance();
		
		//执行private 的方法
		method4.setAccessible(true);
		method4.invoke(p);
		
		
		Method method3 = cls1.getDeclaredMethod("test3");
		System.out.println(method3);
		method3.invoke(p);
	}

}

public class Test4ReflectionMethod {

	public static void main(String[] args)throws Exception {
		Class<?> cls1 = Person.class;
		
		Method method5 = cls1.getMethod("fun");
		System.out.println(method5);
		
		//静态方法，第一个参数表示调用该方法的对象，null即可。
		method5.invoke(null);
	}

}

public class Test5 {

	public static void main(String[] args) {
		/*
		 * java.lang.String类
		 */
		Class<?> cls1 = String.class;
//		Method[] methods = cls1.getMethods();
		Method[] methods = cls1.getDeclaredMethods();
		System.out.println(methods.length);
		for(int i=0;i<methods.length;i++){
			System.out.println(methods[i]);
		}
	}

}

package ss;


public class Person {
	private String name;
	private int age;
	
	
	public void test1(){
		System.out.println("Person类的test1方法。。。");
	}
	
	public String test2(String str,int num){
		System.out.println("Person类中test2方法。。");
		return str + num;
	}
	
	protected void test3(){
		System.out.println("protected的方法。。。");
	}
	
	private void test4(){
		System.out.println("私有方法。。。");
	}
	
	public static void fun(){
		System.out.println("静态方法。。");
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Person() {
		super();
	}
	
	private Person(String name){
		this.name = name;
	}
		}