86 java反射_2 _反射的常见操作

文章目录

• ​​反射​​
• ​​反射常用方法​​

• ​​反射常见操作​​

• ​​常见操作代码1：​​
• ​​常见操作代码2：​​
• ​​常见操作代码3：​​
• ​​常见操作代码4：​​
• ​​常见操作代码5：​​

反射

• **​​JAVA反射机制​​**是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
• 反射被视为动态语言的关键。
• Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
• 反射机制：反射这一概念最早由编程开发人员Smith在1982年提出，主要指应用程序访问、检测、修改自身状态与行为的能力。这一概念的提出立刻吸引了编程界的极大关注，各种研究工作随之展开，随之而来引发编程革命，出现了多种支持反射机制的面向对象语言。 在计算机科学领域，反射是指一类能够自我描述和自控制的应用。在Java编程语言中，反射是一种强有力的工具，是面向抽象编程一种实现方式，它能使代码语句更加灵活，极大提高代码的运行时装配能力。
• 用途：在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。当然，也不是所有的都适合反射，之前就遇到一个案例，通过反射得到的结果与预期不符。阅读源码发现，经过层层调用后在最终返回结果的地方对应用的权限进行了校验，对于没有权限的应用返回值是没有意义的缺省值，否则返回实际值起到保护用户的隐私目的。

反射常用方法

• public String getName ()
• public Package getPackage ()
• public Class<? super T> getSuperclass () //父类
• public Class<?>[] getInterfaces () //接口
• public Constructor<?>[] getConstructors () //构造方法
• public T newInstance () //新建一个实例
• public Method[] getMethods ()
• public Field[] getFields () //字段 ，属性

反射常见操作

package com.wlw.chapter12_reflex;

import java.io.Serializable;

public class Person implements Serializable, Cloneable {
String name;
int age;

public Person() {
System.out.println("无参构造方法执行了.........");
}

public Person(String name, int age) {
System.out.println("带参构造方法执行了........");
this.name = name;
this.age = age;
}

public void eat(){
System.out.println(this.name+"正在吃饭");
}

@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}

常见操作代码1：

package com.wlw.chapter12_reflex;

import java.util.Arrays;

public class TestPerson {
public static void main(String[] args) throws Exception {
reflectOpe1();
}
//1. 使用反射获取类的名字，包名，父类，接口
public static void reflectOpe1() throws Exception {
//1.第一步先获取类对象
Class<?> class1= Class.forName("com.wlw.chapter12_reflex.Person");
//2.获取
//public String getName () 类的名字
System.out.println(class1.getName());//com.wlw.chapter12_reflex.Person

//public Package getPackage () 包名
System.out.println(class1.getPackage().getName());//com.wlw.chapter12_reflex

//public Class<? super T> getSuperclass () //父类
System.out.println(class1.getSuperclass().getName());//java.lang.Object

//public Class<?>[] getInterfaces () //接口
Class<?>[] classes = class1.getInterfaces();
System.out.println(Arrays.toString(classes));

System.out.println(class1.getSimpleName()); //Person
System.out.println(class1.getTypeName()); //com.wlw.chapter12_reflex.Person
}
}
/* 执行结果：
com.wlw.chapter12_reflex.Person
com.wlw.chapter12_reflex
java.lang.Object
[interface java.io.Serializable, interface java.lang.Cloneable]
Person
com.wlw.chapter12_reflex.Person

*/

常见操作代码2：

getConstructor(参数的类型 <可选>); newInstance(具体参数值 <可选>)

package com.wlw.chapter12_reflex;

import java.lang.reflect.Constructor;
import java.util.Arrays;

public class TestPerson {
public static void main(String[] args) throws Exception {
reflectOpe2();
}

//2. 使用反射获取类的构造方法，并创建对象（不是new）
public static void reflectOpe2() throws Exception {
//1.第一步先获取类对象
Class<?> class1= Class.forName("com.wlw.chapter12_reflex.Person");
//2.获取类的构造方法 getConstructors
Constructor<?>[] constructors = class1.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor.toString());
}

//3.获取无参构造
Constructor<?> con = class1.getConstructor();
Person zhangsan = (Person) con.newInstance();//这里就是调用无参构造方法
System.out.println(zhangsan.toString());
// 简便方法
Person lisi = (Person) class1.newInstance();//上面的简化
System.out.println(lisi.toString());

//4.获取有参构造
Constructor<?> con2 = class1.getConstructor(String.class, int.class);
Person wangwu = (Person)con2.newInstance("王五", 20);
System.out.println(wangwu.toString());


}
}
/* 执行结果：
public com.wlw.chapter12_reflex.Person()
public com.wlw.chapter12_reflex.Person(java.lang.String,int)
无参构造方法执行了.........
Person{name='null', age=0}
无参构造方法执行了.........
Person{name='null', age=0}
带参构造方法执行了........
Person{name='王五', age=20}
*/

