XML 反射
1. 什么是反射
反射java语言中的一种机制,通过这种机制可以动态的实例化对象、读写属性、调用方法
2. 类类
所有狗 狗类 Dog 狗对象 旺财
所有猫 猫类 Cat 猫对象 肥波
所有类 类类 java.lang.Class 类对象 特定类
包含的类:
java.lang.Class
java.lang.reflect.Method
java.lang.reflect.Field
java.lang.reflect.construct
Student.java:
package com.qiuwenfan.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());
}
}
Teacher.java
xxx.java
java.lang.Class
类
类属性 java.lang.reflect.Field
类方法 java.lang.reflect.Method
获取类对象的三种方式:
通过Java提供的反射机制获取到com.qiuwenfan.reflect.Student.class
- Class.forName(“全路径名”); jdbc/自定义mvc框架要用
- 类名.class 结合泛型做通用分页查询方法会用
- 类java.lang.Class实例(Student.class)的类实例(name)的getClass()获取
通用的增删改结合泛型使用
代码演示:
package com.qiuwenfan.reflect;
/**
* 获取对象的方式
* 通过Java提供的反射机制获取到com.qiuwenfan.reflect.Student.class
* 1、Class.forName("全路径名"); jdbc/自定义mvc框架要用
* 2、类名.class 结合泛型做通用分页查询方法会用
* 3、类java.lang.Class实例(Student.class)的类实例(name)的getClass()获取 通用的增删改结合泛型使用
*
* @author qiuwenfan
*
*/
public class Demo1 {
public static void main(String[] args) throws Exception {
// 1、Class.forName("全路径名"); jdbc/自定义mvc框架要用
// Class stuClz = Class.forName("com.qiuwenfan.reflect.Student");
// 2、类名.class 结合泛型做通用分页查询方法会用
// Class stuClz = Student.class;
// System.out.println(stuClz);
Student stu = new Student();
// 3、类java.lang.Class实例(Student.class)的类实例(name)的getClass()获取
Class stuClz = stu.getClass();
System.out.println(stuClz);
}
}
图片结果:
3. 一切反射相关的代码都从获得java.lang.Class类对象开始
3.1 Class.forName(完整类名)
3.2 类名.class
3.3 对象.getClass()
注1:ClassNotFoundException(类名错|少jar包)
注2:同一类的、类对象只会创建一个
4. 反射三大作用(java.lang.reflect.*)
4.1 实例化对象
c.newInstance()
Constructor.getConstructor/Constructor.getDeclaredConstructor
注:一定要提供无参构造器
代码演示:
package com.qiuwenfan.reflect;
import java.lang.reflect.Constructor;
/**
* 利用反射进行对象实例化
* 以前:通过new关键字进行实例化
* 现在:
* 通过java.lang.reflect.construct来实例化对象
*
* 优势:
* 1、能够对未知的对象进行实例化
* 2、能够对私有构造器实例化对象
*
* @author qiuwenfan
*
*/
public class Demo2 {
public static void main(String[] args) throws Exception {
// Student stu = new Student();
// Class stuClz = stu.getClass();
Class stuClz = Student.class;
// newInstance这个方法默认是使用无参构造器去实例化对象
// Student stu2 = (Student) stuClz.newInstance();
// System.out.println(stu2);
// 调用有参构造器去实例化对象
// Constructor<Student> constructor = stuClz.getConstructor(String.class);
// Student stu2 = (Student) constructor.newInstance("zs");
// 调用带二个参数的构造器
// Constructor<Student> constructor = stuClz.getConstructor(String.class,String.class);
// Student stu2 = (Student) constructor.newInstance("s002","zs");
// 调用私有构造器去实例化对象
// java.lang.NoSuchMethodException(未找到匹配的方法)
// getConstructor与getDeclaredConstructor的区别(getConstructor只能获取被public修饰的构造器,getDeclaredConstructor被所有关键字修饰的构造器)
// Class com.qiuwenfan.reflect.Demo2 can not access a member of class com.qiuwenfan.reflect.Student with modifiers "private"
Constructor<Student> constructor = stuClz.getDeclaredConstructor(Integer.class);
constructor.setAccessible(true);
Student stu2 = (Student) constructor.newInstance(23);
}
}
图片结果(注释无参的构造方法):
图片结果(调用无参的构造方法):
图片结果(调用一个有参构造器去实例化):
图片结果(调用两个有参构造器去实例化):
图片结果(调用私有构造器去实例化对象);
4.2 动态调用方法
Method m;
m.invoke
代码演示:
package com.qiuwenfan.reflect;
import java.lang.reflect.Method;
/**
* 动态方法调用
* 构造方法是不是方法?
* @author qiuwenfan
*
*/
public class Demo3 {
public static void main(String[] args) throws Exception {
Student stu = new Student();
Class stuClz = stu.getClass();
// hello()无参的构造方法
// Method m = stuClz.getDeclaredMethod("hello");
// m.invoke(stu);
// hello()有参的构造方法
// Method m = stuClz.getDeclaredMethod("hello", String.class);
// m.invoke(stu, "zs");
// add()方法
Method m = stuClz.getDeclaredMethod("add", Integer.class,Integer.class);
// 给予权限
m.setAccessible(true);
// Method.invoke的返回值是被动态调用的方法的返回值
Object invoke = m.invoke(stu, 20, 2);
System.out.println(invoke);
}
}
图片结果(调用hello()无参的构造方法):
图片结果(调用hello()有参的构造方法):
图片结果(调用add()有参的构造方法):
4.3 读写属性
Field set/get
代码演示:
package com.qiuwenfan.reflect;
import java.lang.reflect.Field;
/**
* 反射读写属性
* 自定义标签库、通用分页、自定义mvc
*
* @author qiuwenfan
*
*/
public class Demo4 {
public static void main(String[] args) throws Exception {
Student stu = new Student("s001","zs");
stu.age = 22;
System.out.println(stu.getSid());
System.out.println(stu.getSname());
Class<? extends Student> stuClz = stu.getClass();
System.out.println("------分割线------");
Field f = stuClz.getDeclaredField("sname");
f.setAccessible(true);
System.out.println("sname="+f.get(stu));
Field f1 = stuClz.getDeclaredField("age");
f1.setAccessible(true);
System.out.println("age="+f1.get(stu));
System.out.println("------分割线------");
// 获取当前Student实例化中的stu所有属性及其属性值
Field[] fields = stuClz.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
System.out.println(field.getName()+":"+field.get(stu));
}
}
}
图片结果:
5. 访问修饰符
getModifiers()
java:
private 1
protected 2
public 4
static 8
final abstract…
怎么判定属性或方法被那些修饰符所修饰呢?
getModifiers
3 private protected
5