java反射实例详解

最新推荐文章于 2024-08-11 09:51:52 发布

static_mkk

最新推荐文章于 2024-08-11 09:51:52 发布

阅读量547

点赞数

分类专栏： javase 文章标签： java

javase 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

菜鸟第一次写这啥博客呵呵就前几天面试面试官提到的Java反射机制没有回答上来回来钻研了一下只是一些很浅显的东西菜鸟而已(高手们懂的) 废话不多说言归正传

一什么是 Java反射机制有什么用

（1）： JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

（2）：Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。

（可以进行百度或google 有详细的解释嘻嘻偷点懒）

二 Java反射机制主要提供了以下功能

在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

用实例来说明

(1) class 类的使用：获取类的属性、方法、构造方法、类的相关信息

[java] view plain copy

print ?

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
*
* @author lijian
*class 类的使用：获取类的属性、方法、构造方法、类的相关信息
*/
public class TestClass_1 {
public static void main(String[] args) throws ClassNotFoundException {
//forName(String className)返回与带有给定字符串名的类或接口相关联的 Class 对象。
Class clazz = Class.forName(”java.lang.String”);
//getDeclaredFields();返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段，包括公共、保护、默认（包）访问和私有字段，但不包括继承的字段。
Field[] field = clazz.getDeclaredFields();
System.out.println(”———————显示类的属性—————————-“);
for (Field f : field) {
//getName()返回此 Field 对象表示的字段的名称
//getType()返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。
System.out.println(f.getName() + ” ” + f.getType());
}
System.out.println(”———————显示类的方法—————————–”);
//getDeclaredMethods() 返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
Method[] method = clazz.getDeclaredMethods();
for (Method m : method) {
System.out.println(m.getName());
}
System.out.println(”———————显示类的构造方法—————————–”);
//getDeclaredConstructors() 返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。
Constructor[] constructors = clazz.getDeclaredConstructors();
for(Constructor c:constructors)
{
System.out.println(c);
}
System.out.println(”———————-获取类的相关的信息———————————————-“);
System.out.println(”类所在的包为：”+ clazz.getPackage().getName());
System.out.println(”类名：”+ clazz.getName());
System.out.println(”父类的名称：”+ clazz.getSuperclass().getName());
}
}

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
 * 
 * @author lijian
 *class 类的使用：获取类的属性、方法、构造方法、类的相关信息
 */
public class TestClass_1 {

    public static void main(String[] args) throws ClassNotFoundException {
       //forName(String className)返回与带有给定字符串名的类或接口相关联的 Class 对象。
        Class clazz = Class.forName("java.lang.String");
       //getDeclaredFields();返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段，包括公共、保护、默认（包）访问和私有字段，但不包括继承的字段。
        Field[] field = clazz.getDeclaredFields();
        System.out.println("---------------------显示类的属性----------------------------");
        for (Field f : field) {
            //getName()返回此 Field 对象表示的字段的名称
            //getType()返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。
            System.out.println(f.getName() + "        " + f.getType());
        }
        System.out.println("---------------------显示类的方法-----------------------------");
        //getDeclaredMethods() 返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
        Method[] method = clazz.getDeclaredMethods();
        for (Method m : method) {
            System.out.println(m.getName());
        }
        System.out.println("---------------------显示类的构造方法-----------------------------");
        //getDeclaredConstructors() 返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。
       Constructor[] constructors = clazz.getDeclaredConstructors();
       for(Constructor c:constructors)
       {
           System.out.println(c);
       }
      System.out.println("----------------------获取类的相关的信息----------------------------------------------");
      System.out.println("类所在的包为："+ clazz.getPackage().getName());
      System.out.println("类名："+ clazz.getName());
      System.out.println("父类的名称："+ clazz.getSuperclass().getName());

    }
}

（可以运行瞧瞧效果····嘿嘿）

以下示例中会使用到User.java类，其代码如下：

[java] view plain copy

print ?

public class User {
private String name;
private int age;
public User(){}
public User(String name, int age) {
}
属性的setter 和getter 方法省略······

public class User {

    private String name;
    private int age;

