｛学习笔记｝［反射］

反射

基本概念

定义：

反射就是加载累，并解刨出泪的各个组成部分（如成员变量，方法，构造方法等）

组成：

分为两部分：加载类 解剖类

加载类:（三种方法）

1.Class clazz=Class.forName(“/day01/src/reflact/Demo1.java”);

2.class clazz1=new Person().getClass();

3.Class clazz2=Person.class;

解剖类：

Class对象提供了各种方法 解剖出的成员分别使用Constructor (构造函数) Method(方法） Field(成员变量)对象表示

解剖出来干什么？

去使用！

构造函数——创建对象

字段——数据

方法——调用

反射

反射的构造方法:

被反射的类：

public class Person {

String name;

public Person(){

System.out.println(“person”);

name=”创建成功”;

}

public Person(String name){

System.out.println(“person name”);

}

private Person(List list){

System.out.println(“person 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 void aa1(int num){
System.out.println(num);
}

}

反射的构造方法：

public class Demo2 {

@Test
public void test1() throws Exception{
Class clazz=Class.forName("reflact.Person");//加载类
Constructor c=clazz.getConstructor(null);//获取类的无参构造函数
Person p = (Person)c.newInstance(null);//利用获取到的构造函数创建对象
System.out.println(p.name);
}

@Test
public void test2() throws Exception{
Class clazz = Class.forName("reflact.Person");
Constructor c= clazz.getConstructor(String.class);
Person p = (Person)c.newInstance("xxxx");

}
//如果构造函数是私有的，可以采用暴力破解
@Test
public void test4() throws Exception{
Class clazz =Class.forName("reflact.Person");
Constructor c = clazz.getDeclaredConstructor(List.class);
c.setAccessible(true);//暴力反射
Person p =(Person)c.newInstance(new ArrayList());
System.out.println(p.name);

}

@Test
public void test5() throws Exception{
Class clazz = Class.forName("reflact.Person");
Person p = (Person)clazz.newInstance();//构建对象的第二种方法
}
}

构造方法总结：

public 方法 包访问方法可以用getConstructor来获取，但是private 只能用getDeclaredConstructor来访问

反射的方法：

import java.lang.reflect.Method;

import org.junit.Test;

public class Demo3 {

//反射类的方法：public  void aa1（）
@Test
public void test1() throws Exception{
Person p =new Person();
Class clazz=Class.forName("reflact.Person");
Method method =clazz.getMethod("aa1",null);
method.invoke(p, null);// 调用方法 p_对象,方法的参数

}
//反射类的方法：public  void aa1（String name,int password）
@Test
public void test2() throws Exception{
Person p =new Person();
Class clazz=Class.forName("reflact.Person");
Method method =clazz.getMethod("aa1",String.class,int .class);
method.invoke(p, "zxx",99);// 调用方法 p_对象,方法的参数

}
/*不会！
//反射类的方法：public  Class[] aa1（String name,int password）
@Test
public void test3() throws Exception{
Person p =new Person();
Class clazz=Class.forName("reflact.Person");
Method method =clazz.getMethod("aa1",String.class,int .class);
method.invoke(p, "zxx",99);// 调用方法 p_对象,方法的参数

}
*/
//反射类的方法：public  void aa1（Inputstream in）
@Test
public void test4() throws Exception{
Person p =new Person();
Class clazz=Class.forName("reflact.Person");
Method method =clazz.getMethod("aa1",String.class,int .class);
method.invoke(p, "zxx",99);// 调用方法 p_对象,方法的参数

}
}

静态方法的反射

public void test5() throws Exception{
//Person p = new Person();静态方法不需要对象
Class class =Class.forName("类名");//加载类
Method method =clazz.getMethod("aa1",int.class);
method.invoke(nul,23);
}

main的反射

残留问题＝ ＝！

反射类的字段

反射代码

import java.lang.reflect.Field;

public class Demo5 {
//反射字段 public String name = "aaaa";
public void test1() throws Exception{
Person p = new Person();//为了传递一个对象
Class clazz = Class.forName("reflact.Person");
Field f = clazz.getField("name");
String name=(String)f.getName();
System.out.println(name);
Class type = f.getType();
System.out.println(type);//获取字段的类型
}
}

可以自行判断字段类型

if(type.equals（String.class))

字段赋值

f.set(对象，“”);

静态字段的反射

居然也需要传入一个对象进去