java反射

java反射

---

反射机制是什么：

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

---

机制的优点和缺点：

为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，

1. 关于动态加载：Class.forname(“类全名”);
   动态加载是在用到时才进行加载。动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。
2. 关于静态加载：new Foo();
   静态加载在编译就需要加载所有用到的类。
   反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中 它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编 译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如 这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功能。
   它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它 满足我们的要求。这类操作总是慢于只直接执行相同的操作。

---

最近又看反射觉得很叼，所以就看了看
我们用java官方文档来说一下反射的用途，以及反射的优缺点

反射的用途

反射被广泛地用于那些需要在运行时检测或修改程序行为的程序中。这是一个相对高级的特性，只有那些语言基础非常扎实的开发者才应该使用它。如果能把这句警示时刻放在心里，那么反射机制就会成为一项强大的技术，可以让应用程序做一些几乎不可能做到的事情。

反射的缺点

尽管反射非常强大，但也不能滥用。如果一个功能可以不用反射完成，那么最好就不用。在我们使用反射技术时，下面几条内容应该牢记于心：

性能第一 Performance Overhead

反射包括了一些动态类型，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被 执行的代码或对性能要求很高的程序中使用反射。

安全限制 Security Restrictions

使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如 Applet，那么这就是个问题了。

内部暴露 Exposure of Internals

由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用－－代码有功能上的错误，降低可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化

---

class类的使用

在面向对象的世界里万事万物皆对象。java语言中类也是对象，是java.lang.Class的实例对象
class类的实例对象表示方法：

package fanshe;

public class Fanshedemo {
    public static void main(String[] args) {
        // 第一种表示方式，类名.class-----说明任何一个了都有一个隐含的成员变量
        Class foo1 = Foo.class;
        // 第二种表示方式，知道该类的对象通过对象.getclass（）
        Foo f = new Foo();
        Class foo2 = f.getClass();
        // foo1 foo2 表示Foo类的类类型（class type）
        try {
        //通过class.forname（）动态加载
            Class foo3 = Class.forName("类全名");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

}

class Foo {
}

创建对象：获取类以后我们来创建它的对象，利用newInstance：

foo1.newInstance();
//可以获取Foo的实例对象，但是Foo必须有一个参数为空的构造方法

---

获取方法的信息：

package fanshe;

import java.lang.reflect.Method;

public class ClassUtil {
    public static void printf(Object obj){
        //获取类的类类型
        Class c = obj.getClass();
        System.out.println("类的全称："+c.getName());
        Method[] method = c.getMethods();
        //getMethod获取的是所有public的方法包括继承父类的
        //getDeclaredMethods()获取类自己申明的方法
        for(Method m:method){
            //得到方法的返回值类型的类类型
            Class returnType = m.getReturnType();
            System.out.println("方法的返回值："+returnType);
            //方法的名称
            System.out.println("方法的名称："+m.getName());
            //获取参数类型
            Class[] paramTypes = m.getParameterTypes();
            for(Class cl:paramTypes){
                System.out.print(cl.getName());
            }
        }
    }
    public static void main(String[] args) {
        new ClassUtil().printf("hello");

    }
}

---

获取成员变量的信息：

成员变量也是对象，是java.lang.reflect.Field类的对象。

public class ClassUtil {
    public static void printf(Object obj) {
        // 获取类的类类型
        Class c = obj.getClass();
        Field[] fd = c.getDeclaredFields();
        // getFields();获取所有public的成员变量
        // getDeclaredFields()获取自己定义的成员变量
        for (Field f : fd) {
            Class classtype = f.getType();// 获取成员变量的类星的类类型
            String typename = classtype.getName();
            String name = f.getName();// 获取成员变量的名称
            System.out.println(typename + " " + name);
        }
    }

    public static void main(String[] args) {
        new ClassUtil().printf("hello");
    }
}

---

获取构造函数的信息：

成员变量也是对象，是java.lang.reflect.Constructor类的对象。

package fanshe;

import java.lang.reflect.Constructor;

public class ClassUtil {
    public static void printf(Object obj) {
        // 获取类的类类型
        Class c = obj.getClass();
        // 构造函数也是对象
        Constructor[] fd = c.getDeclaredConstructors();
        // getDeclaredFields()获取自己定义的构造方法
        for (Constructor f : fd) {
            System.out.print(f.getName());
            Class[] ParameterTypes = f.getParameterTypes();// 获取构造函数的成员列表
            for (Class clp : ParameterTypes) {
                System.out.print(clp.getName() + ",");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        new ClassUtil().printf("hello");
    }
}

---

方法的反射：

1. 如何获取某个方法（方法的名称和方法的参数列表能够唯一确定一个方法）
2. 方法的反射操作（method.invoke（对象，参数列表））

package fanshe;

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

public class Methoddemo {
    public static void main(String[] args) {
        A a = new A();
        Class c = a.getClass();
        try {
            Method m = c.getMethod("print", String.class, String.class);
            m.invoke(a, "hello", "fanshe");
            //反射操作
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class A {
    public void print(int a) {
        System.out.println(a);
    }

    public void print(String a, String b) {
        System.out.println(a.toLowerCase() + b.toLowerCase());
    }
}

---

通过反射了解集合的泛型

package fanshe;

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

public class List__test {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        List list2 = new ArrayList<>();
        System.out.println(list1==list2);
//      list1.add(10);这个是错误的
        list1.add("hello");
        Class c1 = list1.getClass();
        Class c2 = list2.getClass();
        System.out.println(c1==c2);
        //反射的操作都是编译后的操作
//      c1==c2结果返回true说明编译之后集合是去泛型化的
//      java中的集合是防止错误输入的，只有在编译阶段有效，绕过编译就无效
//      验证：通过方法的反射来操作
        try {
            Method m = c1.getMethod("add", Object.class);
            m.invoke(list1, 100);
            //绕过编译即可绕过泛型添加int类型的数据
            System.out.println(list1.size());
            System.out.println(list1);
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
}