程序博客网 > 小米机械键盘 知乎

反射——Java高级开发必须懂的

来源：互联网 发布：小米机械键盘 知乎 编辑：程序博客网 时间：2024/06/07 02:23
简介：反射是Java开发中一个非常重要的概念，掌握了反射的知识，才能更好的学习Java高级课程，因此必须要学习——你懂的！本门课程主要介绍Class类的使用，方法和成员变量的反射，以及通过反射了解集合泛型的本质等知识。
1.Class类
  1)在面向对象的世界里，万事万物皆对象。（java语言中，静态的成员、普通数据类型除外)
   类是不是对象呢?类是(哪个类的对象呢?)谁的对象呢?
   类是对象，类是java.lang.Class类的实例对象
  2)这个对象到底如何表示
  3)Class.forName("类的全称")
       不仅表示了，类的类类型，还代表了动态加载类
       请大家区分编译、运行
       编译时刻加载类是静态加载类、运行时刻加载类是动态加载类
  4)基本的数据类型
      void关键字  都存在类类型 
  5)Class类的基本API操作
  
2.方法的反射
1)如何获取某个方法
    方法的名称和方法的参数列表才能唯一决定某个方法
2)方法反射的操作
   method.invoke(对象，参数列表)
3)为什么要用方法的反射
    why?指定方法名称调用方法
    举个实际应用的案例  ---->通过标准JavaBean的属性名获取其属性值
    BeanUtil类
4)通过Class,Method来认识泛型的本质  

第1章Class类的使用

  1. package com.imooc.reflect;
  3. public class ClassDemo1 {
  4. public static void main(String[] args) {
  5. //Foo的实例对象如何表示
  6. Foo foo1 = new Foo();//foo1就表示出来了.
  7. //Foo这个类 也是一个实例对象，Class类的实例对象,如何表示呢
  8. //任何一个类都是Class的实例对象，这个实例对象有三种表示方式
  10. //第一种表示方式--->实际在告诉我们任何一个类都有一个隐含的静态成员变量class
  11. Class c1 = Foo.class;
  13. //第二中表达方式  已经知道该类的对象通过getClass方法
  14. Class c2 = foo1.getClass();
  16. /*官网 c1 ,c2 表示了Foo类的类类型(class type)
  17.  * 万事万物皆对象，
  18.  * 类也是对象，是Class类的实例对象
  19.  * 这个对象我们称为该类的类类型
  20.  * 
  21.  */
  23. //不管c1  or c2都代表了Foo类的类类型，一个类只可能是Class类的一个实例对象
  24. System.out.println(c1 == c2);
  26. //第三种表达方式
  27. Class c3 = null;
  28. try {
  29. c3 = Class.forName("com.imooc.reflect.Foo");
  30. } catch (ClassNotFoundException e) {
  31. // TODO Auto-generated catch block
  32. e.printStackTrace();
  33. }
  34. System.out.println(c2==c3);
  36. //我们完全可以通过类的类类型创建该类的对象实例---->通过c1 or c2 or c3创建Foo的实例对象
  37. try {
  38. Foo foo = (Foo)c1.newInstance();//需要有无参数的构造方法
  39. foo.print();
  40. } catch (InstantiationException e) {
  41. // TODO Auto-generated catch block
  42. e.printStackTrace();
  43. } catch (IllegalAccessException e) {
  44. // TODO Auto-generated catch block
  45. e.printStackTrace();
  46. }
  49. }
  50. }
  51. class Foo{
  53. void print(){
  54. System.out.println("foo");
  55. }
  56. }

第2章动态加载类

