黑马程序员-java高新技术（反射）

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

---

一、反射
1、定义：
Java程序中的各个Java类属于统一类事物，描述这类事物的Java类名就是Class。反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息。
2、优点和缺点：
优点：
可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发。
缺点：
对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。
3、Class对象
T - 由此 Class 对象建模的类的类型。
常用方法：
(1)forName(String className)
返回与带有给定字符串名的类或接口相关联的 Class 对象。
(2)getClasses()
返回一个包含某些 Class 对象的数组，这些对象表示属于此 Class 对象所表示的类的成员的所有公共类和接口。
(3)isPrimitive()
判定指定的 Class 对象是否表示一个基本类型。
(4)newInstance()
创建此 Class 对象所表示的类的一个新实例。
(5)getField(String name)
返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。
(6)getMethod(String name, Class parameterTypes)
返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。
(7)getConstructors()
返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。
4、构造函数
Constructor 提供关于类的单个构造方法的信息以及对它的访问权限。
常用方法：
(1)getName()
以字符串形式返回此构造方法的名称。
(2)newInstance(Object… initargs)
使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
5、字段
Field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。
常用方法：
(1)get(Object obj)
返回指定对象上此 Field 表示的字段的值。
(2)getName()
返回此 Field 对象表示的字段的名称。
(3)set(Object obj, Object value)
将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
6、方法
Method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。
常用方法：
(1)getName()
以 String 形式返回此 Method 对象表示的方法名称。
(2)invoke(Object obj, Object… args)
对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。

代码块

练习：反射常用练习

package com.itheima5;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
 * Class ---> 代表一类什么样的事物？
 * 
 * Person p1 = new Person();
 * Person p2 = new Person();
 * 
 * Class cls1 = Date.class//字节码1;
 * Class cls2 = Person.class//字节码2;
 * 
 * p1.getClass();
 * 
 * Class.forName("java.lang.String");
 * 
 * 加载字节码的方法：
 * 类名.class
 * 对象.getClass()，例如：new Date().getClass()
 * Class.forName("类名")，例如：Class.forName("java.util.Date")
 * 
 * 
 * 反射：就是把Java类中的各种成分映射成相应的Java类。
 * 
 * 
 * 
 * Constructor类
 * Constructor[] constructors = Class.forName("java.lang.String").getConstructors();
 * 
 * class->constructor->new object
 * 
 * ClassDemo对象
 * @author jjy
 * 
 * 
 */
public class ReflectTest{

    public static void main(String[] args)throws Exception{

        String str1 = "abc";
        /**
         * 获得Class对象
         */
        Class cls1 = str1.getClass();
        Class cls2 = String.class;
        Class cls3 = Class.forName("java.lang.String");

        System.out.println(cls1==cls2);
        System.out.println(cls1==cls3);

        System.out.println(cls1.isPrimitive());
        System.out.println(int.class.isPrimitive());
        System.out.println(int.class == Integer.class);

        System.out.println(int.class == Integer.TYPE);
        System.out.println(int[].class.isPrimitive());
        System.out.println(int[].class.isArray());

        /**
         * 调用构造函数
         */
        //new String(new StringBuffer("abc"));
        Constructor constructor1 = String.class.getConstructor(StringBuffer.class);

        String str2 = (String)constructor1.newInstance(new StringBuffer("abc"));

        System.out.println(str2.charAt(2));

        /**
         * 获得字段：field
         */
        ReflectPoint pt1 = new ReflectPoint(3,5);

        Field fieldY = pt1.getClass().getField("y");

        //fieldY的值是多少？是5，错！ 
        //field不是对象身上的变量，而是类上，
        System.out.println(fieldY.get(pt1));

        Field fieldY11 = pt1.getClass().getField("y");

        Field fieldX = pt1.getClass().getDeclaredField("x");

        fieldX.setAccessible(true);
        System.out.println(fieldX.get(pt1));

        changeStringValue(pt1);
        System.out.println(pt1);


        /**
         * 获得方法：Method()
         */
        Method methodCharAt = String.class.getMethod("charAt", int.class);

        System.out.println(methodCharAt.invoke(str1, 1));

        System.out.println(methodCharAt.invoke(str1, new Object[]{2}));



        //TestArguments.main(new String[]{"111","222","333"});
        String startingClassName = args[0];
        Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);
        mainMethod.invoke(null, new Object[]{new String[]{"111","222","333"}});


        /**
         * array
         */
        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());

        Object aObj1 = a1;
        //Object[] aObj5 = a1;//就是int型，不能是Object
        Object[] aObj2 = a4;
        Object[] aObj3 = a3;
        Object[] aObj4= a4;

        System.out.println(Arrays.asList(a1));
        System.out.println(Arrays.asList(a4));

        /**
         * 在看视频的时候，老师定义了几个数组，然后进行比较，在Eclipse中代码不报错，但是，我自己运行的时候，出现了如下错误：
            Incompatible operand types Class<capture#8-of ? extends int[]> and Class<capture#9-of ? extends int[][]>
            解析：查阅了网上的资料，解释如下：
            对于数组类型的变量编译器在编译时，其实已经知道类型了。也就是说,编译器认为这2个类型是不一样的。根本没有比较的需要。
            对于总是不成立的比较，其实是没有意义的。这个编译错误是 JDK 1.6的新功能 
            而老师使用的恰好是JDK1.5的版本，我使用的是1.6版本。
         */
        //System.out.println(a1.getClass() == a4.getClass());
        //System.out.println(a1.getClass() == a3.getClass());


        Object obj = null;
        printObject(obj);

    }

    private static void printObject(Object obj){
        Class clazz = obj.getClass();
        if(clazz.isArray()){
            int len = Array.getLength(obj);
            for(int i=0;i<len;i++){
                System.out.println(Array.get(obj, i));
            }
        }else{
            System.out.println(obj);
        }
    }

    private static void changeStringValue(Object obj)throws Exception{
        Field[] fields = obj.getClass().getFields();

        for(Field field:fields){
            //if(field.getType().equals(String.class))
            if(field.getType() == String.class){
                String oldValue = (String)field.get(obj);
                String newValue = oldValue.replace("b", "a");
                field.set(obj, newValue);
            }
        }
    }
}

class TestArguments{
    public static void main(String[] args){
        for(String arg:args){
            System.out.println(arg);
        }
    }
}

运行结果：
true
true
false
true
false
true
false
true
c
5
3
aall:aasketaall:itcast
b
c
111
222
333
true
[I
java.lang.Object
[[I@3d4b7453]
[null, null, null]