1.反射？
反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
2.如何得到类对象
<1>类名.class<2>对象.getClass()
<3>Class.forName("全限定名");
<4>类加载的loadClass("全限定名")；
<5>子类.class.getSuperClass();
<6>包装类.class
package com.zking.test;
import org.junit.Test;
import com.zking.entity.Person;
import com.zking.entity.Son;
public class TestReflect {
/**
* 获取类对象
*/
@Test
public void test1(){
try {
//第一种方式:实体类.class
// Class clazz=Person.class;
// System.out.println(clazz);//打印出:class com.zking.entity.Person
//2:对象.getClass()
// Person per=new Person();
// Class clazz=per.getClass();
// System.out.println(clazz);//打印出:class com.zking.entity.Person
//3:Class.forName("全限定名");
// Class clazz=Class.forName("com.zking.entity.Person");
// System.out.println(clazz);//打印出:class com.zking.entity.Person
//4:类加载的loadClass("全限定名")；
// ClassLoader cl=Person.class.getClassLoader();
// Class clazz=cl.loadClass("com.zking.entity.Person");
// System.out.println(clazz);//打印出:class com.zking.entity.Person
//5:子类.class.getSuperClass();
// Class clazz=Son.class.getSuperclass();
// System.out.println(clazz);//打印出:class com.zking.entity.Person
//6:获取包装类的类对象 包装类.class
// Class clazz=Integer.class;
// System.out.println(clazz);//打印出:class java.lang.Integer
} catch (Exception e) {
e.printStackTrace();
}
}
}
3.根据类得到类名(全限定名)
c.getName()------------>全限定名c.getSimpleName() ---->类名
c.getPackage()---------->包名
/**
* 根据类对象 获取 类名(全限定名 包名)
*/
@Test
public void test2(){
Class clazz=Person.class;
System.out.println(clazz.getName());//获取全限定名 打印出:com.zking.entity.Person
System.out.println(clazz.getSimpleName());//获取类名(不包括包名) 打印出:Person
System.out.println(clazz.getPackage().getName());//获取包名 打印出:com.zking.entity
}4.根据类得到类的属性
c.getField("field属性名");属性名：f.getName()
属性修饰符：f.getModifiers()
属性的数据类型：f.getType().getName()
给属性设值：f.set()
得到属性的值：f.get()
得到私有的属性：f.getDeclaredField("属性名");
得到所有的声明的属性 c.getDeclaredFields()
/**
* 根据类对象 获取 类的属性
*/
@Test
public void test3(){
try {
//之前
// Person person=new Person();
// //person.setPid(1);
// Person person2=new Person();
// //person2.setPid(100);
// Class clazz=Person.class;
// Field[] fields=clazz.getFields();//只能获取public修饰的属性
// Field[] fields2=clazz.getDeclaredFields();//获取所有的属性（包括私有）
// for (Field field : fields2) {
// //获取所有属性的属性名
// System.out.println(field.getName());
// }
//
// System.out.println(fields2.length);
// //获取单个属性（获取的public）
// Field field=clazz.getField("pid");
// //给属性设值
// field.setInt(person, 100);
// //获取属性的值
// System.out.println(field.getInt(person));
//
// //获取单个属性(修饰符为private)
// //Field fieldPname=clazz.getField("pname");
// Field fieldPname=clazz.getDeclaredField("color");
// System.out.println(fieldPname);
//
// System.out.println("psex的数据类型为："+fieldPname.getType().getSimpleName());
// //private 2
// //public 1
// //protected 4
// //默认 0
// //static 8
// //final 16
//
// System.out.println(Modifier.isPublic(25));
//
// System.out.println("color的修饰符为："+fieldPname.getModifiers());
//
// //设置可以访问
// fieldPname.setAccessible(true);
//
// //给私有的属性设值
// fieldPname.set(person, "admin");
//
// //获取私有属性的值
// System.out.println(fieldPname.get(person));
//
} catch (Exception e) {
e.printStackTrace();
}
}
5.根据类得到类的方法
c.getMethod() c.getDeclaredMethod();
6.根据类得到类的构造方法
/**
* 获取该类所有的构造方法，并执行
*/
@Test
public void test5(){
Class clazz=Person.class;
Constructor constructor[]=clazz.getDeclaredConstructors();
for (Constructor c : constructor) {
System.out.println(c.getModifiers());
Class clazzType[]=c.getParameterTypes();
for (Class cc : clazzType) {
System.out.println(" "+cc.getSimpleName());
}
}
//调用构造方法（使用构造方法进行实例化对象）
try {
//clazz.newInstance();//调用无参构造
//调用有参构造
Constructor constru=clazz.getDeclaredConstructor(Integer.class,String.class,Integer.class);
constru.newInstance(1,"123",2);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 根据类对象 获取 类的所有的方法
*/
@Test
public void test4(){
//获取所有的方法
Class clazz=Person.class;
Method methods[]=clazz.getDeclaredMethods();
System.out.println(methods.length);
for (Method method : methods) {
//获取每个方法的名字
System.out.println(method.getName());
//每个方法的返回值类型
System.out.println(" "+method.getReturnType().getName());
//每个方法的修饰符
System.out.println(" "+method.getModifiers());
//获取每个方法的参数列表
Class[] classType=method.getParameterTypes();
for (Class c : classType) {
System.out.println(" "+c.getSimpleName());
}
}
//调用方法(无参数)
try {
Person person=new Person();
Method method=clazz.getDeclaredMethod("sleep", String.class,String.class);
//设置可访问
method.setAccessible(true);
//执行方法
method.invoke(person, "小飞和小明","小芳");
} catch (Exception e) {
e.printStackTrace();
}
}7.根据类得到类的实现接口列表
/**
* 获取实现该类的所有接口 及 父类
*/
@Test
public void test6(){
Class clazz=Person.class;
System.out.println(clazz.getSuperclass().getSimpleName());
//实现的接口
Class clazzInterface[]=clazz.getInterfaces();
for (Class c : clazzInterface) {
System.out.println(c.getSimpleName());
}
}例子（删除实体类后再读取实体类的class文件）：
package com.zking.entity;
import java.io.Serializable;
import javax.servlet.http.HttpServlet;
/**
* 例子：
* <1>新建实体类Person
* <2>三个字段：pid pname psex
* <3>要求该类有父类，并且实现多接口
* <4>通过反射得到改类所有的属性和方法，父类和实现接口
* 要求:在控制台打印实体类
*/
public class Person extends HttpServlet implements Serializable,Runnable{
private Integer pid;
private String pname;
private String psex;
//构造方法
public Person() {
}
public Person(Integer pid, String pname, String psex) {
super();
this.pid = pid;
this.pname = pname;
this.psex = psex;
}
//封装
public Integer getPid() {
return pid;
}
public void setPid(Integer pid) {
this.pid = pid;
}
public String getPname() {
return pname;
}
public void setPname(String pname) {
this.pname = pname;
}
public String getPsex() {
return psex;
}
public void setPsex(String psex) {
this.psex = psex;
}
//方法
public void run() {
// TODO Auto-generated method stub
}
public void eat(){
System.out.println("打印吃的方法");
}
}
package com.zking.diy;
import java.io.FileInputStream;
public class ClassLoaderDIY extends ClassLoader{
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
System.out.println("自定义加载器:"+name);
name=name.replaceAll("\\.", "/");
System.out.println("替换后:"+name);
//截取
int a=name.lastIndexOf("/");
name=name.substring(a+1);
String path="C:\\Users\\Administrator.USER-20170515AI\\Desktop\\"+name+".class";
try {
FileInputStream fis=new FileInputStream(path);
System.out.println(fis.available());
int len=0;
byte[] b=new byte[fis.available()];
len=fis.read(b);
return defineClass(null, b,0,len);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
package com.zking.test;
import org.junit.Test;
import com.zking.diy.ClassLoaderDIY;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class TestReflect {
@Test
public void test1() throws IOException{
Map<Integer, String> map=new HashMap<Integer, String>();
map.put(0, "\t");
map.put(1, "public");
map.put(2, "private");
map.put(4, "protected");
map.put(8, "static");
map.put(16, "final");
StringBuffer sb=new StringBuffer();
Class clazz= null;
try {
clazz=Class.forName("com.zking.entity.Person", true, new ClassLoaderDIY());
sb.append("=======================================================\r\n");
} catch (Exception e) {
e.printStackTrace();
}
//拿package+(全限定名 包名);
sb.append("package "+clazz.getName().substring(0, clazz.getName().lastIndexOf("."))+";\r\n\r\n");
//拿导包（实现接口）
Class[] interfaces= clazz.getInterfaces();
for (Class cl: interfaces) {
sb.append("import "+cl.getName()+";\r\n\r\n");
}
//拿导包（父类）
sb.append("import "+clazz.getSuperclass().getName()+";\r\n\r\n");
/**
* public class Person extends HttpServlet implements Serializable,Runnable{
*/
sb.append(map.get(clazz.getModifiers())+" class "+clazz.getSimpleName());//拿public class Person
sb.append(" extends "+clazz.getSuperclass().getSimpleName()+" implements ");//拿extends 父类 implements
//拿实现的接口
int t1=0;
for (Class cl : interfaces) {
t1++;
if(t1==interfaces.length){
sb.append(cl.getSimpleName()+"{\r\n");
}else{
sb.append(cl.getSimpleName()+",");
}
}
/**
* 拿属性
* private int pid;
* private String pname;
* private String psex;
*/
Field[] fields=clazz.getDeclaredFields();//获取所有的属性（包括私有）
for (Field f : fields) {
sb.append("\t");
sb.append(map.get(f.getModifiers())+" ");
sb.append(f.getType().getSimpleName()+" ");
sb.append(f.getName()+";\r\n");
}
/**
*拿构造方法
*/
Constructor[] con=clazz.getDeclaredConstructors();
for (Constructor c : con) {
sb.append("\t");
sb.append(map.get(c.getModifiers())+" ");
sb.append(clazz.getSimpleName()+"(");
//参数params
Class[] params=c.getParameterTypes();
int i=0;
for (Class cc : params) {
i++;
if(i==params.length){
sb.append(cc.getSimpleName()+" 参数"+i);
}else{
sb.append(cc.getSimpleName()+" 参数"+i+",");
}
}
sb.append("){\r\n\r\n\t}\r\n");
}
/**
* 获取所有的方法（封装+方法）
*/
//拿方法
Method[] methods=clazz.getDeclaredMethods();
for (Method m : methods) {
sb.append("\t");
sb.append(map.get(m.getModifiers())+" ");
sb.append(m.getReturnType().getSimpleName()+" ");
sb.append(m.getName()+"(");
//方法参数
//获取方法的参数列表
Class[] params=m.getParameterTypes();
int i=0;
for (Class c : params) {
i++;
if(i==params.length){
sb.append(c.getSimpleName()+" 参数"+i);
}else{
sb.append(c.getSimpleName()+" 参数"+i+",");
}
}
sb.append("){\r\n\r\n\t}\r\n");
}
sb.append("}");
System.out.println(sb);
/**
* 写入文件
*/
// File file=new File("D:\\桌面文件\\桌面\\控制台的打印文本.txt");
File file=new File("YuHuiLing.java");
if(!file.isAbsolute()){
file.createNewFile();
}
try {
FileOutputStream fos=new FileOutputStream(file);
//fos.write(sb.toString().getBytes());
//fos.close();
OutputStreamWriter osw=new OutputStreamWriter(fos);
osw.write(sb.toString());
osw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
//如果WebRoot路径下面没有YuHuiLing.java文件，即按F5刷新一下
}
}
扫一扫
3232
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
