您的位置:

java反射机制的讲解(java反射机制详解)

本文目录一览:

如何理解Java反射机制

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

JAVA反射(放射)机制:“程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言”。从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C#不是动态语言。但是JAVA有着一个非常突出的动态相关机制:Reflection,用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说,Java程序可以加载一个运行时才得知名称的class,获悉其完整构造(但不包括methods定义),并生成其对象实体、或对其fields设值、或唤起其methods!

java中的反射机制是什么?有什么作用呢?求解,谢谢。

Java反射机制详解

1. 反射机制是什么

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

2. 反射机制能做什么

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

在运行时判断任意一个对象所属的类;

在运行时构造任意一个类的对象;

在运行时判断任意一个类所具有的成员变量和方法;

在运行时调用任意一个对象的方法;

生成动态代理。

3. 反射机制的相关API

通过一个对象获得完整的包名和类名

package net.xsoftlab.baike;

public class TestReflect {

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

        TestReflect testReflect = new TestReflect();

        System.out.println(testReflect.getClass().getName());

        // 结果 net.xsoftlab.baike.TestReflect

    }

}

实例化Class类对象

package net.xsoftlab.baike;

public class TestReflect {

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

        Class? class1 = null;

        Class? class2 = null;

        Class? class3 = null;

        // 一般采用这种形式

        class1 = Class.forName("net.xsoftlab.baike.TestReflect");

        class2 = new TestReflect().getClass();

        class3 = TestReflect.class;

        System.out.println("类名称   " + class1.getName());

        System.out.println("类名称   " + class2.getName());

        System.out.println("类名称   " + class3.getName());

    }

}

获取一个对象的父类与实现的接口

package net.xsoftlab.baike;

import java.io.Serializable;

public class TestReflect implements Serializable {

    private static final long serialVersionUID = -2862585049955236662L;

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

        Class? clazz = Class.forName("net.xsoftlab.baike.TestReflect");

        // 取得父类

        Class? parentClass = clazz.getSuperclass();

        System.out.println("clazz的父类为:" + parentClass.getName());

        // clazz的父类为: java.lang.Object

        // 获取所有的接口

        Class? intes[] = clazz.getInterfaces();

        System.out.println("clazz实现的接口有:");

        for (int i = 0; i  intes.length; i++) {

            System.out.println((i + 1) + ":" + intes[i].getName());

        }

        // clazz实现的接口有:

        // 1:java.io.Serializable

    }

}

获取某个类中的全部构造函数 - 详见下例

通过反射机制实例化一个类的对象

package net.xsoftlab.baike;

import java.lang.reflect.Constructor;

public class TestReflect {

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

        Class? class1 = null;

        class1 = Class.forName("net.xsoftlab.baike.User");

        // 第一种方法,实例化默认构造方法,调用set赋值

        User user = (User) class1.newInstance();

        user.setAge(20);

        user.setName("Rollen");

        System.out.println(user);

        // 结果 User [age=20, name=Rollen]

        // 第二种方法 取得全部的构造函数 使用构造函数赋值

        Constructor? cons[] = class1.getConstructors();

        // 查看每个构造方法需要的参数

        for (int i = 0; i  cons.length; i++) {

            Class? clazzs[] = cons[i].getParameterTypes();

            System.out.print("cons[" + i + "] (");

            for (int j = 0; j  clazzs.length; j++) {

                if (j == clazzs.length - 1)

                    System.out.print(clazzs[j].getName());

                else

                    System.out.print(clazzs[j].getName() + ",");

            }

            System.out.println(")");

        }

        // 结果

        // cons[0] (java.lang.String)

        // cons[1] (int,java.lang.String)

        // cons[2] ()

        user = (User) cons[0].newInstance("Rollen");

        System.out.println(user);

        // 结果 User [age=0, name=Rollen]

        user = (User) cons[1].newInstance(20, "Rollen");

        System.out.println(user);

        // 结果 User [age=20, name=Rollen]

    }

}

class User {

    private int age;

    private String name;

    public User() {

        super();

    }

    public User(String name) {

        super();

        this.name = name;

    }

    public User(int age, String name) {

        super();

        this.age = age;

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    @Override

    public String toString() {

        return "User [age=" + age + ", name=" + name + "]";

    }

}

获取某个类的全部属性

package net.xsoftlab.baike;

import java.io.Serializable;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

public class TestReflect implements Serializable {

    private static final long serialVersionUID = -2862585049955236662L;

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

        Class? clazz = Class.forName("net.xsoftlab.baike.TestReflect");

        System.out.println("===============本类属性===============");

        // 取得本类的全部属性

        Field[] field = clazz.getDeclaredFields();

