java反射

                                                                          Java反射机制

         

             大家都知道，java不是一个动态语言，但是java不像c、c++的纯静态语言一样，它有个Reflection类能让它在运行的过程中获取相关类的信息，这就是java反射机制。

            java反射通俗的说就是程序在运行的过程中可以获得某个类的全部信息。

            而说到反射，就不能不说一下Class类，每一个类都会有一个Class对象，在编译生成的.Class文件中，就会产生一个class对象，来表示类型信息，我们就可以通过反射来调用之。用法比较简单，直接上代码。

           我建立了一个Dog的测试类，它有各种声明类型不同的属性以及限制符不同的方法    

package february24;
public class Dog {
	//定义dog类中的一些属性和方法。
	public String name;
	private int weight;
	protected int height;
	public int age = 5;
	//构造函数
	public Dog(){
	}
	private Dog(int age){
		this.age=age;
	}
	public Dog(String name){
		this.name=name;
	}
	public void bark(){
		System.out.println("汪汪.....");
	}
	private void bark0(){
		System.out.println("汪汪.....");
	}
	public void bark(String name){
		System.out.println(name+"汪汪汪。。。");
	}
}

       

              1：反射可以根据某个对象而得到其类的出处。

	public static void test0(){
		try{
			Dog jack = new Dog();
			String cName = jack.getClass().getName();
			System.out.println("jack对象所属类的路径为："+cName);
		}
		catch(Exception e){
			e.printStackTrace();
		}
	}

 

 运行结果为：jack对象所属类的路径为：february24.Dog

                 2：反射可以得到类的方法信息。

