目录
1 反射的概念
反射是java提供的一个重要功能,可以在运行时检查类、接口、方法和变量等信息,无需知道类的名字,方法名等。还可以在运行时实例化新对象,调用方法以及设置和获取变量值。
反射的好处:
(1)反射实现了:“在运行时才知道要操作的类是什么”,并且可以在运行时获取类的完整构造,以及调用方法。
(2)解耦,提高程序的可扩展性
程序运行时,会将class文件加载进内存并对该类进行“解剖”(获取构造、属性、方法等),而解剖的途径就是“该类的class文件对象”,该class对象用来将我们所需要的构造、属性、方法等提取出来,如下图所示:
2 获取类的Class对象
反射关键对象:class文件对象
获取Student类的Class文件对象的三种方法:
(1)对象的getClass()方法获取 (getClass()方法定义在Object类中)
(2)使用类的静态属性class获取
(3)(最常用,推荐)使用Class类的静态方法forName(全限定类名)获取,该方法的扩展性最好
下面以Student类为例,通过代码,演示该类的class对象的创建方式,以及通过“反射”来使用Student类的构造方法、成员属性、成员方法。最后,通过一个简单的案例,讲解“反射”是如何做到解耦,来提高程序的可扩展性的。
public class Student {
/*static{
System.out.println("静态代码块");
}*/
//字段
private String name;
private int age;
//无参、有参构造函数
public Student(){
}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
//成员方法
public void study(){
System.out.println("学生在学习");
}
public void eat(String s,double d){
System.out.println("带参数方法:"+s+"::"+d);
}
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
/**
* 反射关键对象:class文件对象
* 获取Student类Class文件对象的三种方法:
* 1、对象的getClass()方法获取 (getClass()方法定义在Object类中)
* 2、使用类的静态属性class获取
* 3、(最常用)使用class类的静态方法forName(全限定类名)获取,该方法的扩展性最好
*/
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
//1、对象的getClass()方法获取 (getClass()方法定义在Object类中)
Student student = new Student();
Class c1 = student.getClass();
System.out.println(c1);
//2、使用类的静态属性class获取
Class c2 = Student.class;
System.out.println(c2);
//3、使用class类的静态方法forName()获取
Class c3 = Class.forName("com.lmy.reflect.Student");
System.out.println(c3);
}
}
3 通过反射获取类的构造方法
3.1 获取无参构造
(1)完整的写法
public static void main(String[] args) throws Exception, Exception {
//1、拿到该类的Class对象
Class c = Class.forName("com.lmy.reflect.Student");
//2、根据Class类对象中的方法getConstructor() 获取类中的无参构造,如果想获取其他有参构造,就传入参数列表
Constructor constructor = c.getConstructor();
//3、运行构造方法,创建对象
Object object = constructor.newInstance(); //object对象就是Student对象
System.out.println(object);
//上面的这三行代码等同于如下的一行:
Student student = new Student();
System.out.println(student);
}
(2)简略的写法(少写一行,但是有条件:被反射的类必须具有public权限的无参数构造)
/**
反射获取Student类的无参构造方法并执行(减少一行代码)
使用简单的方式,减少代码量(前提:被反射的类必须具有public权限的无参数构造)
*/
public class ReflectDemo4 {
public static void main(String[] args) throws Exception {
Class c = Class.forName("com.lmy.reflect.Student");
//Class类中定义方法 Object newInstance() 运行无参构造,创建对象
Object o = c.newInstance();
System.out.println(o);
}
}
3.2 获取带参构造
public static void main(String[] args) throws Exception {
//获取Class类对象
Class c = Class.forName("com.lmy.reflect.Student");
//该对象的getConstructor方法获取构造:构造方法参数列表中,数据类型的Class文件对象作为参数)
Constructor constructor = c.getConstructor(String.class, int.class);
//创建对象
Object object = constructor.newInstance("张三", 30);
System.out.println(object);
//上面的这三行代码等同于:
Student student = new Student("张三",30);
System.out.println(student);
}
4 通过反射获取类的成员方法
3.1 获取无参成员方法
public static void main(String[] args) throws Exception {
//获取Student类的Class对象c
Class c = Class.forName("com.lmy.reflect.Student");
//创建Student对象
Object object = c.newInstance();
//Class类方法getMethod(string 方法名,方法参数列表)获取指定的成员方法
Method method = c.getMethod("study");
//运行成员方法:Method类的对象:invoke(Object obj, Ovject...对象类型的可变参)第一个参数为本类的对象,因为我们调用的时类的非静态方法study(),所以需要对象支持
method.invoke(object);
3.2 获取带参成员方法
public static void main(String[] args) throws Exception {
//创建Student类的Class类对象
Class c = Class.forName("com.lmy.reflect.Student");
//创建一个Student对象
Object object = c.newInstance();
//获取eat方法getMethod("方法名字符串",参数类型的class对象...)
Method eat = c.getMethod("eat", String.class, double.class);
eat.invoke(object,"字符串",9.8);
}
4 反射的好处
以普通的方式来创建对象,调用方法,就是我们常用的new关键字:编译器将.java文件编译成.class文件之后,普通方式创建的对象就不能再变了,我只能选择是运行还是不运行这个.class文件。
是不是感觉很僵硬?
假如现在我有个写好的程序已经放在了服务器上,每天供人家来访问,这时候Mysql数据库宕掉了,改用Oracle,这时候该怎么怎么办呢?
假如没有反射的话,我们是不是得修改代码,将Mysql驱动改为Oracle驱动,重新编译运行,再放到服务器上。很麻烦,还影响用户访问。
假如我们使用反射Class.forName()来加载驱动,只需要修改配置文件就可以动态加载这个类,
Class.forName()生成的结果在编译时是不可知的,只有在运行的时候才能加载这个类,
换句话说,此时我们是不需要将程序停下来,只需要修改配置文件里面的信息就可以了。
这样当有用户在浏览器访问这个网站时,都不会感觉到服务器程序程序发生了变化。
此段关于 反射的好处 节选于:https://www.cnblogs.com/bihanghang/p/9992237.html
5 简单的反射案例,实现程序可扩展
实现步骤
1、创建配置文件(一个文本,写键值对,后缀名一般是Properities,放在src目录下,src下的文件是源代码,
编译后是class文件,class文件和配置文件刚好是同步的,类加载器的getResourceAsStream()方法可以自动扫描读取)
2、通过类加载器,IO读取配置文件,读取文件中的键值对
3、键值存储在集合中Properities
4、集合中取到键值对,拿到类名和方法名
5、反射调用
public static void main(String[] args) throws Exception {
//Test的类加载器,必须先取到这个类的Class文件对象
ClassLoader classLoader = Test.class.getClassLoader();
//加载器获取字节输入流
InputStream inputstream = classLoader.getResourceAsStream("config.properties");
//流对象和集合关联使用
Properties properties = new Properties();
properties.load(inputstream);
//集合方法:获取值
String className = properties.getProperty("className");
String methodName = properties.getProperty("methodName");
//反射获取这个类的class文件对象,创建对象,获取类方法,执行方法
Class c = Class.forName(className);
Object object = c.newInstance();
Method teach = c.getMethod(methodName);
teach.invoke(object);
}
配置文件config.properities中的内容如下:
className=com.lmy.test.Teacher
methodName=teach
在程序运行时,才知道我们要使用的类到底是如下的哪个(通过配置文件指定)
public class Teacher {
public void teach(){
System.out.println("老师在上课");
}
}
public class Student {
public void study(){
System.out.println("学生在学习");
}
}
到现在为止:关于配置文件中所规定的类的方法的调用问题,已经用代码写好了。
但是“最后具体要使用的类,以及需要调用的方法”并没有“写死”到代码里,而是通过“配置文件”来体现:配置文件可以随意修改
当前我们调用的是Teacher类的teacher方法,一旦修改配置文件,我们就可以直接调用Student类的study方法,只需要修改配置而已(当然了,要保证所调用方法的参数类型是统一的,上面的例子是对于无参成员方法的调用)。
以上,通过简单的反射案例,实现了程序的可扩展。