vvsongsunny
- 浏览: 896909 次
- 性别:
- 来自: 北京
-
文章分类
最新评论
-
天天来注册：
...
try catch finally 用法 -
tadpole_java：
谢谢你的分享。
二十七、Qt数据库（七）QSqlRelationalTableModel（转） -
359449749tan：
android之EditText文本监听(addTextChangedListener) -
michael_wang：
人过留名 多谢分享
Android NOtification 使用 -
wilsonchen：
wangqi0614 写道这个删除是删除所有的把？能不能值删除 ...
Android的SharedPreferences保存与删除数据简单实例
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;
}
}
- TestReflect.rar (9.7 KB)
- 下载次数: 12
分享到：
发表评论
-
判断两二叉树相等
2014-05-29 00:13 1089bool IsBSTEqual(BNode* root1, ... -
数据去重
2014-05-29 00:11 763引用 使用数据结构丰富的脚本语言，如Python，利用其中的字 ... -
判断一个整数是否为2的次方幂
2014-05-28 23:56 837/* 判断一个整数是否为2的次方幂 */ bool ... -
实现Comparable接口,进行排序
2014-05-28 23:47 8790import java.util.ArrayList; ... -
Struct2详解
2014-05-21 15:14 877引用 Servlet的缺点： 1、web.xml配置比较多 2 ... -
常用方法
2014-04-25 20:24 738[color=red]String[/color] ... -
java nio和io的比较
2014-04-16 19:49 1691引用 第一部分：简单介绍NIO 服务器在合理时间内处理 ... -
Struts2、Spring3、HIbernate4总结
2014-04-16 10:35 827引用 第一部分：Struts2 1 ... -
Finally的使用总结
2014-04-15 22:02 841//清单一： public class ... -
Fibonacci数列的递归与非递归
2014-04-15 20:57 681//非递归实现 //f(1)=1,f(2)=1,f(n) ... -
Java中的异常
2014-04-14 09:42 594引用 Throwable包括两个子类：Error和Except ... -
JVM的垃圾回收机制
2014-04-13 18:39 821引用 堆被划分为新生代和旧生代， 新生代包含Eden 和 S ... -
集合类总结
2014-04-04 15:54 621引用 一． 总的框架 总的有Collection和Map Co ... -
设计模式之策略模式
2014-04-01 17:07 592main ======================= ... -
设计模式之责任链模式
2014-04-01 16:32 707main ======================= ... -
设计模式之访问者模式
2014-03-31 18:57 824main ======================= ... -
设计模式之工厂模式
2014-03-31 11:33 608main ======================= ... -
设计模式之观察者模式
2014-03-30 15:04 823main =============== ... -
Java虚拟机JVM详解
2014-03-29 12:13 1218引用 第一部分：JVM基本结构 1.什么是JVM 一个java ... -
IOC原理详解
2014-03-28 09:54 1004引用 1.当不用IOC时： 在采用面向对象方法设计的软件系统中 ...
相关推荐
什么是java中的反射机制(reflect).docx
Java 反射机制 代码的实例 请认真阅读 运行此代码 只要读懂了 反射机制也就明白了
免费共享，很详细的介绍了反射机制的原理，适合追根究底的java学习者
ava反射机制 概述：通俗地讲Java反射就是通过类名获得类的实例的方法。java.lang.reflect提供了实现Java反射的API。
3.2.1 Java反射机制的概念 Java反射机制在Java运行状态中，对于任意一个类，我们都能够知道这个类的所有属性和方法；， 对于任意一个对象，我们都能够调用它的任意一个方法；。 这种动态获取的信息以及动态调用对象...
java反射机制核心代码,小弟一直弄不明白，怎么通过反射来调用私有成员方法，看了这个后，你可以随心调用private方法，和属性，记得添加setAccessable(true),哦，要不还是不行，如：method.setAccessable(true);
import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; public class ReflectionTest { public static void main(String[] args) { Class c = null; try { ...
java 高级必学资料 java中的反射机制(内含大量实例)
详细解析java的反射机制
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。...
java中的反射机制,pdf文档，常用的反射用法都有详细的说明。
java反射机制的作用有 1、在运行时判断任意一个类所具有的成员变量和方法 2、在运行时构造任意一个类的对象 3、在运行时判断任意一个对象所属的类 4、在运行时调用任意一个对象的方法 在java的jdk中...
java反射机制的原理及在Android下的简单应用
java中的reflect机制解析XML
java 反射实战demo，Java的反射（reflection）机制是指在程序的运行...我理解的Java反射的原理就是获取Class对象然后使用java.lang.reflect里提供的方法操作Class对象，Class与java.lang.reflect构成了java的反射技术。
反射机制package com.langsin.reflection; import java.lang.reflect.Method; public class DumpMethods { public static void main(String args[]) throws Exception { // 加载并初始化命令行参数指定的类 ...
Java使用反射机制使用get set 方法 import java.beans.PropertyDescriptor; import java.lang.reflect.Field; import java.lang.reflect.Method; /** * */ /** * @ClassName: ReflectTest * @Description: ...
反射机制用Java描述下载资料 import java.lang.reflect.Array; public class ArrayTest { public static void main(String[] args){ try{ //创建一个元素类型为String，长度为10的数组 Object arr=Array....
Reflect学习java反射机制