2021年02月22日java基础第二十六课---反射
java基础第二十六课---反射
类的生命周期
反射：框架的灵魂
*框架：半成品软件。在框架的基础上进行开发，可以简化我们的编码。
我们在后期使用框架的时候即使不会反射也没有关系，但是当我们有一天需要自己去设计框架，那么反射就需要我们深入的理解和掌握反射的原理
*反射：将类的各个组成部分封装成其他对象，这就是反射机制
好处：
1.在程序的运行过程中，来操作这些对象
String str = "123";
str.
- 1
- 2
我们对出很多的方法，这其实就是内部就是使用的是反射机制，你定义了一个字符串，那么他会把字符串的字节码文件加载进内存，在内存当中有一个class类对象，class对象已将所有的方法都抽取出来封装在method[]数组当中，所以我们能够出这么多的程序。
2.可以解耦，提高程序的可扩转性
一、获取class对象的方式
1.Class.forName(“全类名”)：将字节码文件加载进内存，返回class对象
多用于配置文件，将类名定义在配置文件当中，读取文件，加载类
2.类名.class:通过类名的class获取
多用于参数的传递
3.对象.getClass():getClass()方法在object类当中定义着
多用于对象获取字节码的方式
首先定义一个person类,内部定义好成员变量，构造方法和成员方法
public class Person {
private String nameString;
private int age;
public Person() {
}
public Person(String nameString, int age) {
this.nameString = nameString;
this.age = age;
}
public String getNameString() {
return nameString;
}
public void setNameString(String nameString) {
this.nameString = nameString;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [nameString=" + nameString + ", age=" + age + "]";
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
定义测试类
public class refulectDemo1 {
/**
* 1.Class.forName("全类名")：将字节码文件加载进内存，返回class对象
2.类名.class:通过类名的class获取
3.对象.getClass(): getClass()方法在object类当中定义着
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws Exception {
// 1.Class.forName("全类名")：
Class class1 = Class.forName("reflect.Person");
System.out.println(class1);
//2.类名.class:通过类名的class获取
Class class2 = Person.class;
System.out.println(class2);
//3.对象.getClass()
Person person = new Person();
Class class3 = person.getClass();
System.out.println(class3);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
用 == 进行比较
System.out.println(class1 == class2);
System.out.println(class2 == class3);
- 1
- 2
输出为：
true
true
- 1
- 2
class对象功能
获取功能
1.获取成员变量们
1.Field[] getFields() ：获取所有public修饰的成员变量
2.Field getField(String name)：获取指定名称的
3.Field[] getDeclaredFilds()：获取所有的成员变量，不考虑修饰符
4.Field getDeclaredField(String name)
- 1
- 2
- 3
- 4
2.获取构造方法们
1.Constructor<?>[] getConstructors()
2.Constructor<T> getConstructor(类<?>...parameterTypes)
3.Constructor<?>[] getDeclaredConstructors()
4.Constructor<T> getDeclaredConstructors(类<?>...parameterTypes)
- 1
- 2
- 3
- 4
3.获取方法名
1.Method[] getMethod()
2.Method getMethod(String name,类<?>... parameterTypes)
3.Method[] getDeclaredMethod()
4.Method getDeclaredMethod(String name,类<?>... parameterTypes)
- 1
- 2
- 3
- 4
Field成员变量
操作
1.设置值
void set(Object obj,Object value)
- 1
2.获取值
get(Object obj)
- 1
3.忽略安全访问修饰符的安全检查
setAccessible(true) //暴力反射 ---》private
- 1
代码
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personClass = Person.class;
/*
1. 获取成员变量们
* Field[] getFields()
* Field getField(String name)
* Field[] getDeclaredFields()
* Field getDeclaredField(String name)
*/
//1.Field[] getFields()获取所有public修饰的成员变量
Field[] fields = personClass.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("------------");
//2.Field getField(String name)
Field a = personClass.getField("a");
//获取成员变量a 的值
Person p = new Person();
Object value = a.get(p);
System.out.println(value);
//设置a的值
a.set(p,"张三");
System.out.println(p);
System.out.println("===================");
//Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
Field[] declaredFields = personClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
//Field getDeclaredField(String name)
Field d = personClass.getDeclaredField("d");
//忽略访问权限修饰符的安全检查
d.setAccessible(true);//暴力反射
Object value2 = d.get(p);
System.out.println(value2);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
Constructor访问构造方法
*创建对象
*T newInstance(Object… initarges)
*如果使用空参数构造方法，此操作可以简化：class对象的newInstance方法
public static void main(String[] args) throws Exception {
//0.获取Person的class对象
Class personClass = Person.class;
//因为构造器的方法名称是相同的，不同的是参数列表，所以我们可以根据不同的参数列表来找到构造器
Constructor constructor = personClass.getConstructor(String.class,int.class);
System.out.println(constructor);
//创建对象
Object perObject = constructor.newInstance("张三",20);
System.out.println(perObject);
System.out.println("-------------------------------");
Constructor constructor1 = personClass.getConstructor();
System.out.println(constructor1);
//创建对象
Object perObject1 = constructor1.newInstance();
System.out.println(perObject1);
System.out.println("-------------------------------");
Object o = personClass.newInstance();
System.out.println(o);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
Method:方法对象
*执行方法
*object invoke(Object object,Object… ages)
*获取方法名称
*String getName:获取方法名
public static void main(String[] args) throws Exception {
//0.获取Person的class对象
Class personClass = Person.class;
//获取指定名称的方法,方法无参
Method eat_method = personClass.getMethod("eat");
//执行方法
Person person =new Person();
eat_method.invoke(person);
//获取指定名称的方法，方法有参
Method eat_method1 = personClass.getMethod("eat",String.class);
//执行方法
eat_method1.invoke(person,"饭");
//获取所有public修饰的方法
Method[] methods = personClass.getMethods();
for (Method method : methods) {
System.out.println(method);
//获取方法的名称
String name = method.getName();
System.out.println(name);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
作业一
作业：给定一个java bean，获取该类的构造方法来构造对象，获取该类的名称和该类中每一个方法的变量方法的名称，并执行get方法。给每一个变量赋值，并获取值，执行每一个构造方法执行相应的方法
什么是java Bean
//java bean是java类的一种特殊格式，java bean要求
1.该类下所有的成员变量都是私有的
//2…每一个私有的变量都有一对方法对他进行操作，分别是get()和set()方法
3.在set方法当中有一个给成员变量赋值的方法
java Bean
public class Student {
private String name;
private int age;
private String address;
public Student(String name,int age,String address) {
this.address = address;
this.age = age;
this.name = name;
}
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;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
反射代码
public class CommonReflect {
//获取该类的类型
public static void getClassName(Object object) {
String className = object.getClass().getSimpleName();
System.out.println("类的名字是："+className);
}
//获取类的变量名称
public static void getField(Object object) {
Field[] fields = object.getClass().getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
System.out.println("成员变量的名称为："+fields[i].getName());
}
}
//获取类的成员方法
public static void getMethod(Object object) {
Method[] methods = object.getClass().getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
System.out.println("成员方法的名称："+methods[i].getName());
}
}
//调用该类的成员方法，以get为例
public static void getAction(Object object) throws Exception {
//获取到有多少get方法
Field[] fields = object.getClass().getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
String fieldName = fields[i].getName();
String fistfont = fieldName.substring(0,1).toUpperCase();
String methodname = "get"+fistfont+fieldName.substring(1);
Method method = object.getClass().getMethod(methodname);
System.out.println("get的输出结果："+method.invoke(object));
}
}
public static void main(String[] args) throws Exception {
Object studentObject = Student.class.getConstructor(String.class,int.class,String.class