2.反射
Java.Reflection
静态语言和动态语言：
-
动态语言：
-
是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗讲就是在运行时代码可以根据某些条件改变自身结构。
-
常见动态语言：JavaScript、PHP、Python、C#、Object-C
//体现动态语言的代码 function test() { var x = "var a=3;var b=5;alert(a+b)"; eval(x);//在运行时改变函数代码 }
-
-
静态语言：
- 与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。
- Java本身不是动态语言，但是Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活。
2.1反射引入
-
Reflection（反射）是Java被视为动态语言的关键
-
反射机制 允许程序在执行期间 借助Reflection API 取得任何类的内部信息，并能直接操作任意对象的的内部属性及方法。
Class c = Class.forName("java.lang.String")
1. Class类及Class类的对象：
-
Java中存在一个Class类型的类，即Java中的类分为Class类和其他类；
-
当某个类加载完之后，在堆内存的方法区中就产生了这个类的Class类型的对象
区分“类”和这个“类的Class对象”，通过类的Class对象可以得到这个类的全部信息。
-
每个类在内存中都只有一个Class对象，我们可以通过“类的对象”（以及类名等）得到这个类对应的Class对象。通过这个对象我们可以看到类的结构。
这个Class对象就像是一面镜子，通过这面镜子可以看到类的结构，所以我们形象的称之为反射。
**反射定义：**每个类都唯一对应一个Class对象，通过这个对象我们可以得到这个类的所有信息。获取某个类Class对象的过程——我们称之为反射。
2.正常方式和反射方式new对象：
//正常方式
Student stu1=new Student();
//反射方式
Student stu2=Class.forName("java.lang.String").newInstance();
Student stu3=stu1.getClass().newInstance();
3.举例：一个类只存在一个Class对象
实体类User：
public class User {
private int id;
private String name;
private int age;
//无参构造
public User() {
}
//有参构造
public User(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
//getter和setter
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
//toString()
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
测试：
public class Test01 {
public static void main(String[] args) throws ClassNotFoundException {
//通过反射获取类对应的Class对象
//一个类被加载后，类的整个结构信息会被放到对应的Class对象中
Class<?> c1 = Class.forName("com.kuang.reflection.User");
System.out.println(c1);
//每个类都有一个Class对象
Class<?> c2 = Class.forName("com.kuang.reflection.User");
System.out.println(c1.hashCode());
System.out.println(c2.hashCode()); //两次获取的User的Class对象hashCode一致，表明是同一个Class对象
}
}
4.反射机制提供的功能
在运行时：
-
判断任意一个对象所属的类
-
判断任意一个类所具有的的成员变量和方法
-
调用任意一个对象对应类的成员变量和方法
-
构造任意一个类的对象
-
获取泛型信息
-
处理注解
-
生成动态代理……
5.反射的优点和缺点
优点：
- 可以实现动态创建对象和编译，体现出很大的灵活性。
缺点：
- 对性能有影响
- 使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它能满足我们的要求
- 这类操作总是慢于 直接执行相同的操作
6.反射相关的主要API
- java.lang.Class：代表一个类
- java.lang.reflect.Method：代表类的方法
- java.lang.reflect.Field：代表类的成员变量
- java.lang.reflect.Constructor：代表类的构造器
……
2.2Class类及Class对象
1.区分Class类和其他类，每个类都有唯一对应的Class对象
-
Object类被所有类继承，其中定义了
public final Class getClass()方法，因此所有的类的对象都能调用该方法获取 自己对应类 对应的Class对象。 -
该方法返回类型是一个Class类，此类是Java反射的源头
-
实际上所谓反射 从程序的运行结果来看 也很好理解，即：可以通过类的对象 反射得到 类对应Class对象，从而得到类的所有信息
- 对象照镜子（反射）以后可以得到的信息：某个类的属性、方法、构造器；实现了哪些接口；
- 没有每个类而言，JRE都为其保留一个不变的Class对象，一个Class对象包含了特定某个结构（class/interface/enum/annotation/primitive type/void/[])的有关信息。
2.Class对象理解：
-
Class本身也是一个类，只不过是比较特殊的类。
-
Class对象只能由系统建立
-
一个加载的类在JVM中只会有一个Class实例对象
-
一个Class对象对应的是一个加载到JVM中的 .class文件
-
通过Class对象可以完整地得到一个类中所有被加载的结构
-
每个类的实例都会记得自己是由哪个Class实例所生成
-
Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象
3.获取Class对象的方式
每个类都继承了Object类，Object类中有一个静态成员变量class，和getClass()方法
-
通过对象获得
Class<? extends Person> c1 = p1.getClass(); -
通过Class.forName(“包名+类名”)获得
Class<?> c2 = Class.forName("com.kuang.reflection.Student"); -
通过类的静态成员class获得
Class<?> c3 =Person.class; -
针对内置的基本数据类型
Class<?> c4 =Integer.TYPE; -
还可以利用ClassLoader，后面讲解
测试：
public class Person {
private String name;
public Person(){
}
public Person(String name){
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
public class Student extends Person{
public Student(){
super.setName("学生");
}
}
public class Teacher extends Person{
public Teacher(){
super.setName("老师");
}
}
//**************************************
public class Test02 {
public static void main(String[] args) throws ClassNotFoundException {
Person p1=new Student();
System.out.println("这个人是:"+p1.getName());
//获取Class对象方法一：通过对象获得，如果是子类的实现，赋值给父类，得到的时子类对应的Class对象
Class<? extends Person> c1 = p1.getClass();
//获取Class对象方法二：通过Class.forName("类名+包名")获得
Class<?> c2 = Class.forName("com.kuang.reflection.Student");
//获取Class对象方法三：通过类的静态成员变量class获得
Class<?> c3 =Person.class;
//获取Class对象方法四：只针对内置的基本数据类型
Class<?> c4 =Integer.TYPE;
//获取父类的Class
Class<?> superc1 = c1.getSuperclass();
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(superc1);
}
}
4.Class类的常用方法
-
Object newInstance()调用类的缺省构造函数，返回类的一个对象实例 -
getName()返回Class对象所表示的实体 的名称（类的名称） -
Class getSuperClass()得到父类的Class对象 -
Class[] getinterfaces()得到当前Class对象对应的类 的所有接口 对应的Class对象 -
ClassLoader getClassLoader()返回该类的类加载器 -
Constructor[] getConstructors()返回一个包含某些Constructor对象的数组 -
method getMothed(String name, Class.. T)返回一个Method对象，此对象的形参类型为paramType -
Filed[] getDeclaredFields()返回Field对象的一个数组
5.哪些类型可以有Class对象
在Java中，万物皆类，万物皆对象
- class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
- interface：接口
- []：数组
- enum：枚举
- annotation：注解
- primitive type：基本数据类型
- void
测试：
public class Test03 {
public static void main(String[] args) {
//测试哪些类型有Class对象
Class c1=Object.class; //类
Class c2=Comparable.class; //接口
Class c3=int[].class; //一维数组
Class c4=int[][].class; //二维数组
Class c5= ElementType.class; //枚举
Class c6=Override.class; //注解
Class c7=Integer.class; //基本数据类型
Class c8=void.class; //void
Class c9=Class.class;
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
System.out.println(c6);
System.out.println(c7);
System.out.println(c8);
System.out.println(c9);
//只有元素类型和维度一样，就对应一个Class对象
int[] a=new int[10];
int[] b=new int[100];
Class Ca=a.getClass();
Class Cb=b.getClass();
System.out.println(Ca==Cb);
}
}
扫一扫
740
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
