黑马程序员——反射

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------



 

 

理解反射的概念

反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。

反射就是把Java类中的各种成分映射相成Java类。反射也称为对类的解剖。把类的各个组成部分映射成一个个相应的Java类。

例如：一个类有：成员变量，方法，构造方法，包等等信息。

利用反射技术可以对一个类进行解剖。

其实只要拿到Java类的字节码对应的Class对象，就等于拿到了Java类中的各个成分。

反射的基石就是Class。

Class类

Class类用于表示.class文件，是所有加载进内存的字节码对象的父类。所以可以通过Class得到运行时的类。

如何得到某个class文件对应的class对象呢？

方法有3种：

1）类名.class 例如，Person.class。

2）对象.getClass() 例如，new Data().getClass()。

3）Class.forName("包名.类名"); 例如，Class.forName("java.lang.String");

代码示例：

public class ClassTest{

    public static void main(String...args)throws Exception{

        String str = "黑马程序员";

        Class cls1 =String.class;

        Class cls2 = str.getClass();

        Class cls3 = Class.forName("java.lang.String");

        System.out.println(cls1 == cls2);//true

        System.out.println(cls2 == cls3);//true

    }

}

注意：字节码文件是唯一的，所以无论怎么获取，都是同一份字节码文件。

九个预定义Class实例对象（八大原始类型+void）

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。

每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该Class 对象。

基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void也表示为 Class 对象。

注意：

1、int.class == Integer.TYPE。

2、数组类型的Class实例对象Class.isArray()为true。

3、反射并不是Java 5.0的新特性。

Java 5.0 代码示例：

package com.itheima.day01;

public class ReflectTest {

    public static void main(String[] args) {

        System.out.println("判断int基本数据类型和Integer的基本数据类型"

        + "是不是同一个Class对象 结果为："+(int.class == Integer.TYPE));

        System.out.println("判断int.class是不是基本数据类型 结果为："+int.class.isPrimitive());

        System.out.println("判断是不是数组类型 结果为："+int[].class.isArray());

    }

}

//结果都为true

总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int.class，int[].class。

一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。

构造方法的反射应用（Coustructor类）

Constructor类的实例对象代表类的一个构造方法。

反射公共，私有和保护的构造方法：

反射公共的需要的方法是：getConstructor();

反射私有的需要的方法是：getDeclaredConstructor();

Constructor对象代表一个构造方法，Constructor对象有的方法：得到构造方法名字，得到所属于的类，产生实例对象。

得到某个类空参数构造方法，例：

Constructor constructor = Class.forName("java.lang.String").getConstructor();

得到某个类所有的构造方法，例：

Constructor [] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个带参数的构造方法，例：       

Constructor constructor =Class.forName("java.lang.String").getConstructor(StringBuffer.class);

注意：一个类有多个构造方法，用什么方式可以区分清楚想得到其中的哪个方法呢？根据参数的个数和类型，例如，Class.getMethod(name,Class... args)中的args参数就代表所要获取的那个方法的各个参数的类型的列表。重点：参数类型用什么方式表示？用Class实例对象。

利用构造方法创建实例对象：

通常方式：String instance = new String(new StringBuffer("黑马程序员"));

反射方式：String instance = (String)constructor.newInstance("黑马程序员");

//调用获得的方法时要用到上面相同类型的实例对象

通过Class类中的newInstance()方法也可创建类的实例，其内部工作原理是先得无参的构造方法，再用构造方法创建实例对象。

代码示例：

package com.itheima.day01;

import java.lang.reflect.Constructor;

public class ReflectTest {

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

        Class clszz = Class.forName("java.lang.String");

        Constructor constructor = clszz.getConstructor(StringBuffer.class);

        String str = (String) constructor.newInstance(new StringBuffer("黑马程序员"));

        char [] chs = str.toCharArray();

        for(int x = 0; x<chs.length;x++){

            System.out.println(chs[x]);

        }

    }

}

成员变量的反射（Field类）

Field类代表反射某个类中的一个成员变量。

问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，那关联的是哪个对象呢？所以字段fieldAge 代表的是Age的定义，而不是具体的Age变量。

(注意访问权限的问题)也就是说，定义的是类对象，而非对象的对象。

当我们需要对其操作的时候，需要确定是那个具体的对象。

代码示例：

package com.itheima.study;

public class Person {

    public int age;

    private int height;

    public Person(int age,int height){

        this.age=age;

        this.height=height;

    }

}

package com.itheima.study;

import java.lang.reflect.Field;

public class ReflectTest{

    public static void main(String...args) throws Exception{

        Person p = new Person(20,30);

        Field fieldAge = p.getClass().getField("age");

        System.out.println(fieldAge.get(p));

    }

}

注意：如果类的某个成员变量的修饰符是private，那么直接通过getField方法获取Field类型的对象就会出现如下错误。如age是private的

 

注意：如果类的某个成员变量的修饰符是private，那么直接通过getDeclaredField方法获取Field类型的对象就会出现如下错误。

 