        for (int i = 0; i  field.length; i++) {

            // 权限修饰符

            int mo = field[i].getModifiers();

            String priv = Modifier.toString(mo);

            // 属性类型

            Class? type = field[i].getType();

            System.out.println(priv + " " + type.getName() + " " + field[i].getName() + ";");

        }

         

        System.out.println("==========实现的接口或者父类的属性==========");

        // 取得实现的接口或者父类的属性

        Field[] filed1 = clazz.getFields();

        for (int j = 0; j  filed1.length; j++) {

            // 权限修饰符

            int mo = filed1[j].getModifiers();

            String priv = Modifier.toString(mo);

            // 属性类型

            Class? type = filed1[j].getType();

            System.out.println(priv + " " + type.getName() + " " + filed1[j].getName() + ";");

        }

    }

}

通过反射机制调用某个类的方法

package net.xsoftlab.baike;

import java.lang.reflect.Method;

public class TestReflect {

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

        Class? clazz = Class.forName("net.xsoftlab.baike.TestReflect");

        // 调用TestReflect类中的reflect1方法

        Method method = clazz.getMethod("reflect1");

        method.invoke(clazz.newInstance());

        // Java 反射机制 - 调用某个类的方法1.

        // 调用TestReflect的reflect2方法

        method = clazz.getMethod("reflect2", int.class, String.class);

        method.invoke(clazz.newInstance(), 20, "张三");

        // Java 反射机制 - 调用某个类的方法2.

        // age - 20. name - 张三

    }

    public void reflect1() {

        System.out.println("Java 反射机制 - 调用某个类的方法1.");

    }

    public void reflect2(int age, String name) {

        System.out.println("Java 反射机制 - 调用某个类的方法2.");

        System.out.println("age - " + age + ". name - " + name);

    }

}

通过反射机制操作某个类的属性

package net.xsoftlab.baike;

import java.lang.reflect.Field;

public class TestReflect {

    private String proprety = null;

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

        Class? clazz = Class.forName("net.xsoftlab.baike.TestReflect");

        Object obj = clazz.newInstance();

        // 可以直接对 private 的属性赋值

        Field field = clazz.getDeclaredField("proprety");

        field.setAccessible(true);

        field.set(obj, "Java反射机制");

        System.out.println(field.get(obj));

    }

}

4. 反射机制的应用实例

在泛型为Integer的ArrayList中存放一个String类型的对象。

package net.xsoftlab.baike;

import java.lang.reflect.Method;

import java.util.ArrayList;

public class TestReflect {

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

        ArrayListInteger list = new ArrayListInteger();

        Method method = list.getClass().getMethod("add", Object.class);

        method.invoke(list, "Java反射机制实例。");

        System.out.println(list.get(0));

    }

}

通过反射取得并修改数组的信息

package net.xsoftlab.baike;

import java.lang.reflect.Array;

public class TestReflect {

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

        int[] temp = { 1, 2, 3, 4, 5 };

        Class? demo = temp.getClass().getComponentType();

        System.out.println("数组类型: " + demo.getName());

        System.out.println("数组长度  " + Array.getLength(temp));

        System.out.println("数组的第一个元素: " + Array.get(temp, 0));

        Array.set(temp, 0, 100);

        System.out.println("修改之后数组第一个元素为: " + Array.get(temp, 0));

    }

}

将反射机制应用于工厂模式

package net.xsoftlab.baike;

interface fruit {

    public abstract void eat();

}

class Apple implements fruit {

    public void eat() {

        System.out.println("Apple");

    }

}

class Orange implements fruit {

    public void eat() {

        System.out.println("Orange");

    }

}

class Factory {

    public static fruit getInstance(String ClassName) {

        fruit f = null;

        try {

            f = (fruit) Class.forName(ClassName).newInstance();

        } catch (Exception e) {

            e.printStackTrace();

        }

        return f;

    }

}

/**

 * 对于普通的工厂模式当我们在添加一个子类的时候,就需要对应的修改工厂类。 当我们添加很多的子类的时候,会很麻烦。

 * Java 工厂模式可以参考

 * 

 * 

 * 现在我们利用反射机制实现工厂模式,可以在不修改工厂类的情况下添加任意多个子类。

 * 

 * 但是有一点仍然很麻烦,就是需要知道完整的包名和类名,这里可以使用properties配置文件来完成。

 * 

 * java 读取 properties 配置文件 的方法可以参考

 * 

 * 

 * @author xsoftlab.net

 */

public class TestReflect {

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

        fruit f = Factory.getInstance("net.xsoftlab.baike.Apple");

        if (f != null) {

            f.eat();

        }

    }

}

我有一个微信公众号,经常会分享一些Java技术相关的干货,还有一些学习资源。