    public User(){}
    public User(String name, int age) {
    }
属性的setter 和getter 方法 省略······

(2)生成一个类的Class对象有一下四种方式

[java] view plain copy

print ?

import entity.User;
/**
*
* @author lijian
* 创建Class对象的4种方法
*/
public class TestClass_2 {
public static void main(String[] args) throws ClassNotFoundException {
User user = new User();
// 第一种：对象.Class
Class clazz = user.getClass();
// 使用包装器获取Class 对象
String str = ”asdasd”;
clazz = str.getClass();
// 第二种：类.class
clazz = User.class;
clazz = String.class;
clazz = Integer.class;
// 第三种：Class.forname();
clazz = Class.forName(”java.lang.String”);
clazz = Class.forName(”java.lang.Long”);
//第四种：包装类.type
clazz = Integer.TYPE;
}
}

import entity.User;

/**
 * 
 * @author lijian 
 * 创建Class对象的4种方法
 */
public class TestClass_2 {

    public static void main(String[] args) throws ClassNotFoundException {
        User user = new User();
        // 第一种：对象.Class
        Class clazz = user.getClass();
        // 使用包装器获取Class 对象
        String str = "asdasd";
        clazz = str.getClass();
        // 第二种 ：类.class
        clazz = User.class;
        clazz = String.class;
        clazz = Integer.class;

        // 第三种：Class.forname();
        clazz = Class.forName("java.lang.String");
        clazz = Class.forName("java.lang.Long");

        //第四种：包装类.type
        clazz = Integer.TYPE;
    }
}

(3)使用反射动态创建对象实例有两种方式：

方法一：通过Class的newInstance()方法

该方法要求该Class 对象的对应类有无参构造方法

执行newInstance()实际上就是执行无参构造方法来创建该类的实例

方法二：通过Constructor的newInstance() 方法

先使用Class对象获得指定的Constructor对象

再调用Constructor对象的newInstance()方法来创建该Class对象对应类的对象

通过该方法可以选择使用指定的构造方法来创建对象

下面就两种方法写个简单的实例

[java] view plain copy

print ?

import java.lang.reflect.Constructor;
import entity.User;
/**
*
* @author lijian
* 使用反射动态创建对象两种方式
*/
public class TestClass_3 {
public static void main(String[] args) throws Exception {
/**
* 方法1：通过Class的newInstance()方法
* 该方法要求该Class对象的对应类有无参构造方法
* 执行newInstance()实际上就是执行无参构造方法来创建该类的实例
*/
// Class clazz = Class.forName(“entity.User”);
// Object obj = clazz.newInstance();
/**
* 方法2：通过Constructor的newInstance()方法
* 先使用Class对象获取指定的Constructor对象
* 再调用Constructor对象的newInstance()方法来创建该Class对象对应类的对象
* 通过该方法可选择使用指定构造方法来创建对象
*/
Class clazz = Class.forName(”entity.User”);
//指定有参的构造方法
Constructor cons = clazz.getConstructor(new Class[] {int.class,String.class,String.class});
//使用有参数的构造方法实例对象
Object obj = cons.newInstance(new Object[]{1,“scott”,“1234”});
//转换为实际操作类
User user = (User)obj;
//也可以调用无参构造方法，比第一种方法复杂
obj = clazz.getConstructor(new Class[]{}).newInstance(new Object[]{});
user = (User)obj;
//以下也可以调用无参构造方法
obj = clazz.getConstructor().newInstance();
//转换为实际操作类
user = (User)obj;
}
}

import java.lang.reflect.Constructor;
import entity.User;

/**
 * 
 * @author lijian
 *  使用反射 动态创建对象  两种方式
 */
public class TestClass_3 {
    public static void main(String[] args) throws Exception {
        /**
         * 方法1：通过Class的newInstance()方法
         *          该方法要求该Class对象的对应类有无参构造方法
         *              执行newInstance()实际上就是执行无参构造方法来创建该类的实例
         */
    //      Class  clazz = Class.forName("entity.User");
    //  Object obj =  clazz.newInstance();

        /**
         * 方法2：通过Constructor的newInstance()方法
         *             先使用Class对象获取指定的Constructor对象
         *             再调用Constructor对象的newInstance()方法来创建该Class对象对应类的对象
         *              通过该方法可选择使用指定构造方法来创建对象
         */
        Class clazz = Class.forName("entity.User");
        //指定有参的构造方法
        Constructor cons = clazz.getConstructor(new Class[] {int.class,String.class,String.class});
        //使用有参数的构造方法实例对象
                Object obj = cons.newInstance(new Object[]{1,"scott","1234"});
                //转换为实际操作类
                User user = (User)obj;

                //也可以调用无参构造方法，比第一种方法复杂
                obj = clazz.getConstructor(new Class[]{}).newInstance(new Object[]{});
                user = (User)obj;
                //以下也可以调用无参构造方法
                obj = clazz.getConstructor().newInstance();
                //转换为实际操作类
                 user = (User)obj;
    }

}

（4）使用反射动态修改查询的属性值

通过Class对象的getFields() 或者getField()方法可以获得该类所包括的全部Field属性或指定Filed属性。Field类提供了以下方法来方法访问属性

getXxx(Object obj) ：获取obj对象该Field的属性值。此处的Xxx对应8个基本数据类型，如果该属性类型是引用类型则直接使用get(Objectobj)

setXxx(Object obj,Xxx val) ：将obj对象的该Field赋值val。此处的Xxx对应8个基本数据类型，如果该属性类型是引用类型则直接使用set(Objectobj, Object val)

setAccessible(Boolean flag)：若flag为true，则取消属性的访问权限控制，即使private属性也可以进行访问

[java] view plain copy

print ?

import java.lang.reflect.Field;
/**
*
* @author lijian
* 使用反射动态修改查询属性值
*/
public class TestClass_4 {
public static void main(String[] args) throws Exception {
Class clazz = Class.forName(”entity.User”);
Object obj = clazz.newInstance();//获得类的实例
//获得 User 类中的指定属性对应的Field对象（每个属性对应一个Field对象）
Field field = clazz.getDeclaredField(”name”);
//取消属性的访问权限控制，即使private 属性也可以进行访问
field.setAccessible(true);
//调用 getter 方法获取属性值
System.out.println(field.get(obj));
//调用setter 方法给属性赋值
field.set(obj, ”scott”);
//调用 getter 方法获取对应属性修改后的值
System.out.println(field.get(obj));
}
}

import java.lang.reflect.Field;


/**
 * 
 * @author lijian
 *    使用反射动态修改查询属性值
 */
public class TestClass_4 {

