反射是用来做框架用的

反射：是用来做框架的

package http.client.test;


import java.io.InputStream;
import java.util.List;


public class Person {
public String name = "aaaaa";
private int password = 1234;
private static int age = 28;
public Person(){
System.out.println("person");
}

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

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

private Person(List list){
System.out.println("list");
}

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

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

public Class[] aa1(String name,int[] password){
return new Class[]{String.class};
}

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

public static void aa1(int num){
System.out.println(num);
}

public static void main(String[] args){
System.out.println("main!");
}
}

package http.client.test;


import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;


import org.junit.Test;


public class Reflect {
/**
* 反射：加载类，获得类的字节码
* @param args
* @throws ClassNotFoundException 
* @throws SecurityException 
* @throws NoSuchMethodException 
*/
public static void main(String[] args) throws Exception{
/*
加载类，获得类的字节码三种方法
*/
//1.
Class clazz = Class.forName("http.client.test.Person");
//2.
Class clazz1 = new Person().getClass();
//3.
Class clazz2 = Person.class;

}
/*---------------------------反射类的构造方法----------------------------------*/

//反射构造函数：public Person(){}
@Test
public void test1() throws Exception{
Class clazz = Class.forName("http.client.test.Person");
Constructor c = clazz.getConstructor(null);
Person p = (Person) c.newInstance(null);
System.out.println(p.name);
}

//反射构造函数：public Person(String name){}
@Test
public void test2() throws Exception{
Class clazz = Class.forName("http.client.test.Person");
Constructor c = clazz.getConstructor(String.class);
Person p = (Person) c.newInstance("张三");
System.out.println(p.name);
}

//反射构造函数：public Person(String name,int password){}
@Test
public void test3() throws Exception{
Class clazz = Class.forName("http.client.test.Person");
Constructor c = clazz.getConstructor(String.class,int.class);
Person p = (Person) c.newInstance("张三",20);
System.out.println(p.name);
}

//反射构造函数：private Person(List list){}
@Test
public void test4() throws Exception{
Class clazz = Class.forName("http.client.test.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("http.client.test.Person");
Person p = (Person) clazz.newInstance();//反射出类的无参构造函数，创建对象
System.out.println(p.name);
}

/*---------------------反射类的方法-----------------------*/
//反射方法：public void aa1(){
@Test
public void test6() throws Exception{
Person p = new Person();
Class clazz = Class.forName("http.client.test.Person");
Method method = clazz.getMethod("aa1", null);//null表示无参
method.invoke(p, null);
}

//反射方法：public void aa1(String name,int password){
@Test
public void test7() throws Exception{
Person p = new Person();
Class clazz = Class.forName("http.client.test.Person");
Method method = clazz.getMethod("aa1", String.class,int.class);
method.invoke(p, "老王",28);
}

//反射方法：public Class[] aa1(String name,int[] password){
@Test
public void test8() throws Exception{
Person p = new Person();
Class clazz = Class.forName("http.client.test.Person");
Method method = clazz.getMethod("aa1", String.class,int[].class);
Class css[] = (Class[]) method.invoke(p, "xxxx",new int[]{1,2,3,4,5});
System.out.println(css[0]);
}

//反射方法：private void aa1(InputStream in){
@Test
public void test9() throws Exception{
Person p = new Person();
Class clazz = Class.forName("http.client.test.Person");
Method method = clazz.getDeclaredMethod("aa1", InputStream.class);
method.setAccessible(true);//私有方法
method.invoke(p,new FileInputStream("H:\\BaiduNetdiskDownload\\工作接口文档\\亚信资源信息查询\\new 5.txt"));
}

//反射方法：public static void aa1(int num){
@Test
public void test10() throws Exception{
//Person p = new Person();
Class clazz = Class.forName("http.client.test.Person");
Method method = clazz.getDeclaredMethod("aa1", int.class);
method.invoke(null,23);//静态方法调用的时候不需要对象
}

//反射main方法：public static void main(String[] args){
@Test
public void test11() throws Exception{
Class clazz = Class.forName("http.client.test.Person");
Method method = clazz.getMethod("main", String[].class);
//method.invoke(null, new String[]{"aaa","bbb"});//jdk1.4升级1.5兼容导致的错误
//1.
//method.invoke(null, new Object[]{new String[]{"aa","bb"}});
//2.
method.invoke(null, (Object)new String[]{"aa","bbb"});
/*
* 通过反射调用一个接收数组的方法
*/

}

/*------------------------------反射字段-------------------------------*/
//反射字段：public String name = "aaaaa";
@Test
public void test12() throws Exception{
Person p = new Person();
Class clazz = Class.forName("http.client.test.Person");
Field f = clazz.getField("name");
//获取字段值
Object value = f.get(p);
//获取字段类型
Class type = f.getType();
if(type.equals(String.class)){
String svalue = (String) value;
System.out.println(svalue);
}
//设置字段值
f.set(p, "xxxxxx");
System.out.println(p.name);
}

//反射字段：private int password;
@Test
public void test13() throws Exception{
Person p = new Person();
Class clazz = Class.forName("http.client.test.Person");
Field f = clazz.getDeclaredField("password");
//私有的只能被类内部访问，但反射可以做到这一点
f.setAccessible(true);//暴力破解访问权限
System.out.println(f.get(p));
}

//反射字段：private static int age = 28;
@Test
public void test14() throws Exception{
Class clazz = Class.forName("http.client.test.Person");
Field f = clazz.getDeclaredField("age");
f.setAccessible(true);//暴力破解访问权限
System.out.println(f.get(null));
}
}