解决方案：

Field fieldAge =p.getClass().getDeclaredField("age");

fieldAge.setAccessible(true);

注意：通过称之为暴力反射的方式解决，也就是使用setAccessible(true)使private类型的成员变量也可以被获取值。

练习：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"CSDN社区"通过反射改成"黑马论坛"。

package com.itheima.day01;

public class ReflectPoint {

    public String str1 = "CSDN社区";

    public String str2 = "黑马程序员";

    public String str3 = "黑马程序员——戒风";

    @Override

    public String toString() {

        return str1 + "\n" + str2 + "\n" + str3;

    }

}

package com.itheima.day01;

import java.lang.reflect.Field;

public class ReflectTest {

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

        ReflectPoint rp = newReflectPoint();

        changeStringValue(rp);

        System.out.println(rp);

    }

    public static void changeStringValue(Object obj) throws Exception {

        Field[] fields = obj.getClass().getFields();

        for(Field field : fields){

            if(field.getType() == String.class){

                String oldValue = (String)field.get(obj);

                String newValue = oldValue.replace("CSDN社区", "黑马论坛" );

                field.set(obj, newValue);

            }

        }

    }

}

成员方法的反射（Method类）

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.4：public Object invoke(Objectobj,Object[] args)

JDK1.5：public Object invoke(Objectobj,Object... args)

即按JDK1.4的语法，需要将一个数组作为参数传递给invoke方法时，这时它会把一个数组作为一个元素。

这时如果我们要取出其中的元素，需要将数组中的元素通过数组一个个的取出。

所以，调用charAt方法的代码也可以用JDK 1.4改写为 charAt.invoke("str",new Object[]{1})形式。

代码示例：

package com.itheima.day1;

import java.lang.reflect.Method;

public class ReflectTest {

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

        String str = "黑马程序员";

        Method method = str.getClass().getMethod("charAt", int.class);

        //1.4写法。

        System.out.println(method.invoke(str,new Object[]{1}));

        //1.5写法。

        System.out.println(method.invoke(str, 0));

    }

}

对接收数组参数的成员方法进行反射

目标：写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。

package com.itheima.day01;

import java.lang.reflect.Method;

public class ReflectTest {

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

        Class clszz = Class.forName(args[0]);

        Method main = clszz.getMethod("main", String[].class);

        main.invoke(null,"黑马程序员","黑马论坛","CSDN社区");

    }

}

class TestArrayArguments {

    public static void main(String [] args)

    {

        for(String arg:args)

        {

            System.out.println("----------" + arg + "----------");

        }

    }

}

 

分析问题：这个问题是没有传入参数才发生的数组角标越界。

解决方法：右击Run As-->点击Run Configurations。

弹出如下窗口-->点击Arguments选项卡-->输入需要执行的main方法所在类全名。

点击Run，运行。

结果：

 

分析原因：启动Java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射

方式来调用这个main方法时，如何为invoke方法传递参数呢？

按JDK1.5的语法，整个数组是一个参数，而按JDK1.4的语法，数组中的每个元素对应一个参数，当把一个字符串

数组作为参数传递给invoke方法时，Javac会到底按照哪种语法进行处理呢？

JDK1.5肯定要兼容JDK1.4的语法，会按JDK1.4的语法进行处理，即把数组打散成若干个单独的参数。

所以，在给main方法传递参数时，不能使用代码main.invoke(null,"黑马程序员","黑马论坛","CSDN社区")，Javac只把它当作JDK1.4的语法进行理解，而不把它当作JDK1.5的语法解释，因此会出现参数类型不对的问题。

解决办法：

方法一：

main.invoke(null,new Object[]{new String[]{"黑马程序员","黑马论坛","CSDN社区"}});

方法二：

main.invoke(null,(Object)new String[]{"黑马程序员","黑马论坛","CSDN社区"});

编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了。

代码示例一：

package com.itheima.day01;

import java.lang.reflect.Method;

public class ReflectTest {

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

        Class clszz = Class.forName(args[0]);

        Method main = clszz.getMethod("main", String[].class);

        main.invoke(null,new Object[]{new String[]{"黑马程序员","黑马论坛","CSDN社区"}});

    }

}

代码示例二：

package com.itheima.day01;

import java.lang.reflect.Method;

public class ReflectTest {

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

        Class clszz = Class.forName(args[0]);

        Method main = clszz.getMethod("main", String[].class);

        main.invoke(null,(Object)new String[]{"黑马程序员","黑马论坛","CSDN社区"});

    }

}

数组与Object的关系及其反射类型

具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

package com.itheima.day01;

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()==a3.getClass());

        System.out.println(a1.getClass()==a4.getClass());

        System.out.println(a3.getClass()==a4.getClass());

    }

}

注意：如果元素类型不同或者维数不同的话，那么编译器直接不通过。

代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。

代码示例：

基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用;

非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

