反射----Java高级开发必须懂的

定义：

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

1.在面向对象的世界里，万事万物皆对象。

java语言中，静态的成员、普通数据类型是不是对象呢？不是

类是谁的对象呢？
类是对象，类是java.lang,Class类的实例对象。

好比，自定义一个student对象，student是Student类的实例对象。

任何一个类，都是Class的实例对象，这个实例对象有3中表示方式。

类名.class

对象.getClass()

Class.forName("全类名")

类类型：类也是一个对象，这个对象，我们叫它为类类型。

注意：一个类只可能是class类的一个实例对象。

可以通过类的类类型创建该类的实例对象。

Class s=Student.class;//这个s就是类类型
Student s1=(Student)s.newInstance();

通过new创建对象，都是静态加载类，在编译时刻就需要加载所有的可能使用到的类。

通过Class.forName();是动态加载类，在运行时刻加载

反射的作用：

反射提高程序的灵活性和扩展性，低耦合。常用于系统架构和框架搭建。

代码演示：
1.反射获取方法、成员变量、构造函数的信息

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

public class Demo3 {
    
    /**
     * 反射获取方法信息
     * @author Administrator
     *
     */
    public static void printClassMessage(Object obj){
        //首先获取类的信息  首先要获取类类型
        Class c=obj.getClass();  //c就是Object这个类的类类型
        //获取类的名称
        System.out.println("类的名称："+c.getName());
        //获取所有public的函数，包括父类继承而来的
        Method[] methods = c.getMethods();
        //获取所有该类自己声明的方法，不问访问权限
        Method[] ms = c.getDeclaredMethods();
        for (int i = 0; i < ms.length; i++) {
            //获取方法的返回值类型
            Class<?> returnType = ms[i].getReturnType();
            //返回值类型的类类型
            System.out.print(returnType.getName()+" ");
            //得到方法的名称
            System.out.print(ms[i].getName()+"(");
            //获取参数列表的类型的类类型
            Class<?>[] parameterTypes = ms[i].getParameterTypes();
            for (Class<?> class1 : parameterTypes) {
                System.out.print(class1.getName()+",");
            }
            System.out.println(")");
            
            printFieldMessage(c);
        }
        
    }
    /**
     * 反射获取成员变量信息
     * @author Administrator
     *
     */
    public  static void printFieldMessage(Object obj) {
        Class c=obj.getClass();
        /*
         * 成员变量也是对象
         * Filed类封装了关于成员变量的操作
         */
        //获取所有public的成员变量的信息
        Field[] fs = c.getFields();
        //获取所有自己声明的成员变量的信息，公有、私有都有
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            //得到成员变量的类型的类类型
            Class<?> fieldType = field.getType();
            String typeName = fieldType.getName();
            System.out.println();
            //得到成员变量的名称
            String fieldName = field.getName();
            System.out.println(typeName+" "+fieldName);
        }
    }
    
    /**
     * 打印对象的构造函数的信息
     */
    public static void printConsMessage(Object obj){
        Class c=obj.getClass();
        /**
         * 构造函数也是对象
         * java.lang.Constructor中封装了构造函数的信息
         */
        //获取所有Public的构造函数
        Constructor[] constructors = c.getConstructors();
        //获取所有自己声明的构造函数
        Constructor[] cs = c.getDeclaredConstructors();
        for (Constructor constructor : cs) {
            System.out.print(constructor.getName()+"(");
            //获取构造函数的参数列表的类类型
            Class[] parameterTypes = constructor.getParameterTypes();
            for (Class class1 : parameterTypes) {
                System.out.print(class1.getName()+",");
            }
            System.out.println(")");
        }
        
    }
    public static void main(String[] args) {
//        String s="hello";
//        Demo3.printClassMessage(s);
//        Demo3.printClassMessage(new String());
//        Demo3.printFieldMessage(new Integer(1));
        Demo3.printConsMessage(new Integer(1));
        
    }

}

2.方法反射的基本操作

import java.lang.reflect.Method;
/**
 * 方法反射的基本操作
 * @author Administrator
 *
 */
public class MethodDemo {

    public static void main(String[] args) {
        //获取一个方法就是获取类的信息，获得类的信息首先就要获得类的类类型
        A a1=new A();
        Class c = a1.getClass();
        //获取Public的方法
//        c.getMethod(name, parameterTypes);
        try {
//            c.getMethod("print", new Class[]{int.class,int.class});
            Method m = c.getMethod("print", int.class,int.class);//同上意思一样，可变参数
            //方法的反射操作
            //方法如果没有返回值，返回null，有返回值，就要强制类型转换，返回具体的返回值
            Object o=m.invoke(a1,new Object[]{10,20});
            System.out.println("================");
            Method m1=c.getMethod("print", String.class,String.class);
            m1.invoke(a1, "Hello","World");
        } catch (Exception e) {
            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());
    }
}

3.反射与泛型

import java.util.ArrayList;
import java.util.List;

public class Fanxing {

    public static void main(String[] args) {

     List list=new ArrayList();
     List<String> list1=new ArrayList<String>();
     Class<? extends List> class1 = list.getClass();
     Class<? extends List> class2 = list1.getClass();
     System.out.println(class1==class2);//true

    }

}

泛型只在编译阶段有效，使用反射技术，可以绕过泛型，达到去泛型化的效果

反射的操作，Class类的操作，Fileld类的操作，方法的操作。都是在编译之后的操作，就是在动态运行时候操作的