欢迎使用CSDN-markdown编辑器

反射–Reflect

1. Class类的使用

• 万物皆对象，类也是对象，类是java.lang.Class类的实例对象。
• Class类是私有的构造方法，在类的外部是不能访问的，只有Java的虚拟机可以创建Java的实例对象，不可以用new的形式来创建。
• 任何一个类都是Class类的实例对象，这个实例对象有三种表示方式:

public class Demo1 {
    public static void main(String[] args) {
        Foo foo = new Foo();
        //第一种———>任何一个类都有一个隐含的静态成员变量class
        Class c1 = Foo.class;
        //第二种———>已经知道该类的对象，通过getClass()
        Class c2 = foo.getClass();
        System.out.println(c1==c2);
        //类是Class类的实例对象，这个对象我们称之为该类的类类型
        //不管c1还是c2都代表了Foo类的类类型，一个类只能是Class类的一个实例对象
        //第三种-->通过Class.forName("类的全称")
        Class c3 = null;
        try {
            c3 = Class.forName("Foo");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
        //通过类类型来创建该对象
            Foo foo2 = (Foo)c1.newInstance();//需要有无参数的构造方法
            foo2.print();
        } catch (InstantiationException | IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
    }

}

class Foo{
    void print(){
        System.out.println("fff");
    }
}

2.动态加载类

• 通过Class.forName(“类的全称”)不仅表示了该类的类类型，还代表了动态加载类
• 一定要区分编译和运行
• 编译时刻加载类是静态加载类，运行时刻加载类是动态加载类
• new对象是静态加载类，在编译时刻就需要加载所有的可能使用到的类

public class Office {
    public static void main(String[] args) {
        if("Word".equals(args[0])){
            Word w = new Word();
            w.start();
        }
        if("Excel".equals(args[0])){
            Excel e = new Excel();
            e.start();
        }
    }
}

• 通过类类型创建该对象 (强制类型转换)c.newInstance()

public class Office {
    public static void main(String[] args) {
        try {
            //动态加载类，在运行时加载
            Class c = Class.forName(args[0]);
            //通过类类型，创建该类对象
            //Word w = c.newInstance();
            //Excel e = c.newInstance();
            OfficeAble oa = c.newInstance();
            oa.start();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

• 功能性的类一般使用动态加载而不能使用静态加载

3.获取方法信息

import java.lang.reflect.Method;

public class Demo2 {
    /**
     * 获取成员函数的信息
     * @param obj
     * 
     */
    public static void printClassMessage(Object obj){
        // 要获取类的信息，首先要获取类的类类型
        Class c = obj.getClass();//传递的是哪个子类的对象，c就是该子类的类类型
        //获取类的名称
        System.out.println(c.getName());
        /*获取类的对象
         *Method类，方法对象
         *一个成员方法就是一个Method对象
         *getMethods()方法获取的是所有的public的函数，包括父类继承而来的 
         *getDeclaredMethods()获取的是所有该类自己生命的方法，不问访问权限
         * 
         */
        Method[] ms = c.getMethods();
        //Method[] ms = c.getDeclaredMethods();
        for(int i=0;i<ms.length;i++){
            //获取方法的返回值类型的类类型
            Class returnType = ms[i].getReturnType();
            System.out.println(returnType.getName());
            //获取方法的名称
            System.out.println(ms[i].getName());
            //获取参数类型，得到的是参数列表的类型的类类型
            Class[] paramTypes = ms[i].getParameterTypes();
            for(Class class1:paramTypes){
                System.out.println(class1.getName());
            }
        }
    }
}

4.获取成员变量构造函数信息

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class Demo3 {
    /**
     * 成员变量也是对象
     * java.lang.reflect.Field
     * Field封装了关于成员变量的操作
     * getFields()获取的是所有public的成员变量的信息
     * getDeclaredFields()方法获取的是该类自己声明的成员变量的信息
     */
    public static void printClassMessage(Object obj){
        Class c = obj.getClass();
        //Field[] fs = c.getFields();
        Field[] fs = c.getDeclaredFields();
        for(Field field:fs){
            //得到成员变量的类型的类类型
            Class fieldType = field.getType();
            //得到成员变量的名字
            String typeName = fieldType.getName();
        }
    }
    /**
     * 打印对象的构造函数的信息
     * @param obj
     */
    public static void printConMessage(Object obj){
        Class c = obj.getClass();
        /*
         * 构造函数也是对象
         * java.lang.Construct中封装了构造函数的信息
         * getConstructors()获取所有的public的构造方法
         * getDeclaredConstructors()得到所有的构造函数
         */
        //Constructor[] cs = c.getConstructors();
        Constructor[] cs = c.getDeclaredConstructors();
        for(Constructor constructor:cs){
            System.out.println(constructor.getName());
            //获取构造函数的参数列表-->得到的是参数列表的类类型
            Class[] paramTypes = constructor.getParameterTypes();
            for(Class class1:paramTypes){
                System.out.println(class1.getName());
            }
        }
    }
}

5.方法反射的基本操作

• 如何获取某个方法
  
  • 方法的名称和参数列表才能唯一决定某个方法
• 方法反射的操作
  
  • method.invoke(对象，参数列表)

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Demo4 {
    public static void main(String[] args) {
        //获取print(int ,int )方法
        A a1 = new A();
        Class c = a1.getClass();
        /**
         * getMehtod()方法获取的是public的方法
         * getDeclaredMethod()方法获取的是自己声明的方法
         */
        //c.getMethod("print", parameterTypes)
        try {
            Method m = c.getDeclaredMethod("print", new Class[]{int.class,int.class});
            //("print", int.class,int.class)
            //方法的反射操作是用m对象来进行方法调用，和a1.print调用的效果一样
            //方法如果没有返回值则返回null，有返回值则返回具体的返回值
            //Object o = m.invoke(a1, new Object[]{10,20});
            Object o = m.invoke(a1, 10,20);
            //获取方法对象
            Method m1 = c.getMethod("print", String.class,String.class);
            //用方法进行反射操作
            m1.invoke(a1, "hello","world");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
    }
}

class A{
    public void print(int a,int b){
        System.out.println(a+b);
    }
    public void print(String a,String b){
        System.out.println(a.toUpperCase()+","+b.toLowerCase());
    }
}

6.通过反射了解集合类型的本质

import java.lang.reflect.Method;
import java.util.ArrayList;

public class Demo5 {
    public static void main(String[] args) {
        ArrayList a1 = new ArrayList();
        ArrayList<String> a2 = new ArrayList<String>();
        Class c1 = a1.getClass();
        Class c2 = a2.getClass();
        System.out.println(c1==c2);//true
        //反射的操作都是编译之后的操作
        /**
         * c1==c2结果返回true说明编译之后集合的泛型是去泛型化的
         * Java中集合的泛型，是防止错误输入的，只在编译阶段有效，绕过编译就无效
         * 验证：我们可以通过方法的反射来操作，绕过编译
         */
        Method m;
        try {
            m = c2.getMethod("add", Object.class);
            m.invoke(a2, 100);//绕过了编译操作就绕过了泛型
            System.out.println(a2);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
    }
}