// 反射在知道类的名字后，可以得倒某个类的所有方法。
	public static void test1() {
		try {
			Class c = Class.forName("february24.Dog");
			//getMethods方法可以获得类的公开声明的成员方法以及其继承和实现的类（接口）的公开声明的成员方法
			Method mlist[] = c.getMethods();
			for (int i = 0; i < mlist.length; i++) {
				System.out.println("Dog中有一个" + mlist[i].toString() + "方法****");
			}
			//getDeclaredMethods只能得到本类的方法（即使是私有声明的）
			Method mlists[] = c.getDeclaredMethods();
			for (int i = 0; i < mlists.length; i++) {
				System.out.println("Dog中有一个" + mlists[i].toString() + "方法++++");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

                 其中，getMethods()方法可以得到某个类以及其父类或其实现的接口的公开声明的方法。getDeclaredMethod()方法能得到某个类中声明的所有方法。上面代码的结果为：

Dog中有一个public void february24.Dog.bark(java.lang.String)方法****
Dog中有一个public void february24.Dog.bark()方法****
Dog中有一个public final native java.lang.Class java.lang.Object.getClass()方法****
Dog中有一个public native int java.lang.Object.hashCode()方法****
Dog中有一个public boolean java.lang.Object.equals(java.lang.Object)方法****
Dog中有一个public java.lang.String java.lang.Object.toString()方法****
Dog中有一个public final native void java.lang.Object.notify()方法****
Dog中有一个public final native void java.lang.Object.notifyAll()方法****
Dog中有一个public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException方法****
Dog中有一个public final void java.lang.Object.wait() throws java.lang.InterruptedException方法****
Dog中有一个public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException方法****
Dog中有一个public void february24.Dog.bark(java.lang.String)方法++++
Dog中有一个public void february24.Dog.bark()方法++++
Dog中有一个private void february24.Dog.bark0()方法++++

                      3：与上面通过反射得到类的方法类似，通过反射可以得到类的构造函数和成员属性

得到构造函数：

//得到类中的构造函数
	public static void test2(){
		try{
			Class c = Class.forName("february24.Dog");
			Constructor conlist [] = c.getConstructors();
			//得到类中公开的构造函数
			for(int i = 0;i<conlist.length ;i++){
				System.out.println("Dog类中的构造函数为："+conlist[i].toString()+"****");
			}
			//可以得到所有的类中所有的构造方法
			Constructor conlists [] = c.getDeclaredConstructors();
			for(int i = 0;i<conlists.length;i++){
				System.out.println("Dog类中的构造函数为："+conlists[i].toString()+"++++");
			}
		}
		catch(Exception e){
			e.printStackTrace();
		}
	}

                   运行结果为：

Dog类中的构造函数为：public february24.Dog()****
Dog类中的构造函数为：public february24.Dog(java.lang.String)****
Dog类中的构造函数为：public february24.Dog()++++
Dog类中的构造函数为：private february24.Dog(int)++++
Dog类中的构造函数为：public february24.Dog(java.lang.String)++++

 得到成员属性：

//反射可以得到某个类中的定义的属性。
	public static void test3(){
		try{
			Class c = Class.forName("february24.Dog");
			Field flist[] = c.getFields();
			//这个方法只能得到Dog中的public方法。protected，private以及default均得不到。
			for(int i =0;i<flist.length;i++){
				System.out.println("Dog中有"+flist[i].toString()+"属性****");
			}
			Field flists[] = c.getDeclaredFields();
			for(int i =0;i<flists.length;i++){
				System.out.println("Dog中有"+flists[i].toString()+"属性++++");
			}
		}
		catch (Exception e){
			e.printStackTrace();
		}
	}

 其运行结果为：

 

Dog中有public java.lang.String february24.Dog.name属性****
Dog中有public int february24.Dog.age属性****
Dog中有public java.lang.String february24.Dog.name属性++++
Dog中有private int february24.Dog.weight属性++++
Dog中有protected int february24.Dog.height属性++++
Dog中有public int february24.Dog.age属性++++

 

 

                           4:利用反射还可以实现类似于instanceof功能。

	//反射可以有着类似于instanceof的功能。
	public static void test4(){
		try {
			Dog jack = new Dog();
			String a = new String("faith");
			Class c = Class.forName("february24.Dog");
			boolean b0 = jack instanceof Dog;
			boolean b1 =c.isInstance(a);
			System.out.println(b0+"$$$"+b1);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

                            输出结果为：

true$$$false

                         虽然做这种判断因为没有利用好java多态的优点而不推荐使用，但也算是一种java反射的用处。

                       5：利用发射可以创建新的对象以及调用类中的方法

public static void test5(){
		try{
		//首先获取类
		Class c = Class.forName("february24.Dog");
		Method m = c.getMethod("bark");
		m.invoke(c.newInstance());//其中c.newInstance()是新构造一个对象出来。
		}
		catch(Exception e){
			e.printStackTrace();
		}
	}
public static void test6(){
		try {
			Class c = Class.forName("february24.Dog");
			Method m = c.getMethod("bark",String.class);//具体调用方法的参数不一样，调用的方法不同
			m.invoke(c.newInstance(),"小黑：");//构造新对象，同时确定参数。
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

 得到的结果为：

汪汪.....
小黑：汪汪汪。。。

                  Class中有一个newInstance()方法可以创建新的对象。同时，我们也可以在程序运行的时候通过给定的参数利用Construction来创建新的对象，而不是在其编译的时候创建。

	public static void test7(){
		try {
			Class c = Class.forName("february24.Dog");
			Constructor con = c.getConstructor(String.class);
			Field f = c.getField("name");
			System.out.println(f.get(con.newInstance("Jack")));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}	

 输出的结果为：

Jack

 

                             6：利用反射修改类中的属性值

public static void test8(){
		try {
			Class c = Class.forName("february24.Dog");
			Object obj = c.newInstance();
			Field f = c.getField("age");
			f.setAccessible(true);//这个使得它能够修改变量
			f.set(obj,10);
			System.out.println("小狗的年龄为"+f.get(obj));
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

                  结果为：

小狗的年龄为10

            在刚开始测试的时候，我没有定义一个Object obj，在上面代码中的obj全是一个c.newInstance()，结果输出值为5。。。这个错误真是有些低级啊。。。

             反射还有一个Modifier类可以得倒某个方法或属性的修饰符。

public static void test9(){
		try {
			Class c = Class.forName("february24.Dog");
			Field f[] = c.getDeclaredFields();
			for(int i=0;i<f.length;i++){
				int a =f[i].getModifiers(); 
				System.out.println(f[i].toString()+"的限制符为："+Modifier.toString(a));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

 结果为：

public java.lang.String february24.Dog.name的限制符为：public
public int february24.Dog.age的限制符为：public
private int february24.Dog.weight的限制符为：private
protected int february24.Dog.height的限制符为：protected      

                         以上内容就是我对反射机制的基本尝试，在测试的过程中，我发现从点击运行到出来结果，虽然是一个很小的程序段，但是却不能立即得出答案。。。估计反射的应用会降低性能。同时，有什么不对的地方，欢迎大家指正。