反射(一)
程序员文章站
2022-06-18 10:53:55
...
反射
1.什么是反射
反射java语言中的一种机制，通过机制可以动态的实例化对象，读写属性、调用方法
反射的优点
反射提高了程序的灵活性和扩展性，降低耦合性，提高自适应能力。它允许程序创和控制任何类的对象，无需提前硬编码目标类
反射的缺点
性能问题，使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和扩展性要求很高的系统框架上，普通程序不建议使用
2. 类类
所有狗 狗类 Dog 狗对象 旺财
所有猫 猫类 Cat 猫对象 肥波
所有类 类类 java.lang.Class 类对象 特定类
java.lang.Class
java.lang.reflect.Method
java.lang.reflect.Field
java.lang.reflect.construct
(Dog.java , Cat.java…).java文件我们能不能描述成一种事物呢？
java.lang.Class这个类就是描述Dog.java,Cat,java这些东西的
具体的.java文件就是描述java.lang.Class这个类的一个具体的实例
类组成部分：
类属性 java.lang.reflect.Field (都是以java面向对象的思想对它进行封装了)
类方法 java.lang.reflect.Method
3.一切反射相关的代码都从获得java.lang.Class类对象开始
3.1 Class.forName(完整类名)
3.2 类名.class
3.3 对象.getClass()
4. 反射三大作用(java.lang.reflect.*)
4.1获取类对象的三种方式
代码演示：
创建一个Student类
package com.myy.reflect;
public class Student {
private String sid;
private String sname;
public Integer age;
static{
System.out.println("加载进jvm中！");
}
public Student() {
super();
System.out.println("调用无参构造方法创建了一个学生对象");
}
public Student(String sid) {
super();
this.sid = sid;
System.out.println("调用带一个参数的构造方法创建了一个学生对象");
}
public Student(String sid, String sname) {
super();
this.sid = sid;
this.sname = sname;
System.out.println("调用带二个参数的构造方法创建了一个学生对象");
}
@SuppressWarnings("unused")
private Student(Integer age) {
System.out.println("调用Student类私有的构造方法创建一个学生对象");
this.age = age;
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public void hello() {
System.out.println("你好！我是" + this.sname);
}
public void hello(String name) {
System.out.println(name + "你好！我是" + this.sname);
}
@SuppressWarnings("unused")
private Integer add(Integer a, Integer b) {
return new Integer(a.intValue() + b.intValue());
}
}
Demo1:
package com.myy.reflect;
/**
* 获取类对象的方式
* 通过java提供的反射机制获取到com.myy.reflect.Student.class
* 1.Class.forName("全路径名"); jdbc/自定义mvc框架调用
* 2.类名.class 结合泛型做通用分页查询方法会用
* 3.类java.lang.Class(实例的类)实例(Student.class)的类实例getClass()获取 通用的增删改结合泛型使用
*
* @author myy
*
*/
public class Demo1 {
public static void main(String[] args) throws Exception {
// 1.Class.forName("全路径名"); jdbc/自定义mvc框架调用
Class stuClz = Class.forName("com.myy.reflect.Student");
System.out.println("------------");
// 2.类名.class 结合泛型做通用分页查询方法会用
Class stuClz1 = Student.class;
System.out.println(stuClz1);
System.out.println("-------------");
Student stu = new Student();
// 3.类java.lang.Class(实例的类)实例(Student.class)的类实例getClass()获取 通用的增删改结合泛型使用
Class stuClz2 = stu.getClass();
System.out.println(stuClz2);//并且还调用了无参构造器
}
}
运行结果：
4.2反射实例化对象
代码演示：
Demo2:
package com.myy.reflect;
/**
* 利用反射进行对象的实例化
* 之前：通过new关键字进行实例化
* 现在：通过java.lang.reflect.construct来实例化对象
*
* @author myy
*
*/
public class Demo2 {
public static void main(String[] args) throws Exception, Exception {
Student stu = new Student();
Class stuClz = stu.getClass();
// newInstance这个方法默认是使用无参构造器去实例化对象
Student stu2 = (Student) stuClz.newInstance();
System.out.println(stu2);//如果不是空就意味着创建出来
}
}
运行结果：
提问：假设没有无参构造器运行会不会报错
代码演示：
首先，先把Student类的无参构造器注释掉
然后，修改一下Demo2的代码
public static void main(String[] args) throws Exception, Exception {
// Student stu = new Student();
// Class stuClz = stu.getClass();
Class stuClz = Student.class;
// newInstance这个方法默认是使用无参构造器去实例化对象
Student stu2 = (Student) stuClz.newInstance();
System.out.println(stu2);//如果不是空就意味着创建出来
}
如图所示运行会报错：
答：由上面代码演示我们得知当没有无参构造器的时候运行会报错。
运行报错的原因是：没有找到匹配方法，因为它默认找的是默认无参构造器。
注意：一定要提供无参构造器
优势：
- 能够对未知的对象进行实例化
- 能够对私有的构造器实例化对象
1.1代码演示：
public static void main(String[] args) throws Exception, Exception {
Class stuClz = Student.class;
// 调用有参构造器去实例化对象
Constructor<Student> constructor = stuClz.getConstructor(String.class);
Student stu2 = (Student)constructor.newInstance("张三");
}
运行结果：
1.2代码演示
public static void main(String[] args) throws Exception, Exception {
Class stuClz = Student.class;
// 调用有参构造器去实例化对象(两个参数的)
Constructor<Student> constructor = stuClz.getConstructor(String.class,String.class);
Student stu2 = (Student)constructor.newInstance("t003","张三");
}
运行结果：
2.1如果按照以上的操作进行代码演示
public static void main(String[] args) throws Exception, Exception {
Class stuClz = Student.class;
// 调用私有构造器去实例化对象
Constructor<Student> constructor = stuClz.getConstructor(Integer.class);
Student stu2 = (Student)constructor.newInstance(18);
}
运行结果：
getConstructor与getDeclaredConstructoe的区别
getConstructor只能获取被public修饰的构造器
getDeclaredConstructoe被所有关键字修饰的构造器
所以私有的要用getDeclaredConstructoe
如代码演示:
public static void main(String[] args) throws Exception, Exception {
Class stuClz = Student.class;
// 调用私有构造器去实例化对象
Constructor<Student> constructor = stuClz. stuClz.getDeclaredConstructor(Integer.class);
Student stu2 = (Student)constructor.newInstance(18);
}
运行结果：
Class com.myy.reflect.Demo2 can not access a member of class com.myy.reflect.Student with modifiers "private"
该错误原因是：找到了私有的构造器，但不能调用因为没有权限
则要对代码进行给予权限如代码演示：
public static void main(String[] args) throws Exception, Exception {
Class stuClz = Student.class;
// 调用私有构造器去实例化对象
Constructor<Student> constructor = stuClz. stuClz.getDeclaredConstructor(Integer.class);
constructor.setAccessible(true);//默认为false
Student stu2 = (Student)constructor.newInstance(18);
}
运行结果：
4.3 反射动态调用方法
Demo3:
无参的代码演示：
package com.myy.reflect;
import java.lang.reflect.Method;
/**
* 动态方法调用
* 构造方法是不是方法
*
* @author myy
*
*/
public class Demo3 {
public static void main(String[] args) throws Exception, SecurityException {
Student stu = new Student();
Class<? extends Student> stuClz = stu.getClass();//泛型里的上限定
//无参
Method m= stuClz.getDeclaredMethod("hello");
m.invoke(stu);
}
}
运行结果：
有参的代码演示：
public static void main(String[] args) throws Exception, SecurityException {
Student stu = new Student();
Class<? extends Student> stuClz = stu.getClass();//泛型里的上限定
//有参的
Method m= stuClz.getDeclaredMethod("hello", String.class);
m.invoke(stu, "张三");
}
运行结果：
私有的代码演示：
public static void main(String[] args) throws Exception, SecurityException {
Student stu = new Student();
Class<? extends Student> stuClz = stu.getClass();//泛型里的上限定
//私有的
Method m = stuClz.getDeclaredMethod("add", Integer.class,Integer.class);
m.setAccessible(true);
// Method.invoke的返回值是被动态调用的方法的返回值
Object invoke = m.invoke(stu, 11,9);
System.out.println(invoke);
}
运行结果：
4.4 反射读写属性
Demo4:
代码演示：
package com.myy.reflect;
import java.lang.reflect.Field;
/**
* 反射读写属性
* 自定义标签库，通用分页，自定义mvc也要用
* @author myy
*
*/
public class Demo4 {
public static void main(String[] args) throws Exception {
Student stu = new Student("t003","张三");
stu.age = 18;
System.out.println(stu.getSid());
System.out.println(stu.getSname());
Class<? extends Student> stuClz = stu.getClass();
//私有的
Field f = stuClz.getDeclaredField("sname");
f.setAccessible(true);
System.out.println(f.get(stu));
// 获取当前Student实例中的stu私有属性及其属性值
Field[] fields = stuClz.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
System.out.println(field.getName()+":"+field.get(stu));
}
}
}
运行结果：
5.访问修饰符
如何判断类或变量、方法的修饰符，可以使用Java反射机制中，Field的 getModifiers() 方法返回int类型值表示该字段的修饰符，
即这个方法就是返回一个int型的返回值，代表类、成员变量、方法的修饰符。
该修饰符是java.lang.reflect.Modifier的静态属性
对应表如下：
PUBLIC: 1
PRIVATE: 2
PROTECTED: 4
STATIC: 8
FINAL: 16
SYNCHRONIZED: 32
VOLATILE: 64
TRANSIENT: 128
NATIVE: 256
INTERFACE: 512
ABSTRACT: 1024
STRICT: 2048
Modifier提供了很多静态方法，对类和成员访问修饰符进行解码。
如代码演示：
package com.myy.reflect;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
/**
* Modifier.isAbstract(int mod)
* Modifier.isFinal(int mod)
* Modifier.isInterface(int mod)
* Modifier.isNative(int mod)
* Modifier.isPrivate(int mod)
* Modifier.isProtected(int mod)
* Modifier.isStatic(int mod)
* Modifier.isStrict(int mod)
* Modifier.isSynchronized(int mod)
* Modifier.isTransient(int mod)
* Modifier.isVolatile(int mod)
*
* @author myy
*
*/
public class Demo5 {
public static void main(String[] args) {
Field[] fileds = Student.class.getDeclaredFields();
for (Field field : fileds) {
System.out.println(field.getName()+" 访问修饰符是否包括private:"+Modifier.isPrivate(field.getModifiers()));
System.out.println(field.getName()+" 访问修饰符是否包括static:"+Modifier.isStatic(field.getModifiers()));
System.out.println(field.getName()+" 访问修饰符是否包括public:"+Modifier.isPublic(field.getModifiers()));
}
}
}
运行结果：