反射
反射:通过Class获取字节码文件对象，使用字节码文件对象来获取类的一些描述信息
Class: 对Class文件的一种描述
通过反射获取哪些东西?
- 字节码文件对象
- 构造方法 创建对象
- 成员变量 设置和获取值
- 成员方法 调用方法
- 数组 动态创建和 设置获取元素
- 获取注解并且 判断注解的存在性 解析注解//暂时不做介绍
反射获取字节码文件
获取字节码文件对象的方式有三种
1.Object的getClass方法
2.通过数据类型的静态属性 class属性
- 如果形参需要我们传入Class类型，那么我们可以考虑使用方式二
- public void show(Class c){}
- show(int.class)
3.Class类中一个静态方法
- static Class<?> forName(String className)
- 方式三的好处: 因为传入的是一个字符串，而这个字符串可以通过配置文件配置
- 满足了设计原则: 开闭原则 对扩展开放,对修改关闭
- 配置文件: xml文件, properties文件
public class ReflectDemo01 {
public static void main(String[] args) throws ClassNotFoundException, FileNotFoundException, IOException {
Student s1 = new Student();
Student s2 = new Student();
Class<?> c1 = s1.getClass();
Class<?> c2 = s2.getClass();
System.out.println(s1 == s2); //false
System.out.println(c1 == c2); //true
Class<?> c3 = Student.class;
System.out.println(c1 == c3); //true
//因为当我们执行java.exe命令,这个字节码文件会被加载到内存当中，同时还会为这个字节码文件创建一个Class的实例，所以在我们创建对象的时候，在堆区中其实就已经存在Student类的字节码文件对象了，当我们新创建一个自定义的Student类，会在堆区中分配一个新地址给它，所以s1不等于s2，换句话来说，我们其实是通过类加载机制的字节码文件对象来创建对象的，通过反射获取到的字节码文件对象是同一个对象，而且地址是相等的。
Properties pro = new Properties();//属性集里面为className=com.reflect.Student
pro.load(new FileReader("prop.txt"));
String value = pro.getProperty("ClassName");
System.out.println(value); //com.reflect.Teacher
Class<?> c4 = Class.forName(value);
System.out.println(c4); //class com.reflect.Teacher
System.out.println(c1 == c4); //true
}
}
public class Student {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
反射获取构造方法对象并且创建对象
- 通过反射获取字节码文件对象
- 通过字节码文件对象获取构造方法对象 Constructor
- 通过反射获取构造方法对象并且创建对象
以下有四种获取构造方法的方法
- Constructor<?>[] getConstructors() // 获取公有修饰的构造方法的对象，注意为数组对象
- Constructor<?>[] getDeclaredConstructors() // 获取所有的构造方法对象，数组对象
- Constructor getConstructor(Class<?>… parameterTypes) //获取指定公有修饰的构造方法对象
- Constructor getDeclaredConstructor(Class<?>… parameterTypes) //获取指定任意修饰的构造方法对象
代码演示获取字节码对象和构造方法对象
public class ReflectDemo01 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
Class<?> c = Class.forName("com.sxt.reflectdemo2.Student");
Constructor<?>[] constructors = c.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor);
}
System.out.println("----------------------------------");
Constructor<?>[] declaredConstructors = c.getDeclaredConstructors();
for (Constructor<?> constructor : declaredConstructors) {
System.out.println(constructor);
}
System.out.println("----------------------------------");
// 获取所有的构造方法在开发中有意义? 没有什么实际意义，所以我们来获取单个构造方法
// 获取无参构造方法
// c.getConstructor(Class<?>... parameterTypes Class class)
Constructor<?> constructor = c.getConstructor();
System.out.println(constructor);
Constructor<?> constructor2 = c.getConstructor(String.class,int.class);
System.out.println(constructor2);
// 获取私有构造方法
// java.lang.NoSuchMethodException
// Constructor<?> constructor3 = c.getConstructor(String.class);
// System.out.println(constructor3);
Constructor<?> constructor3 = c.getDeclaredConstructor(String.class);
System.out.println(constructor3);
}
}
通过反射获取构造方法对象并且创建对象
反射之前的做法:
Student s = new Student();
反射之后:
1.获取字节码文件对象
2.通过字节码文件对象获取构造方法对象
3.通过构造方法对象创建对象
T newInstance(Object… initargs)
代码演示
public class ReflectDemo02 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException,InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException,FileNotFoundException, IOException {
Properties prop = new Properties();
prop.load(new FileReader("prop.txt"));
String value = prop.getProperty("ClassName");
Class<?> c = Class.forName(value);
Constructor<?> con = c.getConstructor();
Object obj = con.newInstance();
System.out.println(obj);
Student student = (Student) obj;
System.out.println(student.getName());
// 我想要调用带全参数的怎么办
Constructor<?> constructor = c.getConstructor(String.class, int.class);
Object obj2 = constructor.newInstance("Java练习生", 50);
System.out.println(obj2);
// 我想获取私有构造方法并且造对象
// java.lang.NoSuchMethodException:
// Constructor<?> constructor2 = c.getConstructor(String.class);
Constructor<?> constructor2 = c.getDeclaredConstructor(String.class);
// java.lang.IllegalAccessException
constructor2.setAccessible(true); //获取访问权，暴力访问
Object obj3 = constructor2.newInstance("Java两年半实习生");
System.out.println(obj3);
}
}
通过反射获取成员变量对象
以下有四种获取成员变量的方法：
-
Field[] getFields() 获取公有修饰的成员变量对象
-
Field[] getDeclaredFields() 获取所有成员变量对象
-
Field getField(String name) 获取指定的公共成员变量对象
-
Field getDeclaredField(String name) 获取指定任意成员变量对象
有一种方法可得到 返回指定对象上此 Field 表示的字段的值
Object get(Object obj) 返回指定对象上此 Field 表示的字段的值。
代码演示获取方法
public class ReflectDemo01 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
Class<?> c = Class.forName("com.sxt.reflectdemo3.Student");
Field[] fields = c.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("---------------");
Field[] declaredFields = c.getDeclaredFields();
for (Field field : declaredFields) {
System.out.println(field);
}
System.out.println("---------------");
// declaredFields
Field field = c.getField("address");
System.out.println(field);
System.out.println("---------------");
Field field2 = c.getDeclaredField("name");
System.out.println(field2);
}
}
代码演示创造对象并赋值
public class ReflectDemo02 {
public static void main(String[] args) throws Exception {
Class<?> c = Class.forName("com.sxt.reflectdemo3.Student");
// 给sex属性赋值，值为女
Field sexFiled = c.getDeclaredField("sex");
System.out.println(sexFiled);
// 反射之前 Student s = new Student(); s.sex = "女";
// 反射之后
Constructor<?> con = c.getDeclaredConstructor();
Object obj = con.newInstance();
// Object get(Object obj) 返回指定对象上此 Field 表示的字段的值。
sexFiled.set(obj, "女");
System.out.println(obj); //结果为 Student [name=null, sex=女, number=null]
Field nameField = c.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(obj, "Java练习生");
System.out.println(obj); //结果为Student [name=Java练习生, sex=女, number=null]
System.out.println(nameField.get(obj)); //结果为 Java练习生
}
}
通过反射获取成员方法对象并且调用
c.getMethods() 获取所有公有方法 包括父类继承过来的成员
c.getDeclaredMethods() 获取本类中所有方法，包括私有
Method getMethod(String name, Class<?>… parameterTypes)
Method getDeclaredMethod(String name, Class<?>… parameterTypes)
第一个参数是方法名称, 第二个参数是参数类型列表
Object invoke(Object obj, Object… args)
使用反射书写一个能够给任意对象设置任意的值的方法
代码演示
public class ReflectDemo01 {
public static void main(String[] args) throws Exception {
Class<?> c = Class.forName("com.sxt.reflectdemo4.Student");
Constructor<?> con = c.getDeclaredConstructor();
Object obj = con.newInstance();
Method[] methods = c.getMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("--------------------------");
Method[] declaredMethods = c.getDeclaredMethods();
for (Method method : declaredMethods) {
System.out.println(method);
}
System.out.println("--------------------------");
// 获取无参方法show并且调用
Method method = c.getDeclaredMethod("show");
System.out.println(method);
method.invoke(obj);
System.out.println("--------------------------");
// public void method(String s)
Method method2 = c.getDeclaredMethod("method", String.class);
System.out.println(method2);
method2.invoke(obj, "Hello");
System.out.println("--------------------------");
// public String concat(int a, String s, double d)
Method method3 = c.getDeclaredMethod("concat", int.class, String.class, double.class);
System.out.println(method3);
Object result = method3.invoke(obj, 20, "张三", 2.5);
System.out.println(result);
System.out.println("--------------------------");
//private void show2()
Method method4 = c.getDeclaredMethod("show2");
method4.setAccessible(true);
System.out.println(method4);
method4.invoke(obj);
// int getModifiers() 返回值类型为int的原因是可以查看源码，源码给每个访问权限修饰符都设置了一个特定的int值，比如private为2
int modifiers = method4.getModifiers();
System.out.println(modifiers);
}
}
public class Student {
private String name;
int age;
public String address;
protected String sex;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
private Student(String name) {
this.name = name;
}
protected Student(String name,String address) {
this.address = address;
this.name = name;
}
Student(int age){
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", address=" + address + ", sex=" + sex + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public void show() {
System.out.println("我是无参show方法");
}
public void method(String s) {
System.out.println("我是带Sting参数的method方法:" + s);
}
public String concat(int a, String s, double d) {
return a + s + d;
}
private void show2() {
System.out.println("我是私有方法");
}
}
通过反射创建数组 并且给数组设置和获取元素
Array,而不是Arrays工具链
static Object newInstance(Class<?> componentType, int length)
创建一个具有指定的组件类型和长度的新数组。
第一个参数表示你需要创建什么类型的数组
第二个参数表示这个数组的元素大小
代码演示
public class ReflectDemo01 {
public static void main(String[] args) {
Object obj = Array.newInstance(String.class, 3);
System.out.println(obj);
// 通过反射获取元素
Object element = Array.get(obj, 0);
System.out.println(element);
element = Array.get(obj, 0);
System.out.println(element);
element = Array.get(obj, 0);
System.out.println(element);
// 通过反射给数组添加元素
Array.set(obj, 0, "张三");
Array.set(obj, 1, "李四");
Array.set(obj, 2, "王五");
String[] strs = (String[])obj;
for (String s : strs) {
System.out.println(s);
}
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
