• java 反射机制


     

        《南陵别儿童入京》

    白酒新熟山中归,黄鸡啄黍秋正肥。

    呼童烹鸡酌白酒,儿女嬉笑牵人衣。

    高歌取醉欲自慰,起舞落日争光辉。

    游说万乘苦不早,著鞭跨马涉远道。

    会稽愚妇轻买臣,余亦辞家西入秦。

    仰天大笑出门去,我辈岂是蓬蒿人

        哈哈哈,我胡汉三又回来了,好久没写博客了,在接下来的日子里面每周保二进三,别的话不多说了,开整---

     

    java反射机制简单的来说就是通过对象找类,(我们通常都是知道类然后实例化对象)

      1 /**
      2  * 
      3  */
      4 package kdemod;
      5 
      6 /**
      7  * @author Administrator
      8  *
      9  */
     10 public class Student {
     11 
     12     
     13     private String name;
     14     private Integer age;
     15     
     16     //为了掩饰别的项目,先把这个注释掉
     17     
     18     /*public Student(String name){
     19         super();
     20         this.name = name;
     21     }
     22     
     23     //改写默认有参构造方法
     24     public Student(String name,Integer age){
     25         super();
     26         this.name = name;
     27         this.age = age;
     28     }*/
     29     
     30     //======================getter和setter方法===========================================
     31     public String getName() {
     32         return name;
     33     }
     34     public void setName(String name) {
     35         this.name = name;
     36     }
     37     public Integer getAge() {
     38         return age;
     39     }
     40     public void setAge(Integer age) {
     41         this.age = age;
     42     }
     43     
     44     public void Say(){
     45         System.out.println("我的姓名:"+name);
     46     }
     47     
     48     @Override
     49     public String toString() {
     50         // TODO Auto-generated method stub
     51         return "Student [name="+ name + "age"+age+"]";
     52     }
     53 }
     54 
     55 
     56 
     57 
     58 
     59 /**
     60  * 
     61  */
     62 package kdemod;
     63 
     64 /**
     65  * @author Administrator
     66  *
     67  */
     68 public class test {
     69 
     70     /**
     71      * @param args
     72      * 
     73      * 通过class类来获取对象的完整包名和类名
     74      */
     75     public static void main(String[] args) {
     76         // TODO Auto-generated method stub
     77         //Student student = new Student();
     78         //这里对象.getClass() 调用的是Object类的getClass() 
     79         //得到Class对象 然后再调用Class里的getName()方法,获取到完整包路径类
     80         //System.out.println(student.getClass().getName());
     81     }
     82 
     83 }
     84 
     85 
     86 
     87 
     88 
     89 /**
     90  * 
     91  */
     92 package kdemod;
     93 
     94 /**
     95  * @author Administrator
     96  *
     97  */
     98 public class test01 {
     99 
    100     /**
    101      * @param args
    102      */
    103     public static void main(String[] args) {
    104         // TODO Auto-generated method stub
    105 
    106         try {
    107             //通过得到Class对象,我们可以通过Class对象得到Kdemod.Student类的完整结构;
    108             Class<?> c =Class.forName("kdemod.Student");//有没有很熟悉的感觉,JDBC连接数据库的时候获取驱动名====报名+类名
    109             System.out.println(c.getName());
    110         } catch (ClassNotFoundException e) {
    111             // TODO Auto-generated catch block
    112             e.printStackTrace();
    113         }
    114     }
    115 
    116 }
    117 
    118 
    119 
    120 /**
    121  * 
    122  */
    123 package kdemod;
    124 
    125 import java.lang.reflect.Constructor;
    126 
    127 /**
    128  * @author Administrator
    129  *
    130  */
    131 public class test02 {
    132 
    133     /**
    134      * @param args
    135      */
    136     public static void main(String[] args) {
    137         // TODO Auto-generated method stub
    138         Class<?> c = null ;
    139         try {
    140             c=Class.forName("kdemod.Student");
    141             System.out.println(c.getName());
    142         } catch (ClassNotFoundException e) {
    143             // TODO Auto-generated catch block
    144             e.printStackTrace();
    145         }
    146         //获取构造器
    147         Constructor<?> cons[] = c.getConstructors() ;
    148         for (Constructor<?> con : cons) {
    149             System.out.println("构造方法"+ con );
    150             //会输出两个构造方法
    151         }
    152         
    153     }
    154 
    155 }
    156 
    157 
    158 
    159 /**
    160  * 
    161  */
    162 package kdemod;
    163 
    164 import java.lang.reflect.Constructor;
    165 import java.lang.reflect.InvocationTargetException;
    166 
    167 /**
    168  * @author Administrator
    169  *    山豆几
    170  */
    171 public class test03 {
    172 
    173     /**
    174      * @param args
    175      */
    176     public static void main(String[] args) {
    177         // TODO Auto-generated method stub
    178         
    179         Class<?> c = null ;
    180         
    181         try {
    182             c = Class.forName("kdemod.Student");
    183             System.out.println(c.getName());
    184         } catch (ClassNotFoundException e) {
    185             // TODO Auto-generated catch block
    186             e.printStackTrace();
    187         }
    188         Student s = null ;
    189         Constructor<?> [] cons = c.getConstructors() ;
    190         
    191         try {
    192             s = (Student) cons[0].newInstance("山豆几",19);
    193             //s = (Student) c.newInstance() ;
    194         } catch (InstantiationException | IllegalAccessException
    195                 | IllegalArgumentException | InvocationTargetException e) {
    196             // TODO Auto-generated catch block
    197             e.printStackTrace();
    198         }
    199         
    200         //因为在bean里面添加了有参的构造方法,所以在运行这个就会报错,解决办法就是通过反射获取这个类的构造方法,看34行写法
    201         //s.setName("山豆几");
    202         //s.setAge(19);
    203         System.out.println(s);
    204     }
    205 
    206 }
    207 
    208 
    209 
    210 /**
    211  * 
    212  */
    213 package kdemod;
    214 
    215 import java.lang.reflect.Method;
    216 
    217 /**
    218  * @author Administrator
    219  *通过getMethods() 方法获取所有的方法;
    220  */
    221 public class test04 {
    222 
    223     /**
    224      * @param args
    225      * 这是一个测试
    226      */
    227     public static void main(String[] args) {
    228         // TODO Auto-generated method stub
    229         Class<?> c = null;
    230         try {
    231             c = Class.forName("kdemod.Student");
    232             System.out.println(c.getName());
    233         } catch (ClassNotFoundException e) {
    234             // TODO Auto-generated catch block
    235             e.printStackTrace();
    236         }
    237         Method mds[] = c.getMethods() ;
    238         for (Method m : mds) {
    239             System.out.println(m);
    240         }
    241         
    242     }
    243 
    244 }
    245 
    246 
    247 
    248 /**
    249  * 
    250  */
    251 package kdemod;
    252 
    253 import java.lang.reflect.Field;
    254 
    255 /**
    256  * @author Administrator
    257  *
    258  */
    259 public class test05 {
    260 
    261     /**
    262      * @param args
    263      */
    264     public static void main(String[] args) {
    265         // TODO Auto-generated method stub
    266 
    267         Class<?> c = null;
    268         try {
    269             c = Class.forName("kdemod.Student");
    270             System.out.println(c.getName());
    271         } catch (ClassNotFoundException e) {
    272             // TODO Auto-generated catch block
    273             e.printStackTrace();
    274         }
    275         Field fs[] = c.getDeclaredFields() ;
    276         for (Field f : fs) {
    277             System.out.println(f);
    278             //通过getDeclaredFields()方法获取所有属性
    279         }
    280         
    281         
    282         
    283     }
    284 
    285 }
    286 
    287 
    288 
    289 /**
    290  * 
    291  */
    292 package kdemod;
    293 
    294 import java.lang.reflect.Method;
    295 
    296 /**
    297  * @author Administrator
    298  *
    299  */
    300 public class test06 {
    301 
    302     /**
    303      * @param args
    304      * @throws SecurityException 
    305      * @throws NoSuchMethodException 
    306      */
    307     public static void main(String[] args)  {
    308         // TODO Auto-generated method stub
    309 
    310         Class<?> c = null;
    311         try {
    312             c = Class.forName("kdemod.Student");
    313             System.out.println(c.getName());
    314         } catch (ClassNotFoundException e) {
    315             // TODO Auto-generated catch block
    316             e.printStackTrace();
    317         }
    318         
    319     
    320             try {
    321                 Object obj = c.newInstance() ;
    322                 Method m2 = obj.getClass().getMethod("setName", String.class);
    323                 m2.invoke(obj, "山豆几");
    324                 Method m =obj.getClass().getMethod("getName");
    325                 String name = (String) m.invoke(obj);
    326                 System.out.println(name + "name");
    327             } catch (Exception e) {
    328                 // TODO Auto-generated catch block
    329                 e.printStackTrace();
    330             }
    331     }
    332 
    333 }
    334 
    335 
    336 
    337 /**
    338  * 
    339  */
    340 package kdemod;
    341 
    342 import java.lang.reflect.Field;
    343 
    344 /**
    345  * @author Administrator
    346  *
    347  */
    348 public class test07 {
    349 
    350     /**
    351      * @param args
    352      */
    353     public static void main(String[] args) {
    354         // TODO Auto-generated method stub
    355 
    356         
    357         Class<?> c = null;
    358         try {
    359             c = Class.forName("kdemod.Student");
    360             System.out.println(c.getName());
    361         } catch (ClassNotFoundException e) {
    362             // TODO Auto-generated catch block
    363             e.printStackTrace();
    364         }
    365         
    366         try {
    367             Object obj = c.newInstance() ;
    368             Field nameField = c.getDeclaredField("name") ;
    369             nameField.setAccessible(true);
    370             nameField.set(obj, "山豆几");
    371             System.out.println("name="+nameField.get(obj));
    372         } catch(Exception e){
    373             // TODO Auto-generated catch block
    374             e.printStackTrace();
    375         }
    376     }
    377 
    378 }
    379 
    380 
    381 
    382 
    383 
    384 /**
    385  * 
    386  */
    387 package kdemod;
    388 
    389 /**
    390  * @author Administrator
    391  *
    392  */
    393 public class A {
    394 
    395 }
    396 
    397 
    398 
    399 package kdemod;
    400 
    401 public interface B {
    402 
    403 }
    404 
    405 
    406 package kdemod;
    407 
    408 public interface C {
    409 
    410 }
    411 
    412 
    413 /**
    414  * 
    415  */
    416 package kdemod;
    417 
    418 /**
    419  * @author Administrator
    420  *
    421  */
    422 public class Person extends A implements B,C {
    423 
    424 }
    425 
    426 
    427 
    428 
    429 /**
    430  * 
    431  */
    432 package kdemod;
    433 
    434 /**
    435  * @author Administrator
    436  *
    437  */
    438 public class test08 {
    439 
    440     /**
    441      * @param args
    442      */
    443     public static void main(String[] args) {
    444         // TODO Auto-generated method stub
    445 
    446         Class<?> c = null;
    447         try {
    448             c = Class.forName("kdemod.Person");
    449             System.out.println(c.getName());
    450         } catch (ClassNotFoundException e) {
    451             // TODO Auto-generated catch block
    452             e.printStackTrace();
    453         }
    454         Class<?> s = c.getSuperclass() ;
    455         System.out.println(s);
    456         //获取父类测试
    457         
    458     }
    459 
    460 }
    461 
    462 
    463 
    464 /**
    465  * 
    466  */
    467 package kdemod;
    468 
    469 /**
    470  * @author Administrator
    471  *
    472  */
    473 public class test09 {
    474 
    475     /**
    476      * @param args
    477      */
    478     public static void main(String[] args) {
    479         // TODO Auto-generated method stub
    480         
    481         Class<?> c = null;
    482         try {
    483             c = Class.forName("kdemod.Person");
    484             System.out.println(c.getName());
    485         } catch (ClassNotFoundException e) {
    486             // TODO Auto-generated catch block
    487             e.printStackTrace();
    488         }
    489         Class<?> []ifs = c.getInterfaces();
    490         for (Class<?> i : ifs) {
    491             System.out.println(i);
    492             //获取接口测试类
    493         }
    494     }
    495 
    496 }

    以上代码均测试通过。

     

  • 相关阅读:
    品味性能之道<六>:图形化SQL分析工具
    品味性能之道<五>:SQL分析工具
    品味性能之道<四>:管理重于技术
    品味性能之道<三>:方法论
    品味性能之道<二>:性能工程师可以具备的专业素养
    品味性能之道<一>:性能测试思维与误区
    网络协议学习笔记
    Java内存泄露监控工具:JVM监控工具介绍
    Loadrunner脚本回放无法准确定位欲删除元素
    C++ 虚函数
  • 原文地址:https://www.cnblogs.com/shandouji1121/p/8529591.html
Copyright © 2020-2023  润新知