java反射

反射（个人理解）：已知一个对象，可以通过反射方法获得对象的类类型，通过调用类类型来获得该类类型里面封装的方法、成员变量、构造函数等

一、Class类

（1）在面向对象的世界里，万事万物皆对象

java语言中，静态的成员（属于类）、普通的数据类型不是对象。（对象是new一个类实例化得到的）

类是对象，类是java.lang.Class类的实例对象

实例化Class类的实例对象有三种方法，如下代码所示

class Foo{
    public void printfoo(){
        System.out.println("foo");
    }
}

public class ClassDemo {
    public static void main(String[] args) {
        //Foo的实例化表示
        Foo f1=new Foo();
        //Foo这个类也是一个实例对象，是Class的实例对象，如何表示？
        //任何一个类都是Class的实例对象，这个实例对象有三种表达方式

        //第一种表达方式----> 已经知道该类的对象，通过getClass方法
        Class c1=f1.getClass();
        //第二种表达方式----> 任何一个类都有一个隐含的静态成员变量class
        Class c2=Foo.class;

        /*
        官网c1  c2 表示了Foo类的类类型。万事万物皆对象，类也是对象，是Class类的实例对象，这个对象我们称之为该类的类类型
         */
        //true---->不管c1或c2都代表了Foo类的类类型，一个类只可能是Class类的一个实例对象
        System.out.println(c1==c2);
        //第三种表达方式
        Class c3=null;
        try {
            c3=Class.forName("Foo");//写法：Class.forName("类所在的包（不用写src）.类名")
            System.out.println(c3);//输出 class Foo
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //true
        System.out.println(c2==c3);

    }

}

二、动态加载类

编译时刻加载类是静态加载类，运行时刻加载类是动态加载类

Class.forName（“类的全称”）不仅代表了类的类类型，还代表了动态加载类

new创建对象是静态加载类，如果没有实现类，就new类的对象，会在编译的时候就报错。

通过动态加载类创建对象：

Class c1=Class.forName("包名.类名");

c1.newInstance();

---

Dynamic.java

package Reflection;

public class Dynamic {
    public static void main(String[] args1) {
        System.out.println(new Word().getClass().getName());
        if("Word".equals(args1[0])){//与运行时输入的参数作比较
            try {
                Office OF= (Office) Class.forName("Reflection."+args1[0]).newInstance();
                OF.start();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if("Excel".equals(args1[0])){
            try {
                Office OF= (Office) Class.forName("Reflection."+args1[0]).newInstance();
                OF.start();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Office.java

package Reflection;

public interface Office {
    public void start();
}

Excel.java

package Reflection;

public class Excel implements Office{
    public void start(){
        System.out.println("excel.....start");
    }
}

Word.java

package Reflection;

public class Word implements Office{
    public void start(){
        System.out.println("word.....start");
    }
}

实现Office接口，使Word和Excel都实现这个接口，在调用方法的时候就可以使用Office来接受Word和Excel的对象。

---

基本的数据类型、基本数据类型的封装类、void关键字都有类类型

package Reflection;

public class ClassDemo {
    public static void main(String[] args) {
        Class c1=int.class;
        Class c2=double.class;
        Class c3=Double.class;
        Class c4=void.class;
        Class c5=String.class;
        Class c6=Character.class;
        System.out.println(c3.getName());//java.lang.Double
        System.out.println(c5.getName());//getName()返回类的全称，包含包名     java.lang.String
        System.out.println(c5.getSimpleName());//getSimpleName()只返回类名，没有包名    String
        System.out.println(c6.getSimpleName());//Character
    }
}

三、获取类信息（方法、成员变量、构造函数）

1、方法也是对象。java.lang.reflect.Method类封装了方法的信息

2、成员变量也是对象。java.lang.reflect.Filed封装了关于成员变量的信息和操作

3、构造函数也是对象。java.lang.reflect.Constructor封装了关于构造函数的信息和操作

GetMethods.java里包含了获取类的方法、成员变量和构造函数的信息的方法

package Reflection;

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

public class GetMethods {
    public static void printMethodsMessage(Object o){
        //要获取类的信息，首先要获取类的类类型
        Class c1=o.getClass();//传递的是哪个子类的对象，c1就是该类的类类型
        //获取类的名称
        System.out.println("类的名称是："+c1.getName());
        /*
        Method类，是方法对象。一个方法就是一个Method类的对象
        getMethods()获取的是所有的public方法，包括从父类继承而来的
        getDeclaredMethods()获取的是该类自己声明的所有方法，不问访问权限
         */
        Method[] ms=c1.getMethods();
        for(int i=0;i<ms.length;i++){
            //得到方法的返回值类型的类类型
            Class c=ms[i].getReturnType();
            System.out.println(c.getName()+" ");
            //得到方法的名称
            System.out.print(ms[i].getName()+"(");
            //获得每个方法的参数类型的名称
            Class[] Parameter=ms[i].getParameterTypes();
            for(Class clas1:Parameter){
                System.out.print(clas1.getName()+",");
            }
            System.out.println(")");
        }

    }

    public static void printFieldMessage(Object c1) {
        //Field类封装了类的成员变量的信息
        //getFields()获取的是类里面所有的public的成员变量
        //getDeclaredFields()获取的是类里面自己定义的所有成员变量，包括private的
        //Field[] f=c1.getFields();
        Class n=c1.getClass();
        Field[] f1= n.getDeclaredFields();
        for(Field f:f1){
            //得到成员变量的类型的类类型
            Class cs=f.getType();
            String s1=cs.getName();
            //得到成员变量的名称
            String s2=f.getName();
            System.out.println(s1+".."+s2);
        }
    }

    public static void printConMessage(Object c1){
        //构造函数也是对象
        // java.lang.reflect.Constructor中封装了构造函数的信息
        //getDeclaredConstructors()获取的是类定义的所有的构造函数
        // getConstructors()获取的是类里面所有的public的构造函数
        Class c=c1.getClass();
        //Constructor[] cs=c.getConstructors();
        Constructor[] cs1=c.getDeclaredConstructors();
        for(Constructor cc:cs1){
            System.out.print(cc.getName()+"(");
            //获取构造函数的参数列表，得到的是参数列表的类类型
            Class[] tt=cc.getParameterTypes();
            for(Class cl:tt){
                System.out.print(cl.getName()+",");
            }
            System.out.println(")");
        }
    }
}

classDemo.java里是调用方法

package Reflection;

public class ClassDemo {
    public static void main(String[] args) {
        String s1="hh";
        GetMethods.printMethodsMessage(s1);
        GetMethods.printFieldMessage(s1);
        GetMethods.printConMessage(s1);
    }
}

四、方法反射

（1）如何获取某个方法

方法的名称和方法的参数列表才能唯一决定某个方法

（2）方法反射的操作

method.invoke（对象，参数列表）

package Reflection;

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

public class MethodReflect {
    public static void main(String[] args) {
    //要获取print（int,int）方法，要获取一个方法实际上就是要获取一个类的信息，获取类的信息首先要获取类的类类型
        A a=new A();
        Class c=a.getClass();
        //getDeclaredMethod（“方法名称”,class<存放参数的class>）获取该类自己声明的所有方法
        try {
            Method m=c.getDeclaredMethod("print", int.class, int.class);
            //一般的调用方法a.print(10,20);  对象调用方法
            //方法的反射操作是调用c对象来进行方法调用。和a.print(10,20)的效果一样
            //通过invoke方法来实现方法的反射。invoke(对象的名称，Object类型的传递的参数)，这个方法是有返回值的，返回值的类型是Object的，可能需要强制类型转化。如果调用的方法本身没有返回值，呢么返回null，如果有返回值则返回对应的返回值
            Object o=m.invoke(a, 10,20); //方法调用对象

            Method m2=c.getDeclaredMethod("print", String.class,String.class);
            Object o1=m2.invoke(a,"hello","world");

            //如果方法没有参数，就只写方法名称即可
            Method m3=c.getDeclaredMethod("print");
            m3.invoke(a);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}
class A{
    public void print(){
        System.out.println("helloworld");
    }
    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());
    }
}

五、通过反射了解集合泛型的本质

泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。编译之后的集合的泛型是去泛型化的。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

package Fanxing;

import java.io.ObjectInputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

public class TestFan {
    public static void main(String[] args) {
        ArrayList a=new ArrayList();
        ArrayList<String> b=new ArrayList<String>();
        b.add("1");
        //b.add(0); 会报错
        Class c1=a.getClass();
        Class c2=b.getClass();
        System.out.println(c1==c2);//true
        /*
        c1==c2结果返回true说明编译之后的集合的泛型是去泛型化的
        Java中的集合的泛型，是防止错误输入的，只在编译阶段有效，绕过编译就无效了
         */
        //反射的操作都是编译之后的操作。
        // 验证：可以通过方法的反射来操作，绕过编译
        try {
            Method m=c2.getMethod("add", Object.class);
            try {
                m.invoke(b,20);
                System.out.println(b.size());
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}