反射笔记

时间：2014-09-10 17:49:10 阅读：166 评论：0 收藏：0 [点我收藏+]

反射：
一个类有多个组成部分，
成员变量，方法，和构造函数，反射就是加载类，并解剖出
各个组成部分

//加载类
java中有一个Class类用于代表一个类的字节码

----------------------------------------------------------------------------
Reflect
//反射加载某个类Person
public class ReflectClass{
public static void main(String[] args){
//把硬盘上的字节码加载到内存中，在内存中就有一个clazz对象保存了

Class clazz=Class.forName("类的完整名称");

//其他的几种方式：
2.Class clazz2=new Person().getClass();
3.Class clazz3=Person.class;

//技巧：右键-Copy Qualified Name(复制类的完整类名)

Class对象提供了如下的常用方法
//得到public
public Constructor getConstructor<Class<?>...parameterTypes>
public Method getMethod(...);
public Field getField(...);

//得到所声明的方法
public Constructor getDeclaredConstructor();
public Method getDeclaredMethod(...);
public Field getDeclaredField(...);

//这些方法分别用于从类中解剖出构造函数，方法和成员变量(属性)
解剖出的成员分别使用Constructor,Method.Field对象表示

}

}

//解剖一个类的构造函数

public class Person{
public String name="hello";

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

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

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

//解剖构造函数，并创建类的对象
public class Demo{
//反射构造函数public Person(){}
@Test
public void test() throws Exception{
Class clazz1=Class.forName("Person");
Constructor c=clazz1.getConstructor(null);//参数控制你想解剖出哪个构造函数
Person p1=(Person)c.newInstance(null);
System.out.println(p1.name);

}
//反射构造函数public Person(String name)
@Test
public void test2() throws Exception{
Class clazz1=Class.forName("Person");
Constructor c=clazz1.getConstructor(String.class);//参数控制你想解剖出哪个构造函数
Person p1=(Person)c.newInstance("name");
System.out.println(p1.name);

}
//反射构造函数public Person(String name,int password)
@Test
public void test2() throws Exception{
Class clazz1=Class.forName("Person");
Constructor c=clazz1.getConstructor(String.class,Integer.class);//参数控制你想解剖出哪个构造函数
Person p1=(Person)c.newInstance("name",1900);
System.out.println(p1.name);

}
//反射构造函数public Person(List list)
@Test
public void test2() throws Exception{
Class clazz1=Class.forName("Person");
Constructor c=clazz1.getConstructor(List.list);//参数控制你想解剖出哪个构造函数
//关键代码-暴力反射
c.setAccessible(true);
Person p1=(Person)c.newInstance(new ArrayList());
System.out.println(p1.name);
//面试题：私有的不能访问，但反射可以实现访问。c.setAccessible(true);

//创建对象的另外一种途径
Class clazz=Class.forName("Person");
Person p=(Person)clazz.newInstance();
//反射出类的无参构造函数创建对象，意味着类中必须有无参的构造方法
System.out.println(p);
}

//反射Method执行方法
public void aa(){
System.out.println("");
}
public void aa(String name){
System.out.println(name);
}
public Class[] aa(String name,int[] password){
System.out.println(name+);
return new Class[](String.class);
}
private void aa(InputStream in){
System.out.println("in");
}
publiic static aa(){
System.out.println("static");
}

//反射代码
public class Demo{

//public void a(){}
@Test
Person p=new Person();
public void test(){
Class clazz=Class.forName("Person");
Method method=clazz.getMethod(null);
//import java.lang.reflect.Method

method.invoke(p,null);
//第一个参数是一个对象，第二个参数是一个方法中的参数类型

}
//反射方法public void a(String name,int password)
public void test2(){
Class clazz=Class.forName("Person");
Method method=clazz.getMethod("a",String.class,int.class);

//第一个参数是方法名

method.invoke(p,"hephec",39);
//第一个参数是一个对象，第二个参数是一个方法中的参数类型

}
//反射方法public Class[] a(String name,int[] password)
public void test2(){
Class clazz=Class.forName("Person");
Method method=clazz.getMethod("a",String.class,int[]class);
Class[] ca=(Class[])method.invoke(p,"aaa",new int[]{1,2,3});
System.out.println(cs[0]);
//第一个参数是方法名

method.invoke(p,"hephec",39);
//第一个参数是一个对象，第二个参数是一个方法中的参数类型

}
...//反射私有的方法getDeclaredMthod();
//反射静态方法

@test
public void test(){
Class clazz=Class.forName("Person");
Method method=clazz.getMethod("a",int.class);
//静态方法在调用时不需要对象
method.invoke(null,23);
}
}

//反射main方法

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

@Test
public void test(){
Class clazz=Class.forName("Person");
Method method=clazz.getMethod("main",String[].class);
method.invoke(null,new String[]{"1","2","3"});
//不能执行
//解决方案:
method.invoke(null,new Object(new String[]{"1","2","3"}));
method.invoke(null,(Object)(new String[]{"1","2","3"}));
}

//反射字段
public void test(){
Class clazz=Class.forName("Person");
Field field=clazz.getField("name");
Object value=f.get(p);//参数是一个对象
//获取字段的值

//有时候不知道反射的字段的类型

Class type=field.getType();
if(type.equals(String.class)){
String values=(String)value;

}
System.out.println(type);
}

//设置字段的值

f.set(p,"xxxxx");
System.out.printtn(p.name);

}

反射笔记

标签：style io 使用 java ar for sp 代码 on

原文地址：http://blog.csdn.net/hephec/article/details/39183263

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行