反射机制总结
2016-04-10 12:05
281 查看
类的使用
动态加载
获取方法的信息
获取成员变量
获取构造函数的信息
方法的反射
通过反射了解集合泛型的本质
PS:
基本数据类型(包装类弥补面向对象)和静态的不是面向对象的
java.lang.Class的实例对象=Class类
Class类的构造器是私有的 所有new不出来 只能Class自己使用(Constructor. Only the Java Virtual Machine creates Class objects.)
得到Class类型3种方式 1.Class a= A.class 2.Class a = a.getClass() 3.Class c = null; c = Class.forName(“com.A”);
编译时加载类是静态加载 new Class()运行时加载时动态加载Class.forName();
main(String[] args) args[0]就是cmd命令行输入的第一个参数
在线升级或者添加新功能 执行类是不用编译的 执行类的编译代码不用修改用动态加载规则类 用新功能实现规则 编译功能类 直接运行执行类不用编译即可
修改以前的代码 意味着重新编译(javac) 但是动态加载规则接口值编译添加的新功能类(实现规则) 执行类直接编译就可 不用重新加载(因为没有修改代码)
java源码里面有的声明里有native关键字意思是本地方法(用java声明,底层是用c实现的)
反射的操作都是运行时操作 是之后的操作(。class是字节码是编译后生成的)
泛型相当于前台的客户端简单验证,是对错误输入的一中检查(同一容器一般都只存一中类型,所以foreacht,因为foreache都是对同一种类容器的遍历),运行时的容器是没有泛型效果的(通过反射可以操作不是声明时的泛型类型),所以同一声明类型不同泛型的两种引用类型的类型是相同的(ArrayList a1== ArrayLista2)
学习网址:
http://www.imooc.com/learn/199
/article/4657750.html
万事万物皆为对象,类也是对象,任何一个类都是Class类的对象。 Class c1就声明了一个Class类的实例对象,但是不能通过new关键字来创建,而是有一下三种方法创建。 1、Class c1 = Foo.class;//任何一个类都有一个隐含的静态成员变量class,如果Foo已经存在,可以用这种方法来创建Foo的类类型(class type),即Foo类的类类型就是Class类的一个实例对象。 2、Class c2 = foo.getClass();//如果Foo类的对象foo已经存在,可以通过这种方法来创建Foo类的类类型。 并且,c1==c2是true的,因为任何一个类只有一个类类型。 3、Class c3 = null; c3 = Class.forName("com.imooc.reflect.Foo");//通过Foo的全称来创建 可知,c2==c3也是true的。 而且,可以用类类型来创建Foo的实例对象,如下 Foo foo1 = (Foo)c1.newInstance();//前提是Foo有无参的构造方法
动态加载
编译时加载的类:静态加载类(用new关键词创建的类) 运行时加载的类:动态加载类(用类类型创建的类)(不过需要有接口或者父类(抽象类)) //Class.forName("类的全名") Class c = Class.forName(args[0]); OfficeAble oa = (OfficeAble) (c.newInstance());//需要有无参构造器 //OfficeAble 是接口(interface)
获取方法的信息
@ClassUtil.java——(上) public class ClassUtil { /** * 打印类的信息,包括类的成员函数、成员变量(只获取成员函数) * @param obj 该对象所属类的信息 */ public static void printClassMethodMessage(Object obj){ //要获取类的信息 首先要获取类的类类型 Class c = obj.getClass();//传递的是哪个子类的对象 c就是该子类的类类型 //获取类的名称 System.out.println("类的名称是:"+c.getName()); /* * Method类,方法对象 * 一个成员方法就是一个Method对象 * getMethods()方法获取的是所有的public的函数,包括父类继承而来的 * getDeclaredMethods()获取的是所有该类自己声明的方法,不问访问权限(继承的就没有了) */ Method[] ms = c.getMethods();//c.getDeclaredMethods() for(int i = 0; i < ms.length;i++){ //得到方法的返回值类型的类类型 Class returnType = ms[i].getReturnType(); System.out.print(returnType.getName()+" "); //得到方法的名称 System.out.print(ms[i].getName()+"("); //获取参数类型--->得到的是参数列表的类型的类类型 Class[] paramTypes = ms[i].getParameterTypes(); for (Class class1 : paramTypes) { System.out.print(class1.getName()+","); } System.out.println(")"); } } ...
获取成员变量
@ClassUtil.java——(中) /** * 获取成员变量的信息 * @param obj */ public static void printFieldMessage(Object obj) { Class c = obj.getClass(); /* * 成员变量也是对象 * java.lang.reflect.Field * Field类封装了关于成员变量的操作 * getFields()方法获取的是所有的public的成员变量的信息 * getDeclaredFields获取的是该类自己声明的成员变量的信息 */ //Field[] fs = c.getFields(); Field[] fs = c.getDeclaredFields(); for (Field field : fs) { //得到成员变量的类型的类类型 Class fieldType = field.getType(); String typeName = fieldType.getName(); //得到成员变量的名称 String fieldName = field.getName(); System.out.println(typeName+" "+fieldName); } }
获取构造函数的信息
@ClassUtil.java——(下) /** * 打印对象的构造函数的信息 * @param obj */ public static void printConMessage(Object obj){ Class c = obj.getClass(); /* * 构造函数也是对象 * java.lang. Constructor中封装了构造函数的信息 * getConstructors获取所有的public的构造函数 * getDeclaredConstructors得到所有的构造函数 */ //Constructor[] cs = c.getConstructors(); Constructor[] cs = c.getDeclaredConstructors(); for (Constructor constructor : cs) { System.out.print(constructor.getName()+"("); //获取构造函数的参数列表--->得到的是参数列表的类类型 Class[] paramTypes = constructor.getParameterTypes(); for (Class class1 : paramTypes) { System.out.print(class1.getName()+","); } System.out.println(")"); } } }
方法的反射
@方法的反射——(上) public class MethodDemo1 { public static void main(String[] args) { //要获取print(int ,int )方法 1.要获取一个方法就是获取类的信息,获取类的信息首先要获取类的类类型 A a1 = new A(); Class c = a1.getClass(); /* * 2.获取方法 名称和参数列表来决定 * getMethod获取的是public的方法 * getDelcaredMethod自己声明的方法 */ try { ... } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } } class A{ public void print(){ System.out.println("helloworld"); } public void print(int a,int b){ System.out.println(a+b); } public void print(String a,String b){ System.out.println(a.toUpperCase()+","+b.toLowerCase()); } }
@方法的反射——(下) @try——catch...内容 //Method m = c.getMethod("print", new Class[]{int.class,int.class}); Method m = c.getMethod("print", int.class,int.class); //方法的反射操作 invoke //a1.print(10, 20);方法的反射操作是用m对象来进行方法调用 和a1.print调用的效果完全相同 //方法如果没有返回值返回null,有返回值返回具体的返回值 //Object o = m.invoke(a1,new Object[]{10,20}); Object o = m.invoke(a1, 10,20); System.out.println("=================="); //获取方法print(String,String) Method m1 = c.getMethod("print",String.class,String.class); //用方法进行反射操作 //a1.print("hello", "WORLD"); o = m1.invoke(a1, "hello","WORLD"); System.out.println("==================="); // Method m2 = c.getMethod("print", new Class[]{}); Method m2 = c.getMethod("print"); // m2.invoke(a1, new Object[]{}); m2.invoke(a1);
通过反射了解集合泛型的本质
ArrayList list = new ArrayList(); ArrayList<String> list1 = new ArrayList<String>(); list1.add("hello"); //list1.add(20);错误的 Class c1 = list.getClass(); Class c2 = list1.getClass(); System.out.println(c1 == c2); //反射的操作都是编译之后的操作 /* * c1==c2结果返回true说明编译之后集合的泛型是去泛型化的 * Java中集合的泛型,是防止错误输入的,只在编译阶段有效, * 绕过编译就无效了 * 验证:我们可以通过方法的反射来操作,绕过编译 */ try { Method m = c2.getMethod("add", Object.class); m.invoke(list1, 20);//绕过编译操作就绕过了泛型 System.out.println(list1.size()); System.out.println(list1); /*for (String string : list1) { System.out.println(string); }*///现在不能这样遍历 } catch (Exception e) { e.printStackTrace(); } Ps:总而言之:这三种情况就称为“类类型”,但是一般都称为“字节码文件对象”。
PS:
基本数据类型(包装类弥补面向对象)和静态的不是面向对象的
java.lang.Class的实例对象=Class类
Class类的构造器是私有的 所有new不出来 只能Class自己使用(Constructor. Only the Java Virtual Machine creates Class objects.)
得到Class类型3种方式 1.Class a= A.class 2.Class a = a.getClass() 3.Class c = null; c = Class.forName(“com.A”);
编译时加载类是静态加载 new Class()运行时加载时动态加载Class.forName();
main(String[] args) args[0]就是cmd命令行输入的第一个参数
在线升级或者添加新功能 执行类是不用编译的 执行类的编译代码不用修改用动态加载规则类 用新功能实现规则 编译功能类 直接运行执行类不用编译即可
修改以前的代码 意味着重新编译(javac) 但是动态加载规则接口值编译添加的新功能类(实现规则) 执行类直接编译就可 不用重新加载(因为没有修改代码)
java源码里面有的声明里有native关键字意思是本地方法(用java声明,底层是用c实现的)
反射的操作都是运行时操作 是之后的操作(。class是字节码是编译后生成的)
泛型相当于前台的客户端简单验证,是对错误输入的一中检查(同一容器一般都只存一中类型,所以foreacht,因为foreache都是对同一种类容器的遍历),运行时的容器是没有泛型效果的(通过反射可以操作不是声明时的泛型类型),所以同一声明类型不同泛型的两种引用类型的类型是相同的(ArrayList a1== ArrayLista2)
学习网址:
http://www.imooc.com/learn/199
/article/4657750.html
相关文章推荐
- Unity中Microphone类进行录音保存
- 《机电传动控制》第六周学习笔记
- C++隐式转换与显式转换
- 如何在Linux中发现IP地址冲突
- [BZOJ2705][SDOI2012]Longge的问题
- 我的博客是如何搭建的(github pages + HEXO + 域名绑定)
- 让Java程序运行sudo命令
- SLT的代码(当然不是我写的,今天不小心炸出来了,纪念一下)
- SAP的组织架构
- System.out和System.err的并发
- 深入理解 hash 函数、HashMap、LinkedHashMap、TreeMap
- LeetCode *** 38. Count and Say
- recycleView学习01
- KMP算法实现
- 2014年辛星Javascript解读第三节
- 在类中声明函数而不去定义编译通过
- 查找(一)史上最简单清晰的红黑树讲解
- qt实现多平台的二维码展示
- iOS开发数据库篇—FMDB简单介绍
- iOS开发数据库篇—FMDB数据库队列