    public static void main(String[] args) throws Exception {
        Class clazz = Class.forName("entity.User");
        Object obj = clazz.newInstance();//获得类的实例
        //获得 User 类中的指定属性对应的Field对象（每个属性对应一个Field对象）
        Field field = clazz.getDeclaredField("name");

        //取消属性的访问权限控制，即使private 属性也可以进行访问
        field.setAccessible(true);
        //调用 getter 方法获取属性值
        System.out.println(field.get(obj));
        //调用setter 方法给属性赋值
        field.set(obj, "scott");
        //调用 getter 方法获取对应属性修改后的值
        System.out.println(field.get(obj));
    }
}

（5）使用反射动态执行方法

通过Class对象的getMethods()方法可以获得该类所包括的全部方法，返回值是Method[]

通过Class对象的getMethod() 方法可以获得该类所包括的执行方法，返回值是Method

每个Method对象对应一个方法，获得Method对象后，可以调用其invoke() 来调用对应方法

Objectinvoke(Object obj , Object [] args): obj代表当前方法所属的对象的名字，

args代表当前方法的参数列表，

返回值Object是当前方法的返回值，即执行当前方法的结果。

[java] view plain copy

print ?

import java.lang.reflect.Method;
import entity.User;
/**
*
* @author lijian
* 使用反射动态执行方法
*/
public class TestClass_5 {
public static void main(String[] args) throws Exception{
Class clazz = User.class;
Object obj = clazz.newInstance();
//调用该对象的 setName方法
Method method = clazz.getMethod(”setName”, new Class[]{String.class});
Object result =method.invoke(obj, new Object[]{“scott”}); // obj.setName(“scott”);
System.out.println(”返回值为：”+result);
//调用对象的getName()方法
Method method1 = clazz.getMethod(”getName”, new Class[]{});
Object obj1 = method1.invoke(obj, new Object[]{});
System.out.println(”返回值为：”+obj1);
}
}

import java.lang.reflect.Method;
import entity.User;

/**
 * 
 * @author lijian
 *  使用反射动态执行方法
 */
public class TestClass_5 {