如果你喜欢我的分享,可以用微信搜索“Java团长”或者“javatuanzhang”关注。

Java里面反射的原理是什么?

Java在编译之后会生成一个class文件,反射通过字节码文件找到其类中的方法和属性等。

通过反射,java可以动态的加载未知的外部配置对象,临时生成字节码进行加载使用,使代码更灵活,极大地提高应用的扩展性。

其实博客会有更加详细的解释。

什么是java的反射?

Java反射指的是对于任何的一个java类,我们都可以通过反射获取到这个类的所有属性和方法(包含私有的属性方法),使用java反射我们也可以调用一个对象的任何方法。

我们知道Java是一门面向对象编程的语言,我们编程的时候,经常会将类的属性进行封装,然后提供public方法进行属性的设置和获取。类的属性我们通常会设置成private的私有属性,为的就是保护对象属性不被随意的修改和访问。但是反射机制却恰恰相反,通过反射,我们可以获取到这些被保护的属性和方法,并且可以修改和访问他们。

在java中我们可以使用object对象的getClass();方法获得Class的对象classObject;语法格式为 Class classObject = object.getClass() ;可以根据Class对象的方法获取object对象的相关属性和方法;

获取object对象的名字可以使用 classObject.getName();获取类的名称,获取到的结果包含包的名称;

获取object对象的包名称,可以使用classObject.getPackage();获取包的名称;

获取object对象的所有public属性,可以使用classObject.getFields();方法,返回列表是属性类Field[]对象列表;

获取object对象所有属性,可以使用classObject.getDeclaredFields();方法,返回的是所有属性列表(包含private属性);

获取object对象某个特定的属性,可以使用classObject.getField( fieldName );可以根据属性名称获取属性类的对象;

获取object对象private属性,可以使用classObject.getDeclaredField( fieldName );根据属性名获取属性对象信息;

获取object对象public方法,使用classObject.getMethods();可以获取到方法类Method[]对象列表;

获取object对象某个特定的public方法,使用classObject.getMethod( funName , Class... parameterTypes);根据方法名和方法参数类型列表,可以获取到方法类的对象;

获取object对象所有方法(包含private方法);使用classObject.getDeclaredMethods();可以获取所有的方法对象列表;

获取object对象某个特定方法(包含private方法),使用classObject.getDeclaredMethod ( funName, Class... parameterTypes );根据方法名和方法参数类型列表,可以获取到类的特定方法(包含private方法);

获取object对象类中所有的public构造方法,可以使用classObject.getConstructors(); 获取到构造类Constructor的对象列表;

获取object对象类中某个特定的构造方法,可以使用classObject.getConstructor( Class... parameterTypes ); 根据参数类型列表,获取指定的构造函数对象;

获取object对象类中所有的构造方法(包含private),可以使用classObject.getDeclaredConstructors(); 获取到构造类Constructor的对象列表;

获取object对象类中某个特定的构造方法(包含private),可以使用classObject.getDeclaredConstructor( Class... parameterTypes ); 根据参数类型列表,获取指定的构造函数对象;

什么是反射?什么Java反射?

java反射是什么意思呢?下面带大家了解一下。

JAVA反射是指程序可以访问、检测和修改它本身状态或行为的一种能力。反射是一种强大的工具,能够创建灵活的代码,可以使代码在运行时装配,无需在组件之间进行源代表链接。

JAVA反射机制是在运行状态中,知道所有属性和方法,对于任意一个对象,能够调用它的方法和属性,这种动态获取的信息以及动态调用对象的方法的功能的反射机制。

反射适合用在哪

首先我们先思考一个问题,反射适合使用在哪里呢?从功能上看,反射似乎无所不能,几乎所有的类,所有的属性、方法、构造我们都能使用,但是我们细细思考一下,在实际开发中,并不是所有场景都需要使用反射获取属性或者方法进行操作,反而更多的使用实例.xxx方式操作,而当这些操作重复次数较多的时候,我们往往会考虑优化代码,减少代码冗余,提高复用,比如实体构建赋值等操作,这个时候往往是我们最需要复用的地方,所以我们可以大体认为反射主要使用在实体操作过程中。而在一般操作数据的过程中,我们的实体一般都是知道并且依赖于对应的数据类型的,比如:

1.根据类型new的方式创建对象

2.根据类型定义变量,类型可能是基本类型也可能是引用类型、类或者接口

3.将对应类型的对象传递给方法

4.根据类型访问对象的属性,调用方法等操作

以上这些操作都是数据操作的过程中最常见也是最难复用优化的地方,而如果这里的操作使用反射则可以实现动态的操作不同的类型的实例,通过调用反射入口类Class,获取对应的属性、构造、方法完成对应的操作