黑马程序员_java_反射

------- android培训、java培训、期待与您交流！ ----------

【JAVA反射机制】是指在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

获得想操作的类的Class对象3种方式

1 类名.class比如：Class c1=Student.class;

2 获取某一个类的对象，然后通过对象的getClass方法获取Class对象比如 Student s=new Student(); Class c1=s.getClass();该方法是Objcet类的方法。

3 利用Class类的静态方法forName(String 类名)来获取Class对象比如 Class c=Class.forName("Student");

9个预定义的class对象

八个基本数据类型boolean、byte、char、short、int、long、float 和double和void

一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，

一个类中的组成部分：成员变量，方法，构造方法，包等等信息也可以用Java类来表示；这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等

public class ReflectTest {
    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub
        String str1 = "abc";
        Class cls1 = str1.getClass();
        Class cls2 = String.class;
        Class cls3 = Class.forName("java.lang.String");
        System.out.println(cls1==cls2);//true
        System.out.println(cls1==cls3);//true
        System.out.println(cls2==cls3);//true
        System.out.println("------------------");
        System.out.println(cls1.isPrimitive());//false
        System.out.println(int.class.isPrimitive());//true
        System.out.println(int.class==Integer.class);//false
        System.out.println(int.class==Integer.TYPE);//true,type表示基本包装类
        System.out.println(int[].class.isPrimitive());//false//<span style="font-family: Arial;font-size:12px; line-height: 26px;">判断该Class类对象是否是基本数据类型字节码。</span>
        System.out.println(int.class.isArray());//true
    }
}

构造方法的反射

我们可以通过Class类的方法获取构造函数对象，然后用构造函数对象的方法来实例化这个类A。
Constructor类代表某个类中的一个构造方法
得到某个类所有的构造方法：
Constructor [] constructors= Class.forName("java.lang.String").getConstructors();
得到某一个构造方法：
Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);

创建实例对象：
通常方式：String str = new String(new StringBuffer("abc"));
反射方式：String str = (String)constructor.newInstance(new StringBuffer("abc"));

Class.newInstance()方法：
例子：String obj = (String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
该方法内部的具体代码用到了缓存机制来保存默认构造方法的实例对象。

import java.lang.reflect.*;
public class ReflectTest {
    public static void main(String[] args) throws Exception{
        Constructor<String> constructor1 = String.class.getConstructor(StringBuffer.class);
        String str2 = constructor1.newInstance(new StringBuffer("abc"));
        System.out.println(str2.charAt(2));
    }
}

变量的反射

我们可以通过Class类对象的方法获取变量类对象，然后用变量类对象的方法来获取该A类某对象的这个变量的值或者设置这个值。
1.Field类代表某个类中的一个成员变量
2.字段field代表的是类的定义，而不是具体的x变量。

Field getDeclaredField(String name)//返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。 
Field[] getDeclaredFields()//返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。 
Field getField(String name)//返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。 
Field[] getFields()//返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。

import java.lang.reflect.*;
public class ReflectTest {
    public static void main(String[] args) throws Exception{
        ReflectPoint pt1 = new ReflectPoint(3,5);
        Field fieldY = pt1.getClass().getField("y");
        System.out.println(fieldY.get(pt1));//结果为5
        //fieldX为私有的，.getField("x")取不到，得用.getDeclaredField("x")
        Field fieldX = pt1.getClass().getDeclaredField("x");
        //由于私有，不可访问，使用setAccessible(true)，可以表示可以取
        fieldX.setAccessible(true);
        System.out.println(fieldX.get(pt1));//3
    }
}
class ReflectPoint {
    private int x;
    public int y;
    public ReflectPoint(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }
}

方法的反射

可以通过Class类对象的方法获取方法类对象，然后用方法类对象的方法来执行该类对象的这个方法。
Method类代表某个类中的一个成员方法

得到类中的某一个方法：

例子：Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);

调用方法：
通常方式：System.out.println(str.charAt(1));
反射方式：System.out.println(charAt.invoke(str, 1));
如果传递给Method对象的invoke()方法的第一个参数为null说明该Method对象对应的是一个静态方法！

jdk1.4和jdk1.5的invoke方法的区别：
Jdk1.5：public Object invoke(Object obj,Object... args)
Jdk1.4：public Object invoke(Object obj,Object[] args)
即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，
所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

import java.lang.reflect.*;
public class ReflectTest {
    public static void main(String[] args) throws Exception{
        Method methodCharAt = String.class.getMethod("charAt", int.class);
        System.out.println(methodCharAt.invoke("abc",1 ));
        //System.out.println(methodCharAt.invoke(null,1 ));如果为null则为静态方法
        //System.out.println(methodCharAt.invoke("abc",new Object[]{2} ));1.5以前，没有可变参数，这么写
    }
}

数组的反射应用
具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；
非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
Arrays.asList()方法处理int[]和String[]时的差异。
Array工具类用于完成对数组的反射操作

import java.lang.reflect.*;
public class ReflectTest {
    public static void main(String[] args) throws Exception{
        int[] a1 = new int[3];
        int[] a2 = new int[4];
        int[][] a3 = new int[2][3];
        String[] a4 = new String[3];
        System.out.println(a1.getClass()==a2.getClass());
        System.out.println(a1.getClass().getName());
        System.out.println(a1.getClass().getSuperclass().getName());
        System.out.println(a2.getClass().getSuperclass().getName());
        System.out.println(a3.getClass().getSuperclass().getName());
        System.out.println(a4.getClass().getSuperclass().getName());
        System.out.println(String.class.getSuperclass().getName());
        System.out.println(StringBuffer.class.getSuperclass().getName());
        //发现a1，a2，a3，a4的super都是objcet所以可以
        Object aObj1 = a1;
        Object aObj2 = a4;
        //Object[] aObj3 = a1;不对 int 不可以直接转为object
        Object[] aObj4 = a3;
        Object[] aObj5 = a4;
    }
}