`

Java中的反射机制Reflect

    博客分类:
  • Java
 
阅读更多
package com.reflect.sym;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class TestReflect {

	/**
	 * @param args
	 * 
	 * Java反射是Java语言的一个很重要的特征,它使得Java具有了"动态性"。
	 * 在Java运行环境中,对于任意一个类,能否知道这个类有哪些属性和方法?
	 * 对于任意一个对象,能否调用它的任意一个方法?答案是肯定的。这种动态获取
	 * 类的信息以及动态调用对象的方法的功能来自于Java语言的反射(Reflection)机制。
	 * Reflection是Java被视为动态(或准动态)语言的一个关键性质,这个机制允许程序在运行时透过
	 * Reflection APIs取得任何一个已知名称的class的内部信息,包括modifiers(诸如public,static等等)、superclass(例如object)、
	 * 实现之interfaces(如Serializable),也包括fields和methods的所有信息,并可于运行时改变fields内容或者调用methods。
	 * 程序运行时,允许改变程序结构或者变量类型,这种语言称为动态语言。从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C#不是动态语言。
	 * 在JDK中,主要由以下类来实现Java反射机制,这些类都位于java.lang.reflect包中:
	 * Class类:代表一个类。
	 * Field类:代表类的成员变量。
	 * Method类:代表类的方法。
	 * Constructor类:代表类的构造方法。
	 * Array类:提供了动态创建数组,以及访问数组的元素的静态方法。
	 */
	public static void main(String[] args) {
          /*
          * 通过一个对象获取完整的包名和类名
          */
//		Animal dog=new Dog();
//      System.out.print(dog.getClass().getName());//打印:com.reflect.sym.Dog
         /*
          * 所有类的对象其实都是Class的实例
          */
//		Class<?> dog1=null;
//		Class<?> dog2=null;
//		Class<?> dog3=null;
//		try {
//			dog1=Class.forName("com.reflect.sym.Dog");
//		} catch (ClassNotFoundException e) {
//			e.printStackTrace();
//		}
//         dog2=new Dog().getClass();
//         dog3=Dog.class;
//         System.out.println("类名称:"+dog1.getName());//类名称:com.reflect.sym.Dog
//         System.out.println("类名称:"+dog2.getName());//类名称:com.reflect.sym.Dog
//         System.out.println("类名称:"+dog3.getName());//类名称:com.reflect.sym.Dog
//         
         
		/*
		 * 通过Class实例化其他类的对象
		 * 在使用Class实例化其他类的对象的时候,一定要自己定义无参数的构造函数
		 */
//		Class<?> dog = null;
//		try {
//			dog = Class.forName("com.reflect.sym.Dog");
//		} catch (ClassNotFoundException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//		Dog dogd = null;
//		try {
//			dogd = (Dog) dog.newInstance();
//		} catch (InstantiationException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		} catch (IllegalAccessException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//		dogd.setAge(4);
//		System.out.print(dogd);
//		/*打印结果:age为:4*/
		/*
		 * 通过Class调用其他类中的构造函数(也可以通过这种方式通过Class创建其他类的对象)
		 * 此时构造方法可以有参数
		 */
//		Class<?>cat=null;
//		try {
//			cat=Class.forName("com.reflect.sym.Cat");
//		} catch (ClassNotFoundException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//		Cat cat1=null;
//		Cat cat2=null;
//		Cat cat3=null;
//		Cat cat4=null;
//		Constructor<?>cons[]=cat.getConstructors();
//		for(Constructor<?> con:cons){
//			System.out.println(con);
//		}
//		/*
//		 * 打印结果:public com.reflect.sym.Cat(int)
//		 *        public com.reflect.sym.Cat(java.lang.String)
//		 *        public com.reflect.sym.Cat(int,java.lang.String)
//		 *        public com.reflect.sym.Cat()
//		 */
//		try {
//			/*
//			 * 特别要注意这里的构造函数与类中的构造函数顺序不一定相同
//			 */
//			cat4=(Cat) cons[3].newInstance();
//			cat1=(Cat) cons[0].newInstance(20);
//			cat2=(Cat) cons[1].newInstance("kate");
//			cat3=(Cat) cons[2].newInstance(20,"Kate");
//		} catch (IllegalArgumentException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		} catch (InstantiationException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		} catch (IllegalAccessException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		} catch (InvocationTargetException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//		System.out.println(cat1);//age:20name:null
//		System.out.println(cat2);//age:0name:kate
//		System.out.println(cat3);//age:20name:Kate
//		System.out.println(cat4);//age:0name:null
		/*
		 * 获取其他类的继承的接口
		 */
//		Class<?>cat=null;
//		try {
//			cat=Class.forName("com.reflect.sym.Cat");
//		} catch (ClassNotFoundException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//		Class<?>intes[]=cat.getInterfaces();
//		for(Class<?> inte:intes){
//			System.out.print("实现的接口:"+inte.getName());//实现的接口:com.reflect.sym.Animal
//		}
		/*
		 * 获取其他类的继承的父类
		 */
//		Class<?>cat=null;
//		try {
//			cat=Class.forName("com.reflect.sym.Cat");
//		} catch (ClassNotFoundException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//		Class<?>father= cat.getSuperclass();
//	    System.out.print("实现的父类:"+father.getName());//实现的父类:java.lang.Object
//		
//		Class<?>cat=null;
//		try {
//			cat=Class.forName("com.reflect.sym.Cat");
//		} catch (ClassNotFoundException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//		Constructor<?>[]constrouts=cat.getConstructors();
//		for(Constructor<?> constrout:constrouts){
//			System.out.println("拥有的构造函数:"+constrout);
//		}
//		/*打印结果:拥有的构造函数:public com.reflect.sym.Cat(int)
//		                          拥有的构造函数:public com.reflect.sym.Cat(java.lang.String)
//		                          拥有的构造函数:public com.reflect.sym.Cat(int,java.lang.String)
//		                          拥有的构造函数:public com.reflect.sym.Cat()*/
//		
		
		/*
		 * 获取构造函数的修饰符
		 */
//		Class<?>cat=null;
//		try {
//			cat=Class.forName("com.reflect.sym.Cat");
//		} catch (ClassNotFoundException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//		Constructor<?>[]constrouts=cat.getConstructors();
//		for(int i=0;i<constrouts.length;i++){
//			Class<?> p[]=constrouts[i].getParameterTypes();
//			int mo=constrouts[i].getModifiers();
//			 System.out.print(Modifier.toString(mo)+" ");//这个打印出“public”
//			 System.out.print(constrouts[i].getName());//com.reflect.sym.Cat
//			 System.out.print("(");
//			 for(int j=0;j<p.length;++j){
//	                System.out.print(p[j].getName()+" arg"+i);
//	                if(j<p.length-1){
//	                    System.out.print(",");
//	                }
//	            }
//			 System.out.println("){}");
//		}
//		/*打印结果:public com.reflect.sym.Cat(int arg0){}
//		          public com.reflect.sym.Cat(java.lang.String arg1){}
//		          public com.reflect.sym.Cat(int arg2,java.lang.String arg2){}
//		          public com.reflect.sym.Cat(){}*/
		/*
		 * 打印出方法,有时候出现异常的方法
		 */
//		Class<?>cat=null;
//		try {
//			cat=Class.forName("com.reflect.sym.Cat");
//		} catch (ClassNotFoundException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//		 Method method[]=cat.getMethods();
//		 for(int i=0;i<method.length;++i){
//	            Class<?> returnType=method[i].getReturnType();
//	            Class<?> para[]=method[i].getParameterTypes();
//	            int temp=method[i].getModifiers();
//	            System.out.print(Modifier.toString(temp)+" ");
//	            System.out.print(returnType.getName()+"  ");
//	            System.out.print(method[i].getName()+" ");
//	            System.out.print("(");
//	            for(int j=0;j<para.length;++j){
//	                System.out.print(para[j].getName()+" "+"arg"+j);
//	                if(j<para.length-1){
//	                    System.out.print(",");
//	                }
//	            }
//	            Class<?> exce[]=method[i].getExceptionTypes();
//	            if(exce.length>0){
//	                System.out.print(") throws ");
//	                for(int k=0;k<exce.length;++k){
//	                    System.out.print(exce[k].getName()+" ");
//	                    if(k<exce.length-1){
//	                        System.out.print(",");
//	                    }
//	                }
//	            }else{
//	                System.out.print(")");
//	            }
//	            System.out.println();
//	        }
//		/* 打印结果:public java.lang.String  toString ()
//		 public java.lang.String  getName ()
//		 public void  setName (java.lang.String arg0)
//		 public void  call (java.lang.String arg0)
//		 public java.lang.String  eat ()
//		 public int  getAge ()
//		 public void  setAge (int arg0)
//		 public final void  wait () throws java.lang.InterruptedException 
//		 public final void  wait (long arg0,int arg1) throws java.lang.InterruptedException 
//		 public final native void  wait (long arg0) throws java.lang.InterruptedException 
//		 public native int  hashCode ()
//		 public final native java.lang.Class  getClass ()
//		 public boolean  equals (java.lang.Object arg0)
//		 public final native void  notify ()
//		 public final native void  notifyAll ()*/
//		
		/*
		 * 获取其他类的全部属性
		 */
//		 Class<?> cat = null;
//	        try {
//	            cat = Class.forName("com.reflect.sym.Cat");
//	        } catch (Exception e) {
//	            e.printStackTrace();
//	        }
//	        System.out.println("===============本类属性========================");
//	        // 取得本类的全部属性
//	        Field[] field = cat.getDeclaredFields();
//	        for (int i = 0; i < field.length; i++) {
//	            // 权限修饰符
//	            int mo = field[i].getModifiers();
//	            String priv = Modifier.toString(mo);
//	            // 属性类型
//	            Class<?> type = field[i].getType();
//	            System.out.println(priv + " " + type.getName() + " "
//	                    + field[i].getName() + ";");
//	        }
//	        System.out.println("===============实现的接口或者父类的属性========================");
//	        // 取得实现的接口或者父类的属性
//	        Field[] filed1 = cat.getFields();
//	        for (int j = 0; j < filed1.length; j++) {
//	            // 权限修饰符
//	            int mo = filed1[j].getModifiers();
//	            String priv = Modifier.toString(mo);
//	            // 属性类型
//	            Class<?> type = filed1[j].getType();
//	            System.out.println(priv + " " + type.getName() + " "
//	                    + filed1[j].getName() + ";");
//	        }
//	       /*打印结果: ===============本类属性========================
//	        	 int age;
//	        	 java.lang.String name;
//	        	===============实现的接口或者父类的属性========================
//	        	public static final int data;*/
	        /*
	         * 通过反射调用其他类中的方法
	         */
//	        Class<?> cat = null;
//	        try {
//	            cat = Class.forName("com.reflect.sym.Cat");
//	        } catch (Exception e) {
//	            e.printStackTrace();
//	        } 
//	        try{
//          //调用Cat类中的toString方法,这里只是显示控制台上的,只显示出System.out.print("")中的内容
//	        	 Method method=null;
//	            method=cat.getMethod("toString");
//	            method.invoke(cat.newInstance());
//	            //调用Cat的call方法
//	            method=cat.getMethod("call", String.class);
//	            method.invoke(cat.newInstance(),"Rollen");
//	        }catch (Exception e) {
//	            e.printStackTrace();
//	        }
//	        
//	  /*        打印结果:Rollen*/
	         /*
	          * 获取get和set方法
	          */
//		Class<?> cat = null;
//		Object obj = null;
//		try {
//			cat = Class.forName("com.reflect.sym.Cat");
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//		try {
//			obj = cat.newInstance();
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
//		Method method;
//		//此处注意要先set后get
//		try {
//			method = obj.getClass().getMethod("set" + "Name", String.class);
//			try {
//				method.invoke(obj, "Kate");
//				method = obj.getClass().getMethod("get" + "Name");
//				System.out.println(method.invoke(obj));
//			} catch (IllegalArgumentException e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			} catch (IllegalAccessException e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			} catch (InvocationTargetException e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}
//				
//		} catch (SecurityException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		} catch (NoSuchMethodException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
		//打印结果:Kate
			/*
			 * 通过反射操作属性	
			 */
//		
//		Class<?> cat = null;
//		 Object obj = null;
//		 
//		 try {
//			cat = Class.forName("com.reflect.sym.Cat");
//			 try {
//				obj = cat.newInstance();
//				Field field;
//				try {
//					field = cat.getDeclaredField("name");
//					 field.setAccessible(true);
//	                 field.set(obj, "Kate");
//	                 System.out.println(field.get(obj));
//				} catch (SecurityException e) {
//					// TODO Auto-generated catch block
//					e.printStackTrace();
//				} catch (NoSuchFieldException e) {
//					// TODO Auto-generated catch block
//					e.printStackTrace();
//				}
//	       
//			} catch (InstantiationException e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			} catch (IllegalAccessException e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}
//	 
//	        
//		} catch (ClassNotFoundException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//	       /*
//	        * 打印结果:Kate
//	        */
		/*
		 * 通过反射取得并修改数组的信息
		 */
//		int[] temp={1,2,3,4,5};
//        Class<?>cat=temp.getClass().getComponentType();
//        System.out.println("数组类型: "+cat.getName());
//        System.out.println("数组长度  "+Array.getLength(temp));
//        System.out.println("数组的第一个元素: "+Array.get(temp, 0));
//        Array.set(temp, 0, 100);
//        System.out.println("修改之后数组第一个元素为: "+Array.get(temp, 0)); 
//      /*  打印结果:数组类型: int
//                             数组长度  5
//                             数组的第一个元素: 1
//                              修改之后数组第一个元素为: 100*/
        /*
         * 反射修改数组的大小
         * 
         */
//		 int[] temp={1,2,3,4,5,6,7,8,9};
//		    Class<?>arr=temp.getClass().getComponentType();
//	        Object newArr=Array.newInstance(arr, 15);
//	        int co=Array.getLength(temp);
//	        System.arraycopy(temp, 0, newArr, 0, co);
//	        int[] newTemp=(int[])newArr;
//	        Class<?>c=temp.getClass();
//	        if(!c.isArray()){
//	            return;
//	        }
//	        System.out.println("数组长度为: "+Array.getLength(temp));
//	        for (int i = 0; i < Array.getLength(temp); i++) {
//	            System.out.print(Array.get(temp, i)+" ");
//	        }
//	        System.out.println("=====================");
//	        String[] atr={"a","b","c"};
//	        Class<?>arr1=atr.getClass().getComponentType();
//	        Object newArr1=Array.newInstance(arr1, 8);
//	        int co1=Array.getLength(atr);
//	        System.arraycopy(atr, 0, newArr1, 0, co1);
//	        String[] str1=(String[])newArr1;
//	        Class<?>c1=atr.getClass();
//	        if(!c1.isArray()){
//	            return;
//	        }
//	        System.out.println("数组长度为: "+Array.getLength(atr));
//	        for (int i = 0; i < Array.getLength(atr); i++) {
//	            System.out.print(Array.get(atr, i)+" ");
//	        }
//	       /*打印结果: 数组长度为: 9
//	        1 2 3 4 5 6 7 8 9 =====================
//	                        数组长度为: 3
//	        a b c*/ 
	    /*
	     *     如何获取类加载器
	     */
//		Cat cat=new Cat();
//		 System.out.println("类加载器  "+cat.getClass().getClassLoader().getClass().getName());
//		/* 打印结果:类加载器  sun.misc.Launcher$AppClassLoader*/
//		/* 其实在java中有三种类类加载器。
//
//		 1)Bootstrap ClassLoader 此加载器采用c++编写,一般开发中很少见。
//
//		 2)Extension ClassLoader 用来进行扩展类的加载,一般对应的是jre\lib\ext目录中的类
//
//		 3)AppClassLoader 加载classpath指定的类,是最常用的加载器。同时也是java中默认的加载器。*/
		
		/*
		 * 动态代理
		 */
		  MyInvocationHandler demo = new MyInvocationHandler();
	        Animal sub = (Animal) demo.bind(new Cat());
	         sub.call("Kate");
	      /*   打印结果:Kate*/
	}

}
================================================================================
Animal接口:
package com.reflect.sym;

import sun.font.EAttribute;


public interface Animal {
	// 属性一定是public final static
	int data = 0;

	// 方法一定是public的
	 void call(String str);

	String eat();

}
=================================================================================
Cat类:
package com.reflect.sym;

public class Cat implements Animal {
	int age;
	String name;

	public Cat() {
		// TODO Auto-generated constructor stub
	}

	public Cat(int age) {
		this.age = age;
	}

	public Cat(String name) {
		this.name = name;
	}

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

	public void call(String str) {
		// TODO Auto-generated method stub
           System.out.print(str);
	}

	@Override
	public String eat() {
		// TODO Auto-generated method stub
		return null;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String toString() {
		return "age:" + age+"name:"+name;
	}

	public String getName() {
		return name;
	}

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

}
=================================================================================
Dog类:
package com.reflect.sym;

public class Dog implements Animal {
int age;
public Dog() {
	// TODO Auto-generated constructor stub
}
	public void call(String str) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public String eat() {
		// TODO Auto-generated method stub
		return null;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
public String toString(){
	return "age为:"+age;
}

}
================================================================================
InvocationHandler类(代理用):
package com.reflect.sym;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MyInvocationHandler implements InvocationHandler {
	private Object obj = null;
	 
    public Object bind(Object obj) {
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
                .getClass().getInterfaces(), this);
    }
 
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		
		Object temp = method.invoke(this.obj, args);
        return temp;
	}

}

分享到:
评论

相关推荐

    java面试题--反射机制

    Java反射机制主要依赖于`java.lang.reflect`包下的API,其中包括: - `java.lang.Class`:表示一个类的运行时信息。 - `java.lang.reflect.Method`:表示类的方法。 - `java.lang.reflect.Field`:表示类的字段。 -...

    java中的反射reflect

    本文将通过实例深入解析Java反射机制。 首先,我们来看`TestParam.java`和`ParamClass.java`这两个文件,它们可能涉及到参数化类的使用。在Java中,反射可以帮助我们在运行时获取泛型信息。尽管Java的类型擦除导致...

    什么是java中的反射机制(reflect).docx

    Java 反射机制是 Java 语言中的一种动态获取信息和动态调用对象方法的功能。它允许在运行时判断任意一个对象所属的类、在运行时构造任意一个类的对象、在运行时判断任意一个类所具有的成员变量和方法、在运行时调用...

    Java中的反射机制

    Java反射机制允许运行中的程序检查自身,并能直接操作程序的内部属性。这是其他许多编程语言(如Pascal、C或C++)不具备的能力。 **1.1 Reflection的工作机制** 为了展示反射如何工作,我们来看一个简单的例子: ...

    JAVA的反射机制与动态代理

    Java的反射机制与动态代理是Java编程中两个非常重要的高级特性,它们在许多实际场景中发挥着关键作用,如框架开发、插件系统、元数据处理等。下面将详细讲解这两个概念及其应用。 首先,Java的反射机制允许我们在...

    java的反射机制及其实际应用

    ### Java的反射机制及其实际应用 #### 一、引言 ...总之,Java反射机制是一项强大的工具,它能够在运行时动态地获取和操作类的信息。然而,应该谨慎使用反射,避免滥用造成不必要的性能损失或安全风险。

    Java反射机制 Java反射机制

    Java反射机制主要通过`java.lang.reflect`包下的API实现,其中最重要的类包括: - `Class`:代表一个类,是所有反射操作的基础。 - `Method`:表示类中的一个方法。 - `Constructor`:表示类中的一个构造函数。...

    java反射机制详解

    ### Java反射机制详解 #### 一、反射机制是什么 反射机制是Java编程语言的一个核心特性,它允许程序在运行时动态地获取类的信息,并且能够动态地创建对象和调用对象的方法。简单来说,反射机制使得Java程序可以...

    Java反射机制

    ### Java反射机制详解 #### 一、什么是Java的反射机制 Java反射机制是Java语言的一种重要特性,使得Java成为了一种动态性很强的语言。通过反射,可以在程序运行时获取类的信息,包括类名、父类、接口、字段、方法...

    java的反射机制

    Java反射机制的实现主要依赖于`java.lang.reflect`包中的几个核心类: - **Class类**:表示一个类,是反射机制的核心。通过Class类可以获取类的各种信息,如构造器、方法、字段等。 - **Field类**:表示类的成员...

    Java 反射机制 代码的实例

    Java反射机制是Java编程语言中的一个强大特性,它允许程序在运行时检查和操作类、接口、对象等的内部结构。通过反射,开发者可以动态地获取类的信息并调用其方法,创建对象,访问私有成员,甚至改变类的行为。在深入...

    反射实例-JAVA反射机制

    ### 反射实例—JAVA反射机制 #### 一、反射概念及原理 反射在计算机科学领域,特别是程序设计中,是指程序有能力访问、检测和修改其自身的结构和行为。这一概念最早由Smith于1982年提出,并迅速应用于各种编程语言...

    Java反射机制课件ppt

    Java反射机制是Java编程语言中的一个重要特性,它允许程序在运行时动态地获取类的信息并操作类的对象。这种机制使得Java具有高度的灵活性和动态性,可以在编译时未知类的情况下进行类的加载、实例化、方法调用等操作...

    Reflection_in_Java.zip_in_java 反射_java 反射机制_java反射_反射机制

    Java反射机制是Java编程语言中一个强大的特性,它允许运行时的程序动态地获取类的信息并操作类的对象。在Java中,反射主要涉及到`java.lang.Class`类、`java.lang.reflect`包下的类如`Constructor`、`Method`和`...

    java反射(reflect)

    Java反射(Reflect)是Java语言中的一个重要特性,它允许运行时的Java程序访问、操作类、接口、字段和方法的信息,甚至动态调用方法。在Java编程中,反射提供了强大的能力,可以用来实现一些高级功能,如元编程、...

Global site tag (gtag.js) - Google Analytics