JAVA 反射总结

Class是什么：

百度百科解释是这样的：在Java中，每个class都有一个相应的Class对象。也就是说，当我们编写一个类，编译完成后，在生成的.class文件中，就会产生一个Class对象，用于表示这个类的类型信息。

我们有一个Person类，如下所示：

package cn.itcat.reflection;
import java.io.InputStream;
import java.util.List;
public class Person {
public String name = "AAAA";

public Person() {
System.out.println("Person");
}

public Person(String name) {
System.out.println(name);
}

public Person(String name, int age) {
System.out.println(name + age);
}

private Person(List list) {
name = "sss";
}

public void aa1(String name, int password) {
System.out.println(name + password);
}

public void aa1() {
System.out.println("aa1");
}

private void aa1(InputStream in) {
System.out.println(in);
}

public Class[] aa1(String name, int[] password) {
return new Class[] { String.class };
}
//静态方法
public static void aa1(int name) {
System.out.println(name);
}
}

1.获取Person的Class对象的方法：

//1
Class clazz =  Class.forName("cn.itcat.reflection.Person");（常用）

//2
Class clazz2 = new Person().getClass();

//3
Class clazz3 = Person.class;

2.反射类的构造函数，创建类的对象

通过反射两种创建类对象的方法。1：通过Constructor 2 : 直接通过Class对象

下面是举例:

//反射类的构造函数，public Person()
@Test
public void test1() throws Exception
{
Class clazz = Class.forName("cn.itcat.reflection.Person");
Constructor c = clazz.getConstructor(null);  //反射类的无参构造函数，getConstructor(参数列表)
Person p = (Person) c.newInstance(null);//用这个构造函数创建类的对象newInstance（参数列表值）
System.out.println(p.name);
}

//反射类的构造函数，public Person(String name)
@Test
public void test2() throws Exception
{
Class clazz = Class.forName("cn.itcat.reflection.Person");
Constructor c = clazz.getConstructor(String.class);//反射类的有参构造函数
Person p = (Person) c.newInstance("BBBB");
System.out.println(p.name); //输出BBBB
}
//反射类的构造函数，public Person(String name,int age)
@Test
public void test3() throws Exception
{
Class clazz = Class.forName("cn.itcat.reflection.Person");
Constructor c = clazz.getConstructor(String.class,int.class);
Person p = (Person) c.newInstance("CCCC",23);
}
//反射类的构造函数，private Person(List list)
@Test
public void test4() throws Exception
{
Class clazz = Class.forName("cn.itcat.reflection.Person");
Constructor c =  clazz.getDeclaredConstructor(List.class); //私有构造函数
c.setAccessible(true);   //暴力反射
Person p =(Person) c.newInstance(new ArrayList());
System.out.println(p.name);
}

//创建对象的另外一种方法,等效于test1（无参构造）
@Test
public void test5() throws Exception
{
Class clazz = Class.forName("cn.itcat.reflection.Person");
Person p =(Person) clazz.newInstance();  //直接通过Class对象创建类的实例
System.out.println(p.name);
}

3.反射类的方法

普通方法：

A a= new A();

Class clazz = Class.forName(“cn.itcat.reflection.A”);

Method menthod = clazz.getMethod(“方法名”,参数列表);

menthod.invoke(类的实例对象,参数列表值);

静态方法：

Class clazz = Class.forName(“cn.itcat.reflection.A”);

Method menthod = clazz.getMethod(“方法名”,参数列表);

menthod.invoke(null,参数列表值);

下面是例子：

@Test
public void test6() throws Exception
{
Person p = new Person();
Class clazz = Class.forName("cn.itcat.reflection.Person");
Method menthod = clazz.getMethod("aa1",null);
menthod.invoke(p,null);
}
@Test
public void test7() throws Exception
{
Person p = new Person();
Class clazz = Class.forName("cn.itcat.reflection.Person");
Method menthod = clazz.getMethod("aa1",String.class,int.class);
menthod.invoke(p,"ll",23);
}
@Test
public void test8()throws Exception
{
Person p = new Person();
Class clazz = Class.forName("cn.itcat.reflection.Person");
Method method = clazz.getMethod("aa1", String.class,int[].class);
Class cs[] =(Class[])method.invoke(p, "vv",new int[]{1,2,3});
System.out.println(cs[0]);
}
@Test
public void test9()throws Exception
{
Person p = new Person();
Class clazz = Class.forName("cn.itcat.reflection.Person");
Method method = clazz.getDeclaredMethod("aa1", InputStream.class);
method.setAccessible(true);
method.invoke(p, new FileInputStream("f:\\1.txt"));
}
@Test
public void test10()throws Exception
{
Class clazz = Class.forName("cn.itcat.reflection.Person");
Method method = clazz.getMethod("aa1", int.class);
method.invoke(null, 23);   //静态方法调用时不需要对象，有对象更加没问题
}

4.Person类中的Main方法如何调用（如果有的话）：

String[] args,需要对其做点处理传过去。

public void test11()throws Exception
{
Class clazz = Class.forName("cn.itcat.reflection.Person");
Method m1 = clazz.getMethod("main", String[].class);

//m1.invoke(null,new Object[]{new String[]{"hh","dd"}});
m1.invoke(null,(Object)new String[]{"hh","dd"});
}

5.反射字段

//反射字段

public class demo4
{
@Test  //public String name = "xxxxx";
public void test1()throws Exception
{
Class clazz = Class.forName("cn.itcat.reflection.Person");
Field f = clazz.getField("name");
Person p = new Person();
Object o =f.get(p);
Class type = f.getType();
if(type.equals(String.class))
{
String value = (String)o;
System.out.println(value);
}

f.set(p,"xxxxx");
System.out.println(p.name);
}
@Test   //private int age = 0;
public void test2()throws Exception
{
Class clazz = Class.forName("cn.itcat.reflection.Person");
Field f = clazz.getDeclaredField("age");
f.setAccessible(true);
Person p = new Person();
Object o =f.get(p);
Class type = f.getType();
if(type.equals(int.class))
{
int value = (int)o;
System.out.println(value);
}
f.set(p,12);
}
@Test  //private static int num = 0;
public void test3()throws Exception
{
Class clazz = Class.forName("cn.itcat.reflection.Person");
Field f = clazz.getDeclaredField("num");
f.setAccessible(true);
Object o = f.get(null);
Class c = f.getType();
if(c.equals(int.class))
{
int value = (int)o;
System.out.println(value);
}
f.set(null,12);
}
}