反射机制详解下篇

简介:

java的反射机制一共分为上下两篇,上篇请参考:http://xinsz08.blog.51cto.com/10565212/1946912

下篇主要讲解:

      1.利用反射技术获取构造方法,并使用构造方法创建对象

      2.使用反射技术快速创建对象

      3.使用反射技术获取成员方法,并执行方法

      4.反射技术小结.


1.使用反射技术获取构造方法,并使用构造方法创建对象

  实现步骤:

   1.获取class文件对象 (Class.forName)

   2.使用class文件对象中的方法,解剖class文件获取构造方法Constructor

   3.使用构造方法Constructor中的方法newInstance执行构造方法创建对象


  使用反射能够获取的构造方法:(首先建立一个Person类,用于测试,见代码实例1)

* public Person()   无参构造方法

* public Person(String name, int age, String sex)  全参构造方法

* private Person(String name, int age)  私有构造方法



代码实例1-创建Person 类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
package  cn.xins08.boke;
 
public  class  Person {
     private  String name;
     private  int  age;
     public  String sex;
 
     static  {
         System.out.println( "静态代码块" );
     }
 
     // 3.无参的构造方法
     public  Person() {
         super ();
         System.out.println( "无参构造方法" );
     }
 
     public  Person(String name,  int  age, String sex) {
         super ();
         this .name = name;
         this .age = age;
         this .sex = sex;
         System.out.println( "满参数构造方法" );
     }
 
     private  Person(String name,  int  age) {
         super ();
         this .name = name;
         this .age = age;
         System.out.println( "私有的构造方法" );
     }
 
     // 4.toString方法
     @Override
     public  String toString() {
         return  "Person [name="  + name +  ", age="  + age +  ", sex="  + sex +  "]" ;
     }
 
     private  void  method() {
         System.out.println( "私有的method方法" );
     }
 
     // 2.公共的setter/getter方法
     public  String getName() {
         return  name;
     }
 
     public  void  setName(String name) {
         this .name = name;
     }
 
     public  int  getAge() {
         return  age;
     }
 
     public  void  setAge( int  age) {
         this .age = age;
     }
 
     public  String getSex() {
         return  sex;
     }
 
     public  void  setSex(String sex) {
         this .sex = sex;
     }
 
}

2.利用反射技术获取Person类的构造方法及创建对象:

代码实例2:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package  cn.xins08.boke;
 
import  java.lang.reflect.Constructor;
 
import  cn.xins08.boke.Person;
 
public  class  ReflectConstructor {
 
     public  static  void  main(String[] args)  throws  Exception {
         //1.获取class文件对象
         Class clazz = Class.forName( "cn.xins08.boke.Person" );
         // 2.使用class文件对象中的方法,获取class文件构造方法
         Constructor[] cons1 = clazz.getConstructors();
         // 获取多个需要用getConstructors,前面用Constructor[]数组来接收.
         // 获取一个用Constructor[] cons =clazz.getConstructor(); 只有一个就无需遍历
         for  (Constructor con : cons1) {
 
             System.out.println(con);
         }
         System.out.println( "-------------------------------" );
         Constructor[] cons2 = clazz.getDeclaredConstructors();
         for (Constructor con:cons2){
             System.out.println(con);
         }
         
        //3.使用构造方法Constructor中的方法newInstacnce执行构造方法创建对象
         Constructor con1 = clazz.getConstructor();
         Object obj1=con1.newInstance();
         System.out.println(obj1); //无参构造方法 Person [name=null, age=0, sex=null]
         Person p1=(Person) obj1;
         p1.setName( "xinsz08" );
         System.out.println(p1); //Person [name=xinsz08, age=0, sex=null]   
         
     }
 
}

运行结果:

静态代码块

public cn.xins08.boke.Person()

public cn.xins08.boke.Person(java.lang.String,int,java.lang.String)

-------------------------------

public cn.xins08.boke.Person()

public cn.xins08.boke.Person(java.lang.String,int,java.lang.String)

private cn.xins08.boke.Person(java.lang.String,int)  (私有方法)

无参构造方法

Person [name=null, age=0, sex=null]

Person [name=xinsz08, age=0, sex=null]  




3.使用反射技术快速创建对象(重点)


    使用反射技术快速创建对象的前提:

  1. Person类中必须有无参构造方法

  2. 构造方法的修饰符不能是私有,建议使用public,因为public的权重比较高.

  3. 只针对无参构造

    原理:使用class类中的方法 newInstance() ,创建此对象所表示的类的一个新实例.


代码实例3:


1
2
3
4
5
6
7
8
9
10
11
package  cn.xins08.boke;
 
public  class  Reflect_3 {
 
     public  static  void  main(String[] args)  throws  Exception {
         Class clazz = Class.forName( "cn.xins08.boke.Person" );
         Object obj = clazz.newInstance();
         System.out.println(obj);
     }
 
}


运行结果:

静态代码块
无参构造方法
Person [name=null, age=0, sex=null]


4.使用反射技术获取成员方法,并执行方法(重点):

   实现步骤:

    1.获取类的class文件对象

    2.使用class文件对象中的方法,获取Method

   method 有两个方法:

  1. Method[] getMethods()  返回公共的成员方法,包括继承自父类的,重写接口的方法

  2. Method[] getDeclaredMethods() 包括公共、保护、默认(包)访问和私有方法,但不包括继承的方法


    代码实例4:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package  cn.xins08.boke;
 
import  java.lang.reflect.Method;
 