常见操作代码3：

获取单个方法getMethod(“方法名”,参数的类型); 之后调用invoke(类的一个对象,具体参数值)

package com.wlw.chapter12_reflex;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Arrays;

public class TestPerson {
public static void main(String[] args) throws Exception {
reflectOpe3();
}
//3. 使用反射获取类的方法
public static void reflectOpe3() throws Exception{
//1.第一步先获取类对象
Class<?> class1= Class.forName("com.wlw.chapter12_reflex.Person");

//2.获取类的方法
//2.1 getMethods () 获得的是公共的方法，包括从父类继承的方法
/* Method[] methods = class1.getMethods();
for (Method method : methods) {
System.out.println(method.toString());
}*/
//2.2getDeclaredMethods() 获得的是类中所有的方法，包括私有，保护，默认，不包括继承的方法
/*Method[] declaredMethods = class1.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod.toString());
}*/

//3 获取单个方法getMethod("方法名",参数); 调用invoke(类的一个对象,参数)
//3.1 无参eat()
Method eatMethod = class1.getMethod("eat");
//正常调用方法：Person zhangsan = new Person(); zhangsan.eat();
//调用invoke(类的一个对象,参数)
Constructor<?> constructor = class1.getConstructor(String.class, int.class);
Person xiaowang = (Person) constructor.newInstance("小王", 20);//调用的是有参构造
eatMethod.invoke(xiaowang); //zhangsan.eat();
System.out.println("----------------------------");

//3.2 toString
Method toStringMethod = class1.getMethod("toString");
Object result = toStringMethod.invoke(xiaowang);
System.out.println(result);
System.out.println("----------------------------");

//3.3带参eat()
Method eatMethod2 = class1.getMethod("eat", String.class);
eatMethod2.invoke(xiaowang,"鸡腿");
System.out.println("----------------------------");

//3.4 私有方法 privateMethod
Method privateMethod = class1.getDeclaredMethod("privateMethod");
//私有方法 需要设置访问权限无效
privateMethod.setAccessible(true);
privateMethod.invoke(xiaowang);
System.out.println("----------------------------");

//3.5 静态方法staticMethod
Method staticMethod = class1.getMethod("staticMethod");
staticMethod.invoke(null);//这个也行 调用静态方法
staticMethod.invoke(xiaowang);
}
}
/* 执行结果：
带参构造方法执行了........
小王正在吃饭
----------------------------
Person{name='小王', age=20}
----------------------------
小王正在吃 鸡腿
----------------------------
这是一个私有方法
这是一个静态方法
这是一个静态方法
*/

常见操作代码4：

使用反射实现 一个方法 可以调用任意对象方法的通用方法

package com.wlw.chapter12_reflex;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Properties;

public class TestPerson {
public static void main(String[] args) throws Exception {
Properties properties = new Properties();
//properties.setProperty("name","zhangsan");
//System.out.println(properties.toString());
invokeAny(properties,"setProperty", new Class[] {String.class,String.class},"name","zhangsan");
System.out.println(properties.toString());
}

//4.使用反射实现 一个方法 可以调用任意对象方法的通用方法
public static Object invokeAny(Object object,String methodName,Class<?>[] type,Object...args ) throws Exception {
//1.获取类对象
Class<?> class1 = object.getClass();
//2.获取方法
Method method = class1.getMethod(methodName,type);
//调用
return method.invoke(object,args);
}
}
/*执行结果：
{name=zhangsan}
*/

常见操作代码5：

package com.wlw.chapter12_reflex;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Properties;

public class TestPerson {
public static void main(String[] args) throws Exception {
reflectOpe4();
}
//5. 使用反射获取类的属性 字段
public static void reflectOpe4() throws Exception{
//1.获取类对象
Class<?> class1 = Class.forName("com.wlw.chapter12_reflex.Person");

//2.获取属性 getFields() 只能获取公共的，和继承父类的；
//Field[] fields = class1.getFields();
// getDeclaredFields() 获得的是类中所有的属性，包括私有，保护，默认的
// Field[] fields = class1.getDeclaredFields();
// for (Field field : fields) {
// System.out.println(field.toString());
// }


//3.获取单个的属性
//正常赋值：Person zhangsan = new Person(); zhangsan.name = "张三";
Field namefiled = class1.getDeclaredField("name");
//namefiled.setAccessible(true); //属性私有的话，要设置访问权限无效
//赋值
Person zhangsan = (Person)class1.newInstance(); //Person zhangsan = new Person();
namefiled.set(zhangsan,"张三");//zhangsan.name = "张三";
//获取值
System.out.println(namefiled.get(zhangsan)); //zhangsan.name
}
}
/*执行结果：
无参构造方法执行了.........
张三
*/