什么是反射
反射就是指程序在运行的时候可以知道一个类的自身信息。
-
对于任何一个类:可以知道这个类的属性和方法。
-
对于任何一个对象:可以调用这个对象的任何一个方法和属性。
反射就是把java类中的各种成分映射成一个个的Java对象。
例如:一个类有:成员变量、方法、构造方法、包等等信息,利用反射技术可以对一个类进行 解剖,把个个 组成部分映射成一个个对象。
反射的功能
-
在运行时判断任意一个对象所属的类
-
在运行的时候构造任意一个类的对象
-
在运行时判断一个类所具有的成员变量和方法
-
在运行时调用任何一个对象的方法
-
生成动态代理
反射的优点和缺点
动态编译和静态编译
反射用到的是动态编译,既然有动态编译,就会有静态编译。
那么动态编译和静态编译又有什么区别?
静态编译:在编译的时候进确定类型,如果绑定对象成功,new 是静态加载类,就编译通过
public class Phone{
public static void main(String[] args){
if("iphone".equals(args[0])){
Iphone iphone = new Iphone();
iphone.call();
}
if("xiaomi".equals(args[0])){
Xiaomi xiaomi = new Xiaomi();
xiaomi.call();
}
}
}
class Xiaomi{
public void call(){
System.out.println("xiaomi is calling");
}
}
class Iphone{
public void call(){
System.out.println("iphone is calling");
}
}
当在Phone.java里面写好代码的时候,如果需要添加新的类,则需要直接在文件里面修改代码。假如需要添加一个华为手机,则我需要在Phone.java文件里面加个if语句判断传进来的参数是不是"huawei",这样增加了类之间的耦合性。
当删除一个类的时候Phone.java编译可能会出现错误。 假如我删除了小米手机这个类,phone.java文件没有删除if判断语句,那么phone.java在编译的时候则会失败。
动态编译:在运行的时候确定类型,绑定对象。最大发挥了Java的多态,降低类之间的耦合性。
Phone.java
public static void main(String[] args){
try{
Class c = Class.forName("Huawei");
PhoneInterface cellPhone = (PhoneInterface)c.newInstance();
cellPhone.ring();
}catch (Exception e){
e.printStackTrace();
}
}
PhoneInterface.java
interface PhoneInterface{
void ring();
}
Huawei.java
public class Huawei implements PhoneInterface{
@Override
public void ring(){
System.out.println("huawei is ringing...");
}
}
OnePlus.java
public class OnePlus implements PhoneInterface{
@Override
public void ring(){
System.out.println("OnePlus is ringing...");
}
}
对比静态编译,当我们需要往Phone.java里面传递新的类参数的时候,根本不需要修改Phone.java的代码,因为这里应用了Java的多态。只要新建一个新的类实现了PhoneInterface的接口,把类名传进去就可以调用。这里体现了 需要哪个类的对象就动态的创建哪个类的对象,也就是说动态的实现了类的加载。
优点
以实现动态创建对象和编译,体现出很大的灵活性,特别是在J2EE的开发中它的灵活性就表现的十分明显。比如,一个大型的软件,不可能一次就把把它设计的很完美,当这个程序编译后,发布了,当发现需要更新某些功能时,我们不可能要用户把以前的卸载,再重新安装新的版本,假如这样的话,这个软件肯定是没有多少人用的。采用静态的话,需要把整个程序重新编译一次才可以实现功能的更新,而采用反射机制的话,它就可以不用卸载,只需要在运行时才动态的创建和编译,就可以实现该功能。
缺点
对性能有影响。使用反射基本上是一种解释操作,我们可以告诉JVM,我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。
Class类和类类型
Class类
所有的类是java.lang.Class类的对象,Class类是所有类的类,反射的基础。
Class对象(类类型)
普通类构造对象是:Student s = new Student();
但Class对象则不是,看Class类的源码,构造器是私有的,则用户无法直接像普通类那样new一个Class的对象,只有JVM才可以构造Class对象。
private Class(ClassLoader loader) {
// Initialize final field for classLoader. The initialization value of non-null
// prevents future JIT optimizations from assuming this final field is null.
classLoader = loader;
}
但是我们可以通过一个已知的类获得Class对象
有以下三种方式:
Class s = Student.class;
Class s1 = new Student().getClass();
Class s2 = Class.forName("Student");
反射相关操作
文章开始说过,反射会把一个类的成分(成员变量,方法,构造器)各自映射成一个个对象(Field对象,Method对象,Construct对象),
一个类中这些成员方法、构造方法、在加入类中都有一个类来描述。
java.lang.reflect.Constructor;
java.lang.reflect.Field;
java.lang.reflect.Method;
java.lang.reflect.Modifier;
通过Class对象我们可以做什么呢?
-
获取成员方法Method
-
获取成员变量Field
-
获取构造函数Construct
获取成员方法
用法
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
// 得到该类所有的方法,不包括父类的
public Method getMethod(String name, Class<?>... parameterTypes)
// 得到该类所有的public方法,包括父类的
//具体使用
Method[] methods = class1.getDeclaredMethods();
//获取class对象的所有声明方法
Method[] allMethods = class1.getMethods();
//获取class对象的所有public方法 包括父类的方法
Method method = class1.getMethod("info", String.class);
//返回次Class对象对应类的、带指定形参列表的public方法
Method declaredMethod = class1.getDeclaredMethod("info", String.class);
//返回次Class对象对应类的、带指定形参列表的方法
例子
public static void main(String[] args) {
try {
Class c = Class.forName("General.Student");
Object o = c.newInstance();
Method method = c.getMethod("fun",String.class,int.class);
method.invoke(o,"X_man",30);
} catch (Exception e) {
e.printStackTrace();
}
}
package General;
import java.lang.reflect.Method;
public class Student {
private String name;
private int age;
private String msg = "I am a student";
public void fun() {
System.out.println("fun");
}
public void fun(String name,int age) {
System.out.println("我叫"+name+",今年"+age+"岁");
}
public Student(){
}
private Student(String 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 getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
结果:
我叫X_man,今年30岁
只要知道包的限定名,就可以对Student这个类进行所有操作
获取成员变量信息
获取成员变量,通过Class类的以下方法,变量是 成员变量名
public Field getDeclaredField(String name)
// 获得该类自身声明的所有变量,不包括其父类的变量
public Field getField(String name)
// 获得该类自所有的public成员变量,包括其父类变量
//具体实现
Field[] allFields = class1.getDeclaredFields();
//获取class对象的所有属性
Field[] publicFields = class1.getFields();
//获取class对象的public属性
Field ageField = class1.getDeclaredField("age");
//获取class指定属性
Field desField = class1.getField("des");
//获取class指定的public属性
例子
public static void main(String[] args) {
try {
Class c = Class.forName("General.Student");
Object o = c.newInstance();
Field field = c.getDeclaredField("msg");
//msg在例子中是私有变量,如果没设置之前,用c.getField()是会报错的
field.setAccessible(true); //private设置为public
System.out.println(c.getField("msg"));
//用getFiled()则可以直接访问
} catch (Exception e) {
e.printStackTrace();
}
}
获取构造函数信息
用法
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
// 获得该类所有的构造器,不包括其父类的构造器
public Constructor<T> getConstructor(Class<?>... parameterTypes)
// 获得该类所以public构造器,包括父类
//具体
Constructor<?>[] allConstructors = class1.getDeclaredConstructors();
//获取class对象的所有声明构造函数
Constructor<?>[] publicConstructors = class1.getConstructors();
//获取class对象public构造函数
Constructor<?> constructor = class1.getDeclaredConstructor(String.class);
//获取指定声明构造函数
Constructor publicConstructor = class1.getConstructor(String.class);
//获取指定声明的public构造函数