JAVA反射总结(1)

反射：

反射机制是在【运行状态】中：

1对于任何一个类，都能够知道这个类的所有属性和方法；

2对于任何一个对象，都能够调用他的任意一个方法和属性；

3反射提供的功能：

4在运行时判断任意一个对象所属的类；

5在运行时构造任何一个类的对象；

6在运行时判断任何一个类所具有的成员变量和方法；

7在运行时调用任意一个对象的方法；

8生成动态代理；

话不多说，代码安排；

首先，要操作反射，首先我们要拿到反射入口（获取反射对象）Class，拿反射入口的方法有三种，如下

1.Class.forName(string className);其中className是全类名，比如java.lang.String

2.类名.class

3.对象.getClass

以上三个的返回值都是Class类型。

ok，先创建2个接口，分别是myInterface1.java，myInterface2.java，代码如下：

package com.charles.reflectDemo;

public interface myInterface1
{
	public void myInterface1Method();
}

package com.charles.reflectDemo;

public interface myInterface2
{
	public void myInterface2Method();
}

再创建reflectDemo.java并实现以上两个接口，待会即用这个类来做实验。

package com.charles.reflectDemo;

public class reflectDemo implements myInterface1,myInterface2{
	private String name;
	private int id;
	public String desc;
	public reflectDemo(String name, int id, String desc) {
		super();
		this.name = name;
		this.id = id;
		this.desc = desc;
	}
	public reflectDemo(String name, int id) {
		super();
		this.name = name;
		this.id = id;
	}
	public reflectDemo() {
		super();
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getDesc() {
		return desc;
	}
	public void setDesc(String desc) {
		this.desc = desc;
	}
	@Override
	public void myInterface2Method() {
		System.out.println("method myInterface2Method");
	}
	@Override
	public void myInterface1Method() {
		System.out.println("method myInterface1Method");
		
	}
	private void sayHello()
	{
		System.out.println("method sayHello");
	}
}

接下来我们创建测试类testDemo.java，该类一共有9个定义的方法，我们用来分别main方法中测试：

第一个方法：

public static void demo1()  //测试三种反射入口
	{
		Class<?> demoClazz=null;
		try {
			demoClazz = Class.forName("com.charles.reflectDemo.reflectDemo");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(demoClazz);
		System.out.println(reflectDemo.class);
		System.out.println(new reflectDemo().getClass());
	}

执行结果：三个方法都没问题

第二个：

public static void demo2()  //获取所有公共方法，包括接口的和继承的，默认继承Object
	{
		Class<?> demoClazz=null;
		try {
			demoClazz = Class.forName("com.charles.reflectDemo.reflectDemo");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Method[] methods=demoClazz.getMethods();
		for(Method method:methods)
		{
			System.out.println(method);
		}
	}

执行结果：拿到了所有的公共方法，包括父类和接口的

第三个：

public static void demo3() //获取本类所有的方法，包括私有
	{
		Class<?> demoClazz=null;
		try {
			demoClazz = Class.forName("com.charles.reflectDemo.reflectDemo");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Method[] methods=demoClazz.getDeclaredMethods();
		for(Method method:methods)
		{
			System.out.println(method);
		}
	}

测试结果：可以获得本类实现的所有方法，包括私有

第四个：

public static void demo4()   //获取所有公有字段
	{
		Class<?> demoClazz=null;
		try {
			demoClazz = Class.forName("com.charles.reflectDemo.reflectDemo");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Field[] fields=demoClazz.getFields();
		for(Field field:fields)
		{
			System.out.println(field);
		}
	}

测试结果：拿到了本类的共有属性字段

第五个：

public static void demo5()  //获取所有声明字段，包括私有
	{
		Class<?> demoClazz=null;
		try {
			demoClazz = Class.forName("com.charles.reflectDemo.reflectDemo");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Field[] fields=demoClazz.getDeclaredFields();
		for(Field field:fields)
		{
			System.out.println(field);
		}
	}

测试结果：拿到所有的属性字段，包括私有

第六个：

public static void demo6()  //获取所有构造函数
	{
		Class<?> demoClazz=null;
		try {
			demoClazz = Class.forName("com.charles.reflectDemo.reflectDemo");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Constructor[] constructors=demoClazz.getConstructors();
		for(Constructor constructor:constructors)
		{
			System.out.println(constructor);
		}
	}

测试结果：拿到了所有的构造函数

第七个：

public static void demo7()  //获取超类
	{
		Class<?> demoClazz=null;
		try {
			demoClazz = Class.forName("com.charles.reflectDemo.reflectDemo");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Class<?> className=demoClazz.getSuperclass();//超类只有一个，单继承
		System.out.println(className);
		
	}

测试结果：拿到了父类object

第八个：

public static void demo8()  //获取实现的接口
	{
		Class<?> demoClazz=null;
		try {
			demoClazz = Class.forName("com.charles.reflectDemo.reflectDemo");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Class<?>[] inter=demoClazz.getInterfaces();
		for(Object inters:inter)
		{
			System.out.println(inters);
		}
	}

测试结果：拿到了实现的接口

第九个：

public static void demo9()  //获取该类对象
	{
		Class<?> demoClazz=null;
		try {
			demoClazz = Class.forName("com.charles.reflectDemo.reflectDemo");
			Object demo=demoClazz.newInstance();
			reflectDemo demo1=	(reflectDemo)demo;
			demo1.myInterface1Method();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}

测试结果：完成了对象的实例化，并且调用了该类的方法！

下次有空就写：JAVA反射总结(2)，over！！