Arrays.asList()方法处理int[]和String[]时的差异。

代码示例：

package com.itheima.day01;

import java.util.Arrays;

public class ReflectTest {

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

        int[] arr =new int[] { 1, 2, 3 };

        String[] str =new String[] {"111", "222", "333" };

        // 直接使用System.out.println无法打印出数组的内容

        System.out.println(arr);

        // 结果：[I@15db9742

        System.out.println(str);

        // 结果：[Ljava.lang.String;@6d06d69c

        // 通过Arrays.asList方法打印出集合的内容

        System.out.println(Arrays.asList(arr));

        // 结果：[[I@15db9742]

        /*

* 原因是因为JDK1.4中为Arrays.asList(Object[] a)，JDK1.5中为Arrays.asList(T...a)。

* arr是int[]类型，JDK1.4中的asList方法处理不了，JDK1.5可以处理。但是JDK1.5将

* int数组整体作为一个参数进行处理。

* 因此最终结果就是将 int[]进行了封装，结果类型也就成了[[I。

*/

        System.out.println(Arrays.asList(str));

        // 结果：[111, 222, 333]

    }

}

getName

public String getName

以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。

如果此类对象表示的是非数组类型的引用类型，则返回该类的二进制名称，Java Language Specification, Second Edition 对此作了详细说明。

如果此类对象表示一个基本类型或 void，则返回的名字是一个与该基本类型或 void 所对应的 Java 语言关键字相同的String。

如果此类对象表示一个数组类，则名字的内部形式为：表示该数组嵌套深度的一个或多个 '[' 字符加元素类型名。元素类型名的编码如下：

Element Type		Encoding
boolean		Z
byte		B
char		C
class or interface		Lclassname;
double		D
float		F
int		I
long		J
short		S

类或接口名classname 是上面指定类的二进制名称。

返回：此对象所表示的类或接口名。

Array工具类用于完成对数组的反射操作。

代码示例：

package com.itheima.day01;

import java.lang.reflect.Array;

public class ReflectTest {

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

        String[] arrOne =new String[] {"黑马程序员", "黑马论坛", "CSDN社区"};

        String arrTo ="黑马程序员";

        printObject(arrOne);

        printObject(arrTo);

    }

    public 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);

        }

    }

}

ArrayList_HashSet的比较及Hashcode分析

分析：当集合为ArrayList时，其实是一个数组，因此放入4个元素后，集合size为4。

当集合为HashSet时，需要通过比较equals方法是否返回true决定是否放入。

如果equals方法返回true，那么就不会放入。因此，集合size为3。（覆盖其中一个）

如果想让size为2，也就是set1与set3作为同一个元素存入HashSet集合，那就需要覆盖ReflectPoint类的hashCode方法以及equals方法。（同时覆盖俩个方法）

在代码区右击-->Source-->点击Generate hashCode() and equals()...。

点击OK，即可生成hashCode和equals方法。

/*

@Override

public inthashCode() {

    final int prime = 31;

    int result = 1;

    result = prime * result + x;

    result = prime * result + y;

    return result;

}

@Override

publicboolean equals(Object obj) {

    if (this == obj)

    return true ;

    if (obj == null)

    return false ;

    if (getClass() != obj.getClass())

    return false ;

    ReflectPoint other = (ReflectPoint) obj;

    if (x != other.x)

    return false ;

    if (y != other.y)

    return false ;

    return true ;

}

*/

重新运行ReflectTest就可以看到size值为2。

注意：当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，从而造成内存泄露。

框架的概念及用反射技术开发框架的原理

框架：我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

框架要解决的核心问题：我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new某个类的实例对象了，而要用反射方式来做。

用类加载器的方式管理资源和配置文件

package cn.itcast.day1;

import java.io.FileInputStream;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashSet;

import java.util.Properties;

public class ReflectTest2 {

    /**

     * @param args

     */

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

        // TODO Auto-generated method stub

        /*getRealPath();//金山词霸/内部

        一定要记住用完整的路径，但完整的路径不是硬编码，而是运算出来的。*/

        //InputStream ips = newFileInputStream("config.properties");

        //InputStream ips =ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/day1/config.properties");

        //InputStream ips =ReflectTest2.class.getResourceAsStream("resources/config.properties");

        InputStream ips = ReflectTest2.class.getResourceAsStream("/cn/itcast/day1/resources/config.properties");

        Properties props = new Properties();

        props.load(ips);

        ips.close();

        String className = props.getProperty("className");

        Collection collections = (Collection)Class.forName(className).newInstance();

        //Collection collections = new HashSet();

        ReflectPoint pt1 = newReflectPoint(3,3);

        ReflectPoint pt2 = newReflectPoint(5,5);

        ReflectPoint pt3 = new ReflectPoint(3,3);  

        collections.add(pt1);

        collections.add(pt2);

        collections.add(pt3);

        collections.add(pt1);  

        //pt1.y = 7;       

        //collections.remove(pt1);

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

    }

}