public  class  ReflectMethod {
 
     public  static  void  main(String[] args)  throws  Exception {
         Class clazz = Class.forName( "cn.xins08.boke.Person" );
         // 使用class 文件对象中的方法获取method
         Method[] methods = clazz.getMethods();
         for  (Method method : methods) {
             System.out.println(method);
              // 能够返回公共,默认访问和私有方法,但是获取不到继承的方法
 
         }
         System.out.println( "======我是分割线==============" );
        
 
         Method[] methodsD = clazz.getDeclaredMethods();
         for  (Method method : methodsD) {
             System.out.println(method); //
 
         }
 
         Object obj = clazz.newInstance();
         Method getNameMethod = clazz.getMethod( "getName" );
         System.out.println(getNameMethod);
         /*
          * 无参构造方法 public java.lang.String cn.xins08.boke.Person.getName()
          */
         Object m1 = getNameMethod.invoke(obj);
         System.out.println(m1);
         
         Method setNameMethod = clazz.getMethod( "setName" , String. class );
         Object m2 =setNameMethod.invoke(obj,  "xinsz08" );
         System.out.println(m2);
         //此处的setName 没有返回值,因为返回类型为void.所以m2的值为null
         //我们再次获取name的值
         m1=getNameMethod.invoke(obj);
         System.out.println(m1);  //此时打印的就是xinsz08
     }
 
}


反射机制小结:


  1. 利用反射机制获取Class文件对象:

三种方式:

  1.   通过Object getClass()方法获取 Class对象

  2.  通过类名.class 方式 获取 Class对象

  3.  通过反射的方式, Class.forName(String classname) 获取Class对象

               


      2.通过反射, 获取类中的构造方法,并完成对象的创建.

               获取指定的构造方法

                public Constructor<T> getConstructor(Class<?>... parameterTypes)

                获取指定的public修饰的构造方法

                  public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)

                 获取指定的构造方法,包含私有的

                 获取所有的构造方法:

                 public Constructor<?>[] getConstructors() 获取所有的public 修饰的构造方法

                 public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法,包含私有的

 

    3. 通过反射获取类中的构造方法,并完成对象的创建:

              基本步骤:

                1.获取字节码文件对象

                2.通过字节码文件对象 ,获取到指定的构造方法

                         getConstructor(参数);

                3.通过构造方法,创建对象

                         public T newInstance(Object... initargs)

 

                  私有构造方法,创建对象

               1. 获取字节码文件对象

                2. 通过字节码文件对象 ,获取到指定的构造方法

                         getDeclaredConstructor (参数);

               

                3.通过构造方法,创建对象

                         public T newInstance(Object... initargs)

 

    4.通过反射,获取Class文件中的方法


                获取指定的方法

                         public Method getMethod(String name, Class<?>... parameterTypes)

                 获取指定的public方法

                         public Method getDeclaredMethod(String name, Class<?>... parameterTypes)

                                   获取指定的任意方法,包含私有的


                 获取所有的方法

                         public Method[] getMethods() 获取本类与父类中所有public 修饰的方法

                         ublic Method[] getDeclaredMethods()获取本类中所有的方法,包含私有的

        

           通过反射,调用方法

              基本步骤:

               1.获取Class对象

               2.获取构造方法,创建对象

               3.获取指定的public方法

               4.执行方法     

本文转自xinsz08の平行时空博客51CTO博客,原文链接http://blog.51cto.com/xinsz08/1947327如需转载请自行联系原作者


维度2018

相关文章
|
3月前
|
安全 Java 编译器
Java反射的原理
Java 反射是一种强大的特性,允许程序在运行时动态加载、查询和操作类及其成员。通过 `java.lang.reflect` 包中的类,可以获取类的信息并调用其方法。反射基于类加载器和 `Class` 对象,可通过类名、`getClass()` 或 `loadClass()` 获取 `Class` 对象。反射可用来获取构造函数、方法和字段,并动态创建实例、调用方法和访问字段。虽然提供灵活性,但反射会增加性能开销,应谨慎使用。常见应用场景包括框架开发、动态代理、注解处理和测试框架。
|
7月前
|
安全 Java API
反射的笔记
反射的笔记
39 0
|
7月前
|
设计模式 Java
java反射基础
本文主要针对java中的反射基础知识进行讲解
48 0
|
7月前
|
Java
Java反射的详细解析之三
面试题: 你觉得反射好不好?好,有两个方向 第一个方向:无视修饰符访问类中的内容。但是这种操作在开发中一般不用,都是框架底层来用的。 第二个方向:反射可以跟配置文件结合起来使用,动态的创建对象,动态的调用方法。
44 0
|
安全 Java 编译器
JAVA注解与反射:看这篇文章就够了2
JAVA注解与反射:看这篇文章就够了
83 0
|
安全 Java 编译器
JAVA注解与反射:看这篇文章就够了1
JAVA注解与反射:看这篇文章就够了
148 0
|
存储 编译器 C++
C嘎嘎~~ [类 下篇]
C嘎嘎~~ [类 下篇]
|
SQL 监控 Java
魔法反射--java反射进阶(实战篇)
相信很多人在初学反射的时候也都会有这个想法(我就不相信就只有我一个人这么蠢!!) 大多数人不了解反射的原因并不是不了解, 而是不知道它到底能用来干什么 今天就来为大家分享一下反射的用法
88 0
|
Java
Java反射 - 基础篇
Java反射 - 基础篇
116 0
Java反射 - 基础篇