工具类，一般需要设计成动态加载类
  1. /**
  2.  * 这是静态加载类，必须Word和Excel都存在才能加载成功
  3.  * @author Shmilxu
  4.  *
  5.  */
  6. public class Office {
  8. public static void main(String[] args) {
  9. // TODO Auto-generated method stub
  10. // new创建对象 是静态加载类，在编译时刻就需要加载所有的可能使用到的类。
  11. // 通过动态加载类可以解决该问题
  12. if("Word".equals(args[0])){
  13. Word w = new Word();
  14. w.start();
  15. }
  16. if ("Excel".equals(args[0])) {
  17. Excel e = new Excel();
  18. e.start();
  19. }
  20. }
  22. }
  1. public class Word implements OfficeAble{
  3. public void start() {
  4. System.out.println("word...starts...");
  5. }
  6. }
  1. public class Excel {
  3. public void start() {
  4. System.out.println("Excel...starts...");
  5. }
  6. }
  1. /**
  2.  * Word和Excel都需要遵循的接口规范
  3.  * 只需要遵循这种接口，去实现里面的方法，Word、Excel，有一个可以运行，有两个可以运行，
  4.  * 甚至一个新的ppt来了一个也可以运行
  5.  * @author Administrator
  6.  *
  7.  */
  8. public interface OfficeAble {
  10. public void start();
  11. }
  1. /**
  2.  * 动态加载类，在运行时加载，它并不管你加载的类存在不存在，都不会报加载错误。
  3.  * @author Administrator
  4.  *
  5.  */
  6. public class OfficeBetter {
  8. public static void main(String[] args) {
  9. // TODO Auto-generated method stub
  11. try {
  12. // 动态加载类，在运行时刻加载 
  13. Class c = Class.forName(args[0]);
  14. // 通过类类型，创建该类对象
  15. OfficeAble oa = (OfficeAble)c.newInstance();;
  16. oa.start();
  17. } catch (ClassNotFoundException e) {
  18. // TODO Auto-generated catch block
  19. e.printStackTrace();
  20. }
  21. }
  23. }

第3章获取方法信息

  1. Class c1 = int.class;//int 的类类型
  2. Class c2 = String.class;//String类的类类型   String类字节码（自己发明的)
  3. Class c3 = double.class;
  4. Class c4 = Double.class;
  5. Class c5 = void.class;
  7. System.out.println(c1.getName());
  8. System.out.println(c2.getName());
  9. System.out.println(c2.getSimpleName());//不包含包名的类的名称
  10. System.out.println(c5.getName());
  1. public class ClassUtil {
  2. /**
  3.  * 打印类的信息，包括类的成员函数、成员变量(只获取成员函数)
  4.  * @param obj 该对象所属类的信息
  5.  */
  6. public static void printClassMethodMessage(Object obj){
  7. //要获取类的信息  首先要获取类的类类型
  8. Class c = obj.getClass();//传递的是哪个子类的对象  c就是该子类的类类型
  9. //获取类的名称
  10. System.out.println("类的名称是:"+c.getName());
  11. /*
  12.  * Method类，方法对象
  13.  * 一个成员方法就是一个Method对象
  14.  * getMethods()方法获取的是所有的public的函数，包括父类继承而来的
  15.  * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
  16.  */
  17. Method[] ms = c.getMethods();//c.getDeclaredMethods()
  18. for(int i = 0; i < ms.length;i++){
  19. //得到方法的返回值类型的类类型
  20. Class returnType = ms[i].getReturnType();
  21. System.out.print(returnType.getName()+" ");
  22. //得到方法的名称
  23. System.out.print(ms[i].getName()+"(");
  24. //获取参数类型--->得到的是参数列表的类型的类类型
  25. Class[] paramTypes = ms[i].getParameterTypes();
  26. for (Class class1 : paramTypes) {
  27. System.out.print(class1.getName()+",");
  28. }
  29. System.out.println(")");
  30. }
  31. }
  32.     /**
  33.      * 获取成员变量的信息
  34.      * @param obj
  35.      */
  36. public static void printFieldMessage(Object obj) {
  37. Class c = obj.getClass();
  38. /*
  39.  * 成员变量也是对象
  40.  * java.lang.reflect.Field
  41.  * Field类封装了关于成员变量的操作
  42.  * getFields()方法获取的是所有的public的成员变量的信息
  43.  * getDeclaredFields获取的是该类自己声明的成员变量的信息
  44.  */
  45. //Field[] fs = c.getFields();
  46. Field[] fs = c.getDeclaredFields();
  47. for (Field field : fs) {
  48. //得到成员变量的类型的类类型
  49. Class fieldType = field.getType();
  50. String typeName = fieldType.getName();
  51. //得到成员变量的名称
  52. String fieldName = field.getName();
  53. System.out.println(typeName+" "+fieldName);
  54. }
  55. }
  56. /**
  57.  * 打印对象的构造函数的信息
  58.  * @param obj
  59.  */
  60. public static void printConMessage(Object obj){
  61. Class c = obj.getClass();
  62. /*
  63.  * 构造函数也是对象
  64.  * java.lang. Constructor中封装了构造函数的信息
  65.  * getConstructors获取所有的public的构造函数
  66.  * getDeclaredConstructors得到所有的构造函数
  67.  */
  68. //Constructor[] cs = c.getConstructors();
  69. Constructor[] cs = c.getDeclaredConstructors();
  70. for (Constructor constructor : cs) {
  71. System.out.print(constructor.getName()+"(");
  72. //获取构造函数的参数列表--->得到的是参数列表的类类型
  73. Class[] paramTypes = constructor.getParameterTypes();
  74. for (Class class1 : paramTypes) {
  75. System.out.print(class1.getName()+",");
  76. }
  77. System.out.println(")");
  78. }
  79. }
  80. }

