反射

得到某个类的构造方法：

1、得到一个类所有的构造方法：

Constructor[] constructors =

     Class.forName("java.lang.String").getConstructors();

或者：

Constructor[] constructors =String.class.getConstructors();

2、（根据传入参数）得到一个类某个构造方法

Constructor constructor =

Class.forName("java.lang.String").getConstructor(

StringBuffer.class);

String name =(String)constructor.newInstance(new StringBuffer("abc"));

其中，getConstructor()中StringBuffer.class是String方法的构造方法参数，用来确定反射哪一个构造方法，newInstance()中StringBuffer是实际传入的参数。

得到某个类的成员变量:

类user有两个变量:

public String name=”zhangsan”;

  private String password=”123”;

若要获得这两个变量：

1、可以通过直接实例化这个方法，然后获取：

user u = new user();

String name = u.name;

2、也可以通过反射的方法获得，而且通过反射可以获得私有的方法：

user u = new user();

Field field = u.getClass().getField("name");   //这时，获得的field不是u对象上的，而是user类（字

节码）上的，不能直接获得“zhangsan”String name = field.get(u);      //这时获得的就是u的name属性值

由于password属性是私有方法，直接获取：Field field = u.getClass().getField("password");会报错，

提示没有这个方法，是因为私有方法通过getField()是不显示的。需要通过getDeclaredField()方法，

该方法可以获取所有声明的方法，因此也就可以获取私有方法，但是通过：

Field field = u.getClass().getDeclaredField("password");仍然会报错，提示没有权限获取私有方法，

这时需要field.setAccessible(true);将field访问权限设置为true，这时，就可以访问私有方法，这

种方法称为“暴力反射”，String password = field.get(u); 

3、 使用Class.forName()方式获取，调用时，需要使用实例化的对象，例如：

Field f = Class.forName("ceshi.fansheTest").getDeclaredField("password");

  f.setAccessible(true);

String ps =

(String)f.get(Class. forName( "ceshi.fansheTest").newInstance());

得到某个类的成员方法：

1、  Method method =

Class.forName("java.lang.String").getMethod("charAt",int.class);

先通过反射，获得类的方法，其中charAt是方法名称，int.class是方法的参数类型，然后method调用invoke方法（直接调用name.charAt(1)）：

String name = "abc";

     System.out.println(method.invoke(name, 1));

2、 和成员变量类似，同样可以获得私有的方法：

Method m = Class.forName("ceshi.fansheTest").getDeclaredMethod("say2", String.class);

      m.setAccessible(true);

    System. out.println(m.invoke(Class. forName( "ceshi.fansheTest").newInstance(), "hh"));

通过反射执行某个类的main方法：

可以直接通过方法名称去调用main方法，例如类user中的main方法，在其他类中，可以通过

user.main(args);直接调用，但是，如果方法名是动态变化的，或者是使用者传入的，那

么，使用实例化方法，然后直接调用就不现实，因为根本就不知道将要调用的方法，也就不知道

去实例化哪个方法了。

通过反射的方式去调用某个类的main方法：

Method m =Class.forName("noli.ceshi").getMethod("main",String[].class);

m.invoke(null, (Object)newString[]{"123","12321"});

在调用main方法时需要注意，invoke调用时，main方法的参数为string数组，但是系统会将String[]看作是对象数组，会将数组打开接受参数，所以需要将数组转换为Object处理。

 

得到某个类（方法）：

获得类（方法）的方式有三种：

a)  Class.forName

(ceshi)Class.forName("com.ceshi").newInstance()).say("hello")

调用方法前需要将对象转换为ceshi类型，否则编译器无法识别。

b)  实例对象.class

ceshi.class.newInstance().say("nihao")

c)  实例对象getClass

ceshi c = new ceshi();

c.getClass().newInstance().say("nihao")

三种方式的区别：

a) Class c = 类名.class   将类装入内存（若有多个同名的类分布在不同的包中，则默认为本包下的，若是其他包下的，需要import引入路径），但不对类进行初始化，返回类的class对象。

b) Class c = 对象引用.getClass  返回引用运行时真正所指的Class对象。

c) Class.forName(“类名”)  将类装入内存，并进行初始化（未进行实例化，进行实例化需要调用newInstance()方法）。

反射调用方法：

类user：

public class user {

  public String username ;

  public String getUsername() {

      return username;

  }

  public void setUsername(String username) {

      this.username = username;

  }  

  public void output(){

      System.out.println("输出："+username);

  }}

在userTest类反射调用：

user u = newuser();

u.getClass().getDeclaredMethod("setUsername",String.class).invoke(u,"xhh");

u.getClass().getDeclaredMethod("output").invoke(u);

或者使用：

Class<?> u = Class.forName("reflectTest.user");

u.getDeclaredMethod("setUsername",String.class).invoke(u.newInstance(), "123");

u.getDeclaredMethod("output").invoke(u.newInstance());

注意：

1、 u.getClass().getDeclaredMethod("setAge", int.class).invoke(u, 20);

注：如果是整型，不能使用Integer.class，而是int.class，否则报NoSuchMethodException异常。

2、 如果是静态方法，调用时不需要得到对象实例（newInstance()）

3、 上面第二种方法不能获得set的123，因为每次调用u.newInstance()会得到不同的实例，改为以下即可：

Class u = (Class)Class.forName("reflectTest.user");

Object o = u.newInstance();

((Class) u).getDeclaredMethod("setUsername",String.class).invoke(o, "123");

((Class)u).getDeclaredMethod("output").invoke(o);

这样就可以调用同一个实例。