    public static void main(String[] args) throws Exception{

        Class clazz = User.class;
        Object obj = clazz.newInstance();


        //调用该对象的 setName方法
        Method method = clazz.getMethod("setName", new Class[]{String.class});
        Object result =method.invoke(obj, new Object[]{"scott"});       //  obj.setName("scott");
        System.out.println("返回值为："+result);

        //调用对象的getName()方法
        Method method1 = clazz.getMethod("getName", new Class[]{});
        Object obj1 = method1.invoke(obj, new Object[]{});
        System.out.println("返回值为："+obj1);
    }
}

（6）使用反射动态创建数组并存取元素

在java.lang.reflect包下提供了Array类，包括一系列static方法，通过这些方法可动态的创建数组、给元素赋值、取出元素值等

Array提供的主要方法如下：

static ObjectnewInstance(Class<?> componentType, int[] dim) ：创建一个具有指定的组件类型和维度的新数组

static void setXxx(Objectarray, int index ，xxx val)：给数组对象array中第index个元素赋值val

static xxx getXxx(Objectarray, int index)：以 xxx形式返回指定数组对象array中第index个元素值

<1>动态创建一维数组，并给数组赋值：

[java] view plain copy

print ?

import java.lang.reflect.Array;
/**
*
* @author lijian
* 动态创建一维数组，并给数组赋值：
*/
public class TestClass_6 {
public static void main(String[] args) throws Exception {
Class clazz = Class.forName(”java.lang.Integer”);
Object array = Array.newInstance(clazz, 10);//根据类的class 创建大小为10的数组
Array.set(array, 5, 10);//给数组的第5个元素赋值为10
Object el = Array.get(array, 5);//取出数组的第5个元素值显示
System.out.println(el);
}
}

import java.lang.reflect.Array;

/**
 * 
 * @author lijian
 *  动态创建一维数组，并给数组赋值：
 */
public class TestClass_6 {

    public static void main(String[] args) throws Exception  {   
          Class clazz = Class.forName("java.lang.Integer");
          Object array = Array.newInstance(clazz, 10);//根据类的class 创建大小为10的数组
          Array.set(array, 5, 10);//给数组的第5个元素赋值为10
          Object el = Array.get(array, 5);//取出数组的第5个元素值显示
          System.out.println(el);
    }

}

<2>动态创建二维数组，并给数组赋值：

[java] view plain copy

print ?

import java.lang.reflect.Array;
/**
*
* @author lijian
*动态创建二维数组，并给数组赋值：
*/
public class TestClass_7 {
public static void main(String[] args) {
int dims[] = {10,15};
Object array = Array.newInstance(int.class, dims);//创建一个10行15列二维数组，等价与：array[10][15]
Object array1 = Array.get(array, 5);//获取二维数组中的第5行
Array.set(array1, 8, 300); //给数组的第5行8列赋值300，等价与：array[5][8]=300
Object el = Array.get(array1, 8);//取出数组中第5行8列的值
System.out.println(el);
}
}

import java.lang.reflect.Array;

/**
 * 
 * @author lijian
 *动态创建二维数组，并给数组赋值：
 */
public class TestClass_7 {

    public static void main(String[] args) {
        int dims[] = {10,15};
        Object  array = Array.newInstance(int.class, dims);//创建一个10行15列二维数组，等价与：array[10][15]
        Object  array1 = Array.get(array, 5);//获取二维数组中的第5行
        Array.set(array1, 8, 300);     //给数组的第5行8列赋值300，等价与：array[5][8]=300
        Object el = Array.get(array1, 8);//取出数组中第5行8列的值
        System.out.println(el);
    }
}