第4章获取成员变量构造函数信息

  1. /**
  2.      * 获取成员变量的信息
  3.      * @param obj
  4.      */
  5. public static void printFieldMessage(Object obj) {
  6. Class c = obj.getClass();
  7. /*
  8.  * 成员变量也是对象
  9.  * java.lang.reflect.Field
  10.  * Field类封装了关于成员变量的操作
  11.  * getFields()方法获取的是所有的public的成员变量的信息
  12.  * getDeclaredFields获取的是该类自己声明的成员变量的信息
  13.  */
  14. //Field[] fs = c.getFields();
  15. Field[] fs = c.getDeclaredFields();
  16. for (Field field : fs) {
  17. //得到成员变量的类型的类类型
  18. Class fieldType = field.getType();
  19. String typeName = fieldType.getName();
  20. //得到成员变量的名称
  21. String fieldName = field.getName();
  22. System.out.println(typeName+" "+fieldName);
  23. }
  24. }
  25. /**
  26.  * 打印对象的构造函数的信息
  27.  * @param obj
  28.  */
  29. public static void printConMessage(Object obj){
  30. Class c = obj.getClass();
  31. /*
  32.  * 构造函数也是对象
  33.  * java.lang. Constructor中封装了构造函数的信息
  34.  * getConstructors获取所有的public的构造函数
  35.  * getDeclaredConstructors得到所有的构造函数
  36.  */
  37. //Constructor[] cs = c.getConstructors();
  38. Constructor[] cs = c.getDeclaredConstructors();
  39. for (Constructor constructor : cs) {
  40. System.out.print(constructor.getName()+"(");
  41. //获取构造函数的参数列表--->得到的是参数列表的类类型
  42. Class[] paramTypes = constructor.getParameterTypes();
  43. for (Class class1 : paramTypes) {
  44. System.out.print(class1.getName()+",");
  45. }
  46. System.out.println(")");
  47. }

第5章方法反射的基本操作

demo1
  1. package com.imooc.reflect;
  3. import java.lang.reflect.Method;
  5. public class MethodDemo1 {
  6. public static void main(String[] args) {
  7.    //要获取print(int ,int )方法  1.要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类类型
  8. A a1 = new A();
  9. Class c = a1.getClass();
  10. /*
  11.  * 2.获取方法 名称和参数列表来决定  
  12.  * getMethod获取的是public的方法
  13.  * getDelcaredMethod自己声明的方法
  14.  */
  15.     try {
  16. //Method m =  c.getMethod("print", new Class[]{int.class,int.class});
  17.     Method m = c.getMethod("print", int.class,int.class);
  18.     
  19.     //方法的反射操作  
  20.     //a1.print(10, 20);方法的反射操作是用m对象来进行方法调用 和a1.print调用的效果完全相同
  21.         //方法如果没有返回值返回null,有返回值返回具体的返回值
  22.     //Object o = m.invoke(a1,new Object[]{10,20});
  23.     Object o = m.invoke(a1, 10,20);
  24.     System.out.println("==================");
  25.     //获取方法print(String,String)
  26.              Method m1 = c.getMethod("print",String.class,String.class);
  27.              //用方法进行反射操作
  28.              //a1.print("hello", "WORLD");
  29.              o = m1.invoke(a1, "hello","WORLD");
  30.              System.out.println("===================");
  31.            //  Method m2 = c.getMethod("print", new Class[]{});
  32.                 Method m2 = c.getMethod("print");
  33.                // m2.invoke(a1, new Object[]{});
  34.                 m2.invoke(a1);
  35. } catch (Exception e) {
  36. // TODO Auto-generated catch block
  37. e.printStackTrace();
  38. } 
  39.      
  40. }
  41. }
  42. class A{
  43. public void print(){
  44. System.out.println("helloworld");
  45. }
  46. public void print(int a,int b){
  47. System.out.println(a+b);
  48. }
  49. public void print(String a,String b){
  50. System.out.println(a.toUpperCase()+","+b.toLowerCase());
  51. }
  52. }
demo2
  1. package com.imooc.reflect;
  3. public class UserService {
  4. public void delete(){
  5. System.out.println("删除用户");
  6. }
  7. public void update(){
  8. System.out.println("修改用户");
  9. }
  10. public void find(){
  11. System.out.println("查找用户");
  12. }
  13. }
  1. package com.imooc.reflect;
  3. import java.io.BufferedReader;
  4. import java.io.InputStreamReader;
  5. import java.lang.reflect.Method;
  7. public class MethodDemo2 {
  8. public static void main(String[] args) {
  9. UserService us = new UserService();
  10. /*
  11.  * 通过键盘输入命令执行操作
  12.  * 输入update命令就调用update方法
  13.  * 输入delete命令就调用delete方法
  14.  * ...
  15.  */
  16. try {
  17. BufferedReader br = new BufferedReader(
  18. new InputStreamReader(System.in));
  19. System.out.println("请输入命令:");
  20. String action = br.readLine();
  21. /*if("update".equals(action)){
  22. us.update();
  23. }
  24. if("delete".equals(action)){
  25. us.delete();
  26. }
  27. if("find".equals(action)){
  28. us.find();
  29. }*/
  30. /*
  31.  * action就是方法名称， 都没有参数--->通过方法的反射操作就会简单很多
  32.  * 通过方法对象然后进行反射操作
  33.  */
  34. Class c = us.getClass();
  35. Method m = c.getMethod(action);
  36. m.invoke(us);
  37. } catch (Exception e) {
  38. e.printStackTrace();
  39. }
  40. }
  42. }
demo3
  1. package com.imooc.reflect;
  2. //标准的JavaBean类有私有属性都对应有get/set方法，有无参数的构造方法
  3. public class User {
  4. private String username;
  5. private String userpass;
  6. private int age;
  7. public User(){}
  9. public User(String username, String userpass, int age) {
  10. super();
  11. this.username = username;
  12. this.userpass = userpass;
  13. this.age = age;
  14. }
  16. public String getUsername() {
  17. return username;
  18. }
  19. public void setUsername(String username) {
  20. this.username = username;
  21. }
  22. public String getUserpass() {
  23. return userpass;
  24. }
  25. public void setUserpass(String userpass) {
  26. this.userpass = userpass;
  27. }
  28. public int getAge() {
  29. return age;
  30. }
  31. public void setAge(int age) {
  32. this.age = age;
  33. }
  36. }
  1. package com.imooc.reflect;
  3. import java.lang.reflect.Method;
  5. public class BeanUtil {
  6. /**
  7.  * 根据标准javaBean对象的属性名获取其属性值
  8.  * 
  9.  * @param obj
  10.  * @param propertyName
  11.  * @return
  12.  */
  13. public static Object getValueByPropertyName(Object obj, String propertyName) {
  14. // 1.根据属性名称就可以获取其get方法
  15. String getMethodName = "get"
  16. + propertyName.substring(0, 1).toUpperCase()
  17. + propertyName.substring(1);
  18. //2.获取方法对象
  19. Class c = obj.getClass();
  20. try {
  21. //get方法都是public的且无参数
  22. Method m= c.getMethod(getMethodName);
  23. //3 通过方法的反射操作方法
  24. Object value = m.invoke(obj);
  25. return value;
  26. } catch (Exception e) {
  27. e.printStackTrace();
  28. return null;
  29. }
  30. }
  31. }
  1. package com.imooc.reflect;
  3. public class MethodDemo3 {
  5. /**
  6.  * @param args
  7.  */
  8. public static void main(String[] args) {
  9. // TODO Auto-generated method stub
  10. User u1 = new User("zhangsan", "123456", 30);
  11. System.out.println(BeanUtil.getValueByPropertyName(u1, "username"));
  12.        System.out.println(BeanUtil.getValueByPropertyName(u1, "userpass"));
  13. }
  14.   
  15. }

第6章通过反射了解集合泛型的本质

  1. package com.imooc.reflect;
  3. import java.lang.reflect.Method;
  4. import java.util.ArrayList;
  6. public class MethodDemo4 {
  7. public static void main(String[] args) {
  8. ArrayList list = new ArrayList();
  10. ArrayList<String> list1 = new ArrayList<String>();
  11. list1.add("hello");
  12. //list1.add(20);错误的
  13. Class c1 = list.getClass();
  14. Class c2 = list1.getClass();
  15. System.out.println(c1 == c2);
  16. //反射的操作都是编译之后的操作
  18. /*
  19.  * c1==c2结果返回true说明编译之后集合的泛型是去泛型化的
  20.  * Java中集合的泛型，是防止错误输入的，只在编译阶段有效，
  21.  * 绕过编译就无效了
  22.  * 验证：我们可以通过方法的反射来操作，绕过编译
  23.  */
  24. try {
  25. Method m = c2.getMethod("add", Object.class);
  26. m.invoke(list1, 20);//绕过编译操作就绕过了泛型
  27. System.out.println(list1.size());
  28. System.out.println(list1);
  29. /*for (String string : list1) {
  30. System.out.println(string);
  31. }*///现在不能这样遍历
  32. } catch (Exception e) {
  33.   e.printStackTrace();
  34. }
  35. }
  37. }


0 0
小米机械键盘 知乎 小米机械键盘 知乎
原创粉丝点击
热门IT博客
nba体测数据最好的nba体测数据最好的
js 时间字符串转datejs 时间字符串转date
js让span隐藏
淘宝机油真假
遥控器怎样调网络电视
广州网络公关
夏普z380和w380知乎
2017年淘宝销售额多少
c语言2的n次方
聚划算和淘宝关系
nginx反向代理配置视频
smb协议如何传输数据
土地资源管理论文数据
复杂网络中的超网
淘宝女装海报
2016淘宝seo教程
linux怎么c语言编程
mac西柚色和珊瑚色区别
sqlite linux 安装
php beast使用报错
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 亚都空气净化器kjf2901 亚都加湿器怎么样 亚都空气净化器kjf2801n 亚都空气净化器价格 亚都超声波加湿器 亚都空气净化器代理商 亚都空气净化器kjg1201s 亚都售后电话 亚都2801n空气净化器 亚都空气净化器哪款好 亚都空气净化器使用说明书 亚都加湿器多少钱 亚都加湿器哪款好 亚都加湿器修理 亚都加湿器厂家 亚都空气净化器怎么用 亚都订单物流管理系统 亚都szk-j136 亚都建设集团有限公司 亚都加湿器专卖店 亚都净化型加湿器 亚都加湿器网站 亚都加湿器m023 亚都加湿器售后服务 亚都加湿器售后电话 亚都加湿器售后 亚都加湿器维修点 亚都加湿器使用方法 亚都纯水机价格 亚都加湿器说明书 海尔车载空气净化器 医用空气消毒机 空气幕 紫外线空气消毒机 空气滤 无耗材空气净化器 室内空气净化器有用吗 夏普空气净化器 空气净化器多少钱 yadu 亚鑫

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里