Java基础加强01-反射2
1、反射的概念
反射是框架设计的灵魂。
框架：半成品软件。可以在框架的基础上进行软件开发，简化编码。
使用框架并不需要使用反射。但是写框架的时候是需要反射的。
将类的各个组成部分封装为其他对象，这就是反射。
2、Java代码在计算机中经历的阶段：三个阶段
第一阶段：Source源代码阶段
Person.java
public class Person{
private String name;
private int age;
public Person(){}
public void eat(){}
}
编译：javac 编译，编译完生成Person.class字节码文件
Person.class中包含三部分：
a. private String name;
private int age;
b. public Person(){}
c. public void eat(){}
第二阶段：Class类对象阶段。
类加载器ClassLoader，可以把Person.class加载到内存中，加载到内存后有对应的Class类对象
成员变量，封装为Field对象。会有多个成员变量，用Field[] fields；
构造方法，封装为Constructor对象。可能有多个构造方法，用Constructor[] cons；
成员方法，封装为Method对象。有多个成员方法，用Method[] methods。
将来可以通过Class类对象的行为来创建真正的Person等对象。
第三阶段：Runtime运行时阶段。
Person对象
new Person();
3、反射的好处
a. 可以在程序运行过程中，操作这些对象。
b. 可以解耦，提高程序的可扩展性。
4、获取Class类对象的方式
- 将字节码文件加载进内存，返回Class对象。
多用于配置文件，将类名定义在配置文件中。读取文件，加载类。
Java代码在第一个阶段，也就是只有.class字节码文件并没有进内存。需要手动将.class加载进内存，通过
Class.forName("全类名");
- 已经加载进内存了，可通过类名的属性class获取Class对象。
多用于参数的传递。
类名.class
- 已经有对象了，通过getClass()方法（在Object类中定义着）获取Class对象。
多用于对象的获取字节码的方式。
对象.getClass()
package com.itheima.day01.reflect; public class Person { private String name; private int age; //快速创建构造方法及getter\setter\toString()，Alt+Insert public Person() { } public Person(String name, int age) { 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 "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } }
package com.itheima.day01.reflect; public class ReflectDemo1 { /** 获取Class对象的方式： 1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象 2. 类名.class：通过类名的属性class获取 3. 对象.getClass()：getClass()方法在Object类中定义着。 */ public static void main(String[] args) throws ClassNotFoundException { //Person.java保存后自动编译为Person.class //1. Class.forName("全类名") Class cls1 = Class.forName("com.itheima.day01.reflect.Person"); System.out.println(cls1);//class com.itheima.day01.reflect.Person // 2. 类名.class Class cls2 = Person.class; System.out.println(cls2);//class com.itheima.day01.reflect.Person //3. 对象.getClass() Person p = new Person(); Class cls3 = p.getClass(); System.out.println(cls3);//class com.itheima.day01.reflect.Person //==比较三个对象 System.out.println(cls1== cls2);//true System.out.println(cls1==cls3);//true } }
结论：同一个字节码文件（*.class）在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。
5、Class对象功能
- 获取成员变量们
Field[] getFields()：获取所有公共的成员变量
Field getField(String name)：获取指定名称的公共成员变量
Field[] getDeclaredFields()：获取所有的成员变量
Field getDeclaredField(String name)：获取单个成员变量
- 获取构造方法们
Constructor<?>[] getConstructors()：获取所有公共的构造方法
Constructor<T> getConstructor(类<?>... parameterTypes)：获取指定的公共构造方法
Constructor<?>[] getDeclaredConstructors()：获取所有的构造方法
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)：获取单个构造方法
- 获取成员方法们
Method[] getMethods()：获取所有的公共成员方法，包括Object的方法
Method getMethod(String name, 类<?>... parameterTypes)：获取指定名称的公共成员方法
Method[] getDeclaredMethods()：获取所有的成员方法
Method getDeclaredMethod(String name, 类<?>... parameterTypes)：获取单个成员方法
- 获取类名
String getName()：获取类名
String getPackage()：获取此类的包
6、使用Class对象功能
- Field：成员变量
操作：
1、设置值：void set(Object obj, Object value)
2、获取值：Object get(Object obj)
3、忽略访问权限修饰符的安全检查：setAccessible(true)暴力反射
package com.itheima.day01.reflect; public class Person { private String name; private int age; public String a; protected String b; String c; private String d; public Person() { } public Person(String name, int age) { 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 "Person{" + "name='" + name + '\'' + ", age=" + age + ", a='" + a + '\'' + ", b='" + b + '\'' + ", c='" + c + '\'' + ", d='" + d + '\'' + '}'; } }
package com.itheima.day01.reflect; import java.lang.reflect.Field; public class ReflectDemo2 { public static void main(String[] args) throws Exception { //0.获取Person的Class对象 Class personClass = Person.class; Field[] fields= personClass.getFields(); for(Field field: fields){ //public java.lang.String com.itheima.day01.reflect.Person.a System.out.println(field); } System.out.println("-------------"); Field a= personClass.getField("a"); //获取成员变量a的值 Person p = new Person(); Object value = a.get(p); System.out.println(value);//null a.set(p,"abc"); System.out.println(p);//Person{name='null', age=0, a='abc', b='null', c='null', d='null'} System.out.println("=================="); Field[] declaredFields = personClass.getDeclaredFields(); for(Field field: declaredFields){ // private java.lang.String com.itheima.day01.reflect.Person.name // private int com.itheima.day01.reflect.Person.age // public java.lang.String com.itheima.day01.reflect.Person.a // protected java.lang.String com.itheima.day01.reflect.Person.b // java.lang.String com.itheima.day01.reflect.Person.c // private java.lang.String com.itheima.day01.reflect.Person.d System.out.println(field); } Field d = personClass.getDeclaredField("d"); //忽略访问权限修饰符的安全检查 d.setAccessible(true);//暴力反射 Object value2 = d.get(p); System.out.println(value2);//null } }
- Constructor：构造方法
构造方法用来创建对象
1、创建对象：T newInstance(Object... initargs)
2、如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance()方法
3、忽略访问权限修饰符的安全检查：setAccessible(true)暴力反射
package com.itheima.day01.reflect; import java.lang.reflect.Constructor; public class ReflectDemo3 { public static void main(String[] args) throws Exception { //0.获取Person的Class对象 Class personClass = Person.class; Constructor[] constructors = personClass.getConstructors(); for(Constructor constructor:constructors){ // public com.itheima.day01.reflect.Person() // public com.itheima.day01.reflect.Person(java.lang.String,int) System.out.println(constructor); } Constructor constructor = personClass.getConstructor(String.class,int.class); //public com.itheima.day01.reflect.Person(java.lang.String,int) System.out.println(constructor); //创建对象 Object person = constructor.newInstance("ab",23); //Person{name='ab', age=23, a='null', b='null', c='null', d='null'} System.out.println(person); System.out.println("-----------------"); Constructor constructor1 = personClass.getConstructor(); //public com.itheima.day01.reflect.Person() System.out.println(constructor1); //创建对象 Object person1 = constructor1.newInstance(); //Person{name='null', age=0, a='null', b='null', c='null', d='null'} System.out.println(person1); //如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法 Object person2 = personClass.newInstance(); //Person{name='null', age=0, a='null', b='null', c='null', d='null'} System.out.println(person2); constructor.setAccessible(true); } }
- Method：成员方法
操作：
1、执行方法：Object invoke(Object obj, Object... args)
2、忽略访问权限修饰符的安全检查：setAccessible(true)暴力反射
3、获取方法名称：String getName()
4、获取该方法的参数类型：Class getParameterTypes()
package com.itheima.day01.reflect; public class Person { private String name; private int age; public String a; protected String b; String c; private String d; //快速创建构造方法及getter\setter\toString()，Alt+Insert public Person() { } public Person(String name, int age) { 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 "Person{" + "name='" + name + '\'' + ", age=" + age + ", a='" + a + '\'' + ", b='" + b + '\'' + ", c='" + c + '\'' + ", d='" + d + '\'' + '}'; } public void eat(){ System.out.println("eat..."); } public void eat(String food){ System.out.println("eat..."+ food); } }
package com.itheima.day01.reflect; import java.lang.reflect.Method; public class ReflectDemo4 { public static void main(String[] args) throws Exception { Class personClass = Person.class; //获取指定名称的成员方法 Method eatMethod =personClass.getMethod("eat"); Person p = new Person(); //执行方法 eatMethod.invoke(p);//输出：eat... Method eatMethod1 =personClass.getMethod("eat",String.class); eatMethod1.invoke(p,"chifan"); //输出：eat...chifan
Class<?>[] parameterTypes = eatMethod1.getParameterTypes();
for(Class parameterType : parameterTypes){
System.out.println(parameterType);//class java.lang.String
System.out.println(parameterType.getName());//java.lang.String
}
System.out.println("------------"); //获取所有public修饰的方法 Method[] methods = personClass.getMethods(); for(Method method:methods){ // public java.lang.String com.itheima.day01.reflect.Person.toString() // public java.lang.String com.itheima.day01.reflect.Person.getName() // public void com.itheima.day01.reflect.Person.setName(java.lang.String) // public void com.itheima.day01.reflect.Person.eat() // public void com.itheima.day01.reflect.Person.eat(java.lang.String) // public int com.itheima.day01.reflect.Person.getAge() // public void com.itheima.day01.reflect.Person.setAge(int) // public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException // public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException // public final void java.lang.Object.wait() throws java.lang.InterruptedException // public boolean java.lang.Object.equals(java.lang.Object) // public native int java.lang.Object.hashCode() // public final native java.lang.Class java.lang.Object.getClass() // public final native void java.lang.Object.notify() // public final native void java.lang.Object.notifyAll() System.out.println(method); String name = method.getName(); // toString // getName // setName // getAge // setAge // eat // eat // wait // wait // wait // equals // hashCode // getClass // notify // notifyAll System.out.println(name); method.setAccessible(true); } //获取类名 String className = personClass.getName(); System.out.println(className); //输出：com.itheima.day01.reflect.Person System.out.println(personClass.getPackage()); //输出：package com.itheima.day01.reflect } }
7、案例
写一个“框架”，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
实现：
a. 配置文件
b. 反射
步骤：
a. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
b.在程序中加载读取配置文件
c. 使用反射技术来加载文件进内存
d. 创建对象
e. 执行方法
src下创建一个pro.properties配置文件
package com.itheima.day01.reflect; import java.io.InputStream; import java.lang.reflect.Method; import java.util.Properties; /** * 框架类 */ public class ReflectTest { public static void main(String[] args) throws Exception { //1.加载配置文件 //1.1 创建Properties对象 Properties pro = new Properties(); //1.2 加载配置文件，转换为一个集合(Properties是一个Map集合类) //1.3 获取class目录下的配置文件 ClassLoader classLoader= ReflectTest.class.getClassLoader();//获取ReflectTest.class文件的类加载器
System.out.println(classLoader); //jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc InputStream is = classLoader.getResourceAsStream("pro.properties");//从classpath的根路径下查找pro.properties文件 pro.load(is); //2.获取配置文件中定义的数据 String className = pro.getProperty("className"); String methodName = pro.getProperty("methodName"); //3. 加载该类进内存 Class cls = Class.forName(className); //4. 创建对象 Object obj = cls.newInstance(); //5. 获取方法对象 Method method = cls.getMethod(methodName); //6. 执行方法 method.invoke(obj);//Person类的eat方法被执行，输出：eat... //不改变此类的任何方法，只需要改pro.properties配置文件即可 //系统庞大，改Java代码需要重新测试编译上线，改配置文件改完就可以了，扩展性更强 } }
8、总结与补充
- JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
- 因为所有类都继承Object类。从而调用Object类来获取class字节码对象。
三种方式常用第三种，第一种对象都有了还要反射干什么。第二种需要导入类的包，依赖太强，不导包就抛编译错误。一般都第三种，一个字符串可以传入也可写在配置文件中等多种方法。
- 构造器可以提供许多特殊的方法，构造器作为一种方法，负责类中成员变量（域）的初始化。实例构造器分为缺省构造器和非缺省构造器。
构造器最大的用处就是在创建对象时执行初始化，当创建一个对象时，系统会为这个对象的实例进行默认的初始化。如果想改变这种默认的初始化，就可以通过自定义构造器来实现。
