反射的定义及其简单实用方法

红太狼 2022-07-11 06:55 234阅读 0赞

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

要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

**public****class** Person \{

**private** String name;

**int** age;

**public** String address;

**public** Person() \{

**private** Person(String name) \{

**this**.name = name;

Person(String name, **int** age) \{

**this**.name = name;

**this**.age = age;

**public** Person(String name, **int** age, String address) \{

**this**.name = name;

**this**.age = age;

**this**.address = address;

**public****void** show() \{

System.out.println("show");

**public****void** method(String s) \{

System.out.println("method " \+ s);

**public** String getString(String s, **int** i) \{

**return** s + "---" \+ i;

**private****void** function() \{

System.out.println("function");

@Override

**public** String toString() \{

**return**"Person \[name=" \+ name + ", age=" \+ age + ", address=" \+ address

\+ "\]";

/\*

\* 反射：就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。

\* Person p = new Person();

\* p.使用

\* 要想这样使用，首先你必须得到class文件对象，其实也就是得到Class类的对象。

\* Class类：

\* 成员变量Field

\* 构造方法Constructor

\* 成员方法Method

\* 获取class文件对象的方式：

\* A:Object类的getClass()方法

\* B:数据类型的静态属性class

\* C:Class类中的静态方法

\* public static Class forName(String className)

\* 一般我们到底使用谁呢?

\* A:自己玩任选一种，第二种比较方便

\* B:开发第三种

\* 为什么呢?因为第三种是一个字符串，而不是一个具体的类名。这样我们就可以把这样的字符串配置到配置文件中。

\*/

**public****class** ReflectDemo \{

**public****static****void** main(String\[\] args) **throws** ClassNotFoundException \{

// 方式1

Person p = **new** Person();

Class c = p.getClass();

Person p2 = **new** Person();

Class c2 = p2.getClass();

System.out.println(p == p2);// false

System.out.println(c == c2);// true

// 方式2

Class c3 = Person.**class**;

// int.class;

// String.class;

System.out.println(c == c3);

// 方式3

// ClassNotFoundException

Class c4 = Class.forName("cn.it18zhang\_01.Person");

System.out.println(c == c4);

# **通过反射获取构造方法并使用** #

**获取构造方法**

getConstructors

getDeclaredConstructors

**创建对象**

newInstance()

con.newInstance(“zhangsan", 20);

/\*

\* 通过反射获取构造方法并使用。

\*/

**public****class** ReflectDemo \{

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

// 获取字节码文件对象

Class c = Class.forName("cn.it18zhang\_01.Person");

// 获取构造方法

// public Constructor\[\] getConstructors():所有公共构造方法

// public Constructor\[\] getDeclaredConstructors():所有构造方法

// Constructor\[\] cons = c.getDeclaredConstructors();

// for (Constructor con : cons) \{

// System.out.println(con);

// \}

// 获取单个构造方法

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

// 参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象

Constructor con = c.getConstructor();// 返回的是构造方法对象

// Person p = new Person();

// System.out.println(p);

// public T newInstance(Object... initargs)

// 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。

Object obj = con.newInstance();

System.out.println(obj);

// Person p = (Person)obj;

// p.show();

# **带参数使用** #

/\*

\* 需求：通过反射去获取该构造方法并使用：

\* public Person(String name, int age, String address)

\* Person p = new Person("林青霞",27,"北京");

\* System.out.println(p);

\*/

**public****class** ReflectDemo2 \{

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

// 获取字节码文件对象

Class c = Class.forName("cn.it18zhang\_01.Person");

// 获取带参构造方法对象

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

Constructor con = c.getConstructor(String.**class**, **int**.**class**,

String.**class**);

// 通过带参构造方法对象创建对象

// public T newInstance(Object... initargs)

Object obj = con.newInstance("林青霞", 27, "北京");

System.out.println(obj);

# **通过反射获取私有构造方法并使用** #

/\*

\* 需求：通过反射获取私有构造方法并使用

\* private Person(String name)\{\}

\* Person p = new Person("风清扬");

\* System.out.println(p);

\*/

**public****class** ReflectDemo3 \{

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

// 获取字节码文件对象

Class c = Class.forName("cn.it18zhang\_01.Person");

// 获取私有构造方法对象

// NoSuchMethodException：每个这个方法异常

// 原因是一开始我们使用的方法只能获取公共的，下面这种方式就可以了。

Constructor con = c.getDeclaredConstructor(String.**class**);

// 用该私有构造方法创建对象

// IllegalAccessException:非法的访问异常。

// 暴力访问

con.setAccessible(**true**);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查。

Object obj = con.newInstance("风清扬");

System.out.println(obj);

# **通过反射获取成员变量并且使用** #

/\*

\* 通过发生获取成员变量并使用

\*/

**public****class** ReflectDemo \{

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

// 获取字节码文件对象

Class c = Class.forName("cn.it18zhang\_01.Person");

// 获取所有的成员变量

// Field\[\] fields = c.getFields();

// Field\[\] fields = c.getDeclaredFields();

// for (Field field : fields) \{

// System.out.println(field);

// \}

/\*

\* Person p = new Person(); p.address = "北京"; System.out.println(p);

\*/

// 通过无参构造方法创建对象

Constructor con = c.getConstructor();

Object obj = con.newInstance();

System.out.println(obj);

// 获取单个的成员变量

// 获取address并对其赋值

Field addressField = c.getField("address");

// public void set(Object obj,Object value)

// 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。

addressField.set(obj, "北京"); //  给obj对象的addressField字段设置值为"北京"

System.out.println(obj);

// 获取name并对其赋值

// NoSuchFieldException

Field nameField = c.getDeclaredField("name");

// IllegalAccessException

nameField.setAccessible(**true**);

nameField.set(obj, "林青霞");

System.out.println(obj);

// 获取age并对其赋值

Field ageField = c.getDeclaredField("age");

ageField.setAccessible(**true**);

ageField.set(obj, 27);

System.out.println(obj);

# **通过反射获取无参无返回值成员方法的使用** #

**public****class** ReflectDemo \{

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

// 获取字节码文件对象

Class c = Class.forName("cn.it18zhang\_01.Person");

// 获取所有的方法

// Method\[\] methods = c.getMethods(); // 获取自己的包括父亲的公共方法

// Method\[\] methods = c.getDeclaredMethods(); // 获取自己的所有的方法

// for (Method method : methods) \{

// System.out.println(method);

// \}

Constructor con = c.getConstructor();

Object obj = con.newInstance();

/\*

\* Person p = new Person(); p.show();

\*/

// 获取单个方法并使用

// public void show()

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

// 第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型

Method m1 = c.getMethod("show");

// obj.m1(); // 错误

// public Object invoke(Object obj,Object... args)

// 返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数

m1.invoke(obj); //  调用obj对象的m1方法

System.out.println("----------");

// public void method(String s)

Method m2 = c.getMethod("method", String.**class**);

m2.invoke(obj, "hello");

System.out.println("----------");

// public String getString(String s, int i)

Method m3 = c.getMethod("getString", String.**class**, **int**.**class**);

Object objString = m3.invoke(obj, "hello", 100);

System.out.println(objString);

// String s = (String)m3.invoke(obj, "hello",100);

// System.out.println(s);

System.out.println("----------");

// private void function()

Method m4 = c.getDeclaredMethod("function");

m4.setAccessible(**true**);

m4.invoke(obj);

# **通过配置文件运行类中的方法** #

/\*

\* 通过配置文件运行类中的方法

\* 反射：

\* 需要有配置文件配合使用。

\* 用class.txt代替。

\* 并且你知道有两个键。

\* className

\* methodName

\*/

**public****class** Test \{

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

// 反射前的做法

// Student s = new Student();

// s.love();

// Teacher t = new Teacher();

// t.love();

// Worker w = new Worker();

// w.love();

// 反射后的做法

// 加载键值对数据

Properties prop = **new** Properties();

FileReader fr = **new** FileReader("class.txt");

prop.load(fr);

fr.close();

// 获取数据

String className = prop.getProperty("className");

String methodName = prop.getProperty("methodName");

// 反射

Class c = Class.forName(className);

Constructor con = c.getConstructor();

Object obj = con.newInstance();

// 调用方法

Method m = c.getMethod(methodName);

m.invoke(obj);

**public****class** Student \{

**public****void** love() \{

System.out.println("爱生活,爱Java");

反射的定义及其简单实用方法

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关反射（反射的概念、反射的使用、Class类的其他方法）

相关关于Field反射的简单理解

相关 Java：调用反射的方法

相关反射的定义及其简单实用方法

相关 Java反射的简单使用

相关使用java反射，自定义springMvc简单案例

相关 Java反射的简单入门

相关 java反射的简单引用（模板）

相关反射的理解（newInstance()方法）

相关反射的操作方法