黑马程序员-反射

反射

1.Class类

• Class类：Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。
• Class描述了：类的名字，类的访问属性，类所属包名，字段名称的列表，方法名称的列表等。
• 类的字节码实例对象信息获取方式：Class主要是获取Java类的字节码信息在获取各个Java类详细信息，需要Java类从硬盘加载到内存中，获取方式有：Class class = Dtae.class;、Class.forName("java.lang.String");、对象.getClass()。
• 在源程序中出现的类型，都有各自的Class实例对象*

        String str = "abc";
        Class cls1 = str.getClass();
        Class cls2 = String.class;
        Class cls3 = Class.forName("java.lang.String");
        System.out.println(cls1.isPrimitive()); //是否是基本数据类型
        System.out.println(int.class == Integer.TYPE); //int包装数据类型类的类型和int对应的字节码相同
        System.out.println(int.class == Integer.class); //int和Integer的字节码不相同
        System.out.println(int[].class.isArray()); //数组类型的Class实例对象

2.反射介绍

• 反射就是把Java类中的各种成分映射成相应的Java类。
• 一个类中的每个成员都可以用相应的反射类的一个实例对象来表示，如类中的方法可以用Method对象来表示。

构造方法的反射：

        Constructor[] con = Class.forName("java.lang.String").getConstructors();//获取此类的所有构造方法
        Constructor con1 = String.class.getConstructor(StringBuffer.class);//获取单个指定构造方法

• 创建构造方法：String str = (String)con1.newInstance(new StringBuffer("bac"));创建new String(new StringBuffer("abc"))此对象,Class.newInstance()用来创建默认的构造方法。

成员变量的反射：

package com.sergio.NewTecl;

import java.io.File;
import java.lang.reflect.Field;

/**
 * 成员反射
 * Created by Sergio on 2015-06-05.
 */
public class ReflectField {
    public static void main(String[] args) throws Exception {
        ReflectTest rt = new ReflectTest(3, 5);
        //获取rt字节码对象上的x变量值.获取私有变量的值
        Field fieldX = rt.getClass().getDeclaredField("x");
        //设置私有变量获取后可以使用了
        fieldX.setAccessible(true);
        System.out.println(fieldX.get(rt));
        //获取的是共有变量
        Field fieldY = rt.getClass().getField("y");
        System.out.println(fieldY.get(rt));

        changeStringValue(rt);
        System.out.println(rt);
    }

    //更改rt对象中变量的某些值
    private static void changeStringValue(Object object) throws IllegalAccessException {
        Field[] fields = object.getClass().getFields();
        for (Field field : fields) {
            if (field.getType() == String.class) {
                String oldValue = (String) field.get(object);
                String newValue = oldValue.replace('b', 'a');
                field.set(object, newValue);
            }
        }
    }
}


class ReflectTest {
    private int x;
    public int y;
    //更改b为a
    public String str1 = "ball";
    public String str2 = "basketball";
    public String str3 = "itcast";


    public ReflectTest(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "ReflectTest{ + str1='" + str1 + '\'' + ", str2='" + str2 + '\'' + ", str3='" + str3
            + '\'' +
            '}';
    }
}

成员方法反射

        String str1 = "abc";
        //str1.charAt(1)调用下面方法方式
        Method method = String.class.getMethod("charAt", int.class);
        //打印1位置的字符，method.invoke(null, 1)静态方法调用
        System.out.println(method.invoke(str1, 1));

数组的反射

• 具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
• 基本类型的一维数组可以被当作Object类型使用，但不能当作Object[]类型使用；非基本类型的一维数组，既可以当作Object类型使用，又可以当作Object[]类型使用。

package com.sergio.NewTecl;

import java.lang.reflect.Array;

/**
 * 数组反射实例
 * Created by Sergio on 2015-06-06.
 */
public class ReflectArrayTest {
    public static void main(String[] args) {
        int[] a1 = new int[] {1, 2, 3};
        String[] a4 = new String[] {"xya"};

        printObject(a1);
        printObject(a4);

    }
    //打印数组中的元素
    private static void printObject(Object obj) {
        Class clazz = obj.getClass();
        if (clazz.isArray()) {
            int length = Array.getLength(obj);
            for (int i = 0; i < length; i++) {
                System.out.println(Array.get(obj, i));
            }
        } else {
            System.out.println(obj);
        }
    }
}

类加载器与反射

• 类加载器是用来加载外部配置文件的主要方式之一。

package com.sergio.NewTecl;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Properties;

/**
 * 反射加载外部文件操作
 * Created by Sergio on 2015-06-06.
 */
public class ReflectCollection {
    public static void main(String[] args) throws Exception {
        //        Collection collections = new ArrayList<>();
        InputStream ips = new FileInputStream("config.properties");
        //类加载方法，加载外部文件配置的主要方式
        //InputStream ips2 = ReflectCollection.class.getClassLoader().getResourceAsStream("config.properties");

        Properties props = new Properties();
        props.load(ips);
        ips.close();

        String className = props.getProperty("className");
        //创建ArrayList构造方法实例，加载的外部文件为className=java.util.ArrayList
        Collection collections = (Collection) Class.forName(className).newInstance();
        ReflectTest rt = new ReflectTest(3, 5);
        ReflectTest rt1 = new ReflectTest(3, 5);
        ReflectTest rt2 = new ReflectTest(3, 5);
        collections.add(rt);
        collections.add(rt1);
        collections.add(rt2);

        System.out.println(collections.size());
    }
}


class ReflectTest1 {
    private int x;
    public int y;

    public ReflectTest1(int x, int y) {
        this.x = x;
        this.y = y;
    }
}


配置文件信息：className=java.util.ArrayList

反射与泛型

• 通过制定对应的Class对象，程序可以获得该类里面所有的Field，不管该Field使用private方法或者public获得Field对象后都可以使用getType()来获取其类型。Class<?> type= f.getType()获得字段的类型，此方法
  只对普通Field有效，若该Field有泛型修饰，则不能准确得到该Field的泛型参数，如Map<String, Integer>;,为了获得指定Fild的泛型类型，可以如下：Type type = f.getGenerciType()得到泛型类型，然后将Type对象强转为ParameterizedType，表示增加泛型后的类型。Type getRawType()返回被泛型限制的类型。Type[] getActualArguments()返回泛型原始参数类型。
• 反射获取泛型类型(信息)的步骤：
  
  1. 获取当前类
  2. 获取目标字段
  3. 获取包含泛型类型的类型getGenericType()
  4. 强转至子类ParameterizedType，因为Type没有任何对应的方法
  5. 获得泛型真正的类型getActualTypeArguments()

package com.sergio.NewTecl;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Date;
import java.util.Vector;

/**
 * 通过反射获取泛型方法的参数类型
 * Created by Sergio on 2015-06-12.
 */
public class GenericDao {
    public static void applyVector(Vector<Date> v1) {

    }

    public static void main(String[] args) throws Exception {
        //要调用哪个泛型方法
        Method method = GenericDao.class.getMethod("applyVector()", Vector.class);
        Type[] types = method.getGenericParameterTypes();//获取泛型方法
        ParameterizedType pType = (ParameterizedType) types[0];//转化为参数类型
        System.out.println(pType.getRawType());//返回被限制的泛型类型
        System.out.println(pType.getActualTypeArguments());返回泛型实际参数类型
    }
}