反射

在java运行环境中，对任意一个类能否知道这个类有哪一些方法？对于任意一个对象，能否调用他的任意一个方法？答案是肯定的。这种动态获取类信息以及动态调用对象的方法的功能来自java的反射机制，在java.lang.reflect包下有三个类Field、Method、Constructor。分别用来描述类的域、方法和构造器。
java反射机制主要提供一下功能
1、在运行时判断任意一个对象所属的类。
2、在运行时构造任意一个类的对象。
3、在运行时判断任意一个类所具有的成员变量和方法。
4、在运行时调用任意一个对象的方法。
Reflection 是java被视为动态语言（准动态语言）的一个关键性质。这个机制允许程序在运行时透过Reflection APIs去获取任何一个已知名称的class的内部信息，包括其modifiers（public，static等等）、superclass（Object）、实现interface（Serializable），也包括fields和methods的所有信息，并可于运行时改变fields内容和methods的所有信息，并可用于运行时改变fields内容或调用methods
尽管java不是动态语言，他却有一个动态机制：reflection，在Java身上指的是我们可以运行时加载、探知、适应编译期间完全未知的classes。换句话说，java程序可以加载一个运行时在得知名称的class，知道其完整的构造（不包括methods定义），并生成对象实体、或对其fields设置、或唤起其methods。这种看透class的能力。
在java中，无论生成某个类的多少对象，这些对象都会应与同一个对象。

import java.lang.reflect.Method;

public class DumpMethods {
    public static void main(String[]args)throws Exception{
        Class<?> classType=Class.forName("java.lang.String");
        Method[] methods=classType.getDeclaredMethods();
        for ( Method method:methods){
            System.out.println(method);
            //可以得到String类里面的所有方法
        }
    }
}

import java.lang.reflect.Method;

public class InvokeTester {
    public int add(int param1,int param2){
        return param1+param2;
    }
    public String echo(String message)
    {
        return "helle "+message;
    }
    public static void main(String[]args)throws Exception{
//        获取对象的第一种方式
//       InvokeTester test=new InvokeTester();
//        System.out.println(test.add(1,2));
//        System.out.println(test.echo("tom"));
        //获取对象的第二种方式
        Class<?> classType=InvokeTester.class;
        Object invokeTest=classType.newInstance();
        //判断是否实例化
        System.out.println(invokeTest instanceof InvokeTester);
        Method method=classType.getMethod("add",new Class[]{int.class,int.class});
        Object result=method.invoke(invokeTest,new Object[]{1,2});
        System.out.println((Integer) result);
        //第二种方法
        Method getmethod=classType.getMethod("echo",new Class[] {String.class});
        Object result2= getmethod.invoke(invokeTest,new Object[]{"tom"});
        System.out.println((String)result2);
    }
}

要想使用反射，首先需要获得待处理类或对象所对应的Class对象。
获取某个类或某个对象的Class对象的三种方式:
1、使用Class类的静态方法：forName：Class.forName。
2、使用 .class语法。
3、使用对象的getClass方法：String s=“aa”；Class<?> clss=s.getClass；
若想通过类的不带参数的构造方法来生成对象，两种方式：
1、先获得Class的对象，然后通过Class对象newInstance（）直接生成;Class<?> classType=String.class;Object obj=classType.newInstance();
2、先获得Class对象，然后通过该对象获得对应的Constructor对象，在通过Constructor对象的newInstance方法生成：Class<?> classType=Customew.class; Constructor cons=class.Type.getConstructor(new Class[]{}); Object obj=cons.newInstance(new Object[]{});
若想通过类带参数的构造方法生成对象，有一种方法
Class<?> classType=Customew.class;
Constructor cons=class.Type.getConstructor(new Class[]{String.class,int.class});
Object obj=cons.newInstance(new Object[]{“hello”,4});

package reflect;

import java.lang.reflect.Field;

public class PrivateTest {
    private String name="zhangsan";
    public String getName(){
        return name;
    }
}
class Private{
        public static void main(String []args) throws Exception {
            PrivateTest p=new PrivateTest();
            Class<?> classType=p.getClass();
            Field field=classType.getDeclaredField("name");
            field.setAccessible(true);
            field.set(p,"lishi");
            System.out.println(p.getName());
        }
}

package reflect;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class PrivateTest {
    private String getName(String name){
        return name;
    }
}
class Private{
        public static void main(String []args) throws Exception {
            PrivateTest p=new PrivateTest();
            Class<?> c=p.getClass();
            Method method=c.getDeclaredMethod("getName",new Class[]{String.class});
            method.setAccessible(true);
            String str=(String)method.invoke(p,new Object[]{"zhangsan"});
            System.out.println(str);
        }