java反射
java能够反射的前提：已经加载过这个类，就可以通过类名来寻找这个类的所有相关信息
javaReflection
Reflection（反射）是被视为动态语言的关键，AVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性
提供的功能
在运行时判断任意一个对象所属的类
在运行时判断任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的成员变量和方法
生成动态代理
主要API
Calss：代表一个类
reflect.Method:代表类的方法
reflect.Field:代表类的成员变量
reflect.Constructor:代表类的构造方法
Class类
package reflection;
/**
* Class对象由系统建立
* 一个类在jvm中只会有一个Class实例,这个Class对象对应的是.class文件
*/
public class MyClass {
public static void main(String[] args) throws ClassNotFoundException {
Person p = new Person();
// 改方法的返回值类型是一个Class类
Class<? extends Person> aClass = p.getClass();//包含这个对象的所有信息
//通过类名.class创建指定类的Class实例
Class c=Person.class;
//通过一个类的实例对象.getClass()方法,获取对象实例对象的类的Class实例
Class c1 = p.getClass();
//通过Class静态方法forName() 来获取
// 方法中的参数是你要获取的Class实例的类的全路径(包名.类名)
Class c2 = Class.forName("reflection.Person");
}
}
++++++++++++++++++++++++++++++++++++++++
package reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class Test1 {
public static void main(String[] args) throws ClassNotFoundException {
Class c = Class.forName("reflection.Student");
// 获取父类
Class sup = c.getSuperclass();
// 输出
System.out.println(sup.getName());
// 获取当前类的所有接口
Class[] int1 = c.getInterfaces();
// 因为是数组,遍历输出
for (Class s : int1) {
System.out.println(s.getName());
}
// getConstructors()获取全部用public修饰的构造器
Constructor[] con = c.getConstructors();
for (Constructor v : con) {
System.out.println(v.getName());
// 获得方法的修饰符
System.out.println(v.getModifiers());
// 获取参数类型
Class[] pa = v.getParameterTypes();
for (Class m : pa) {
System.out.println(m.getName());
}
}
// 获取全部构造器
Constructor[] de = c.getDeclaredConstructors();
for (Constructor b : de) {
// 返回数组1代表punlic,返回数组2代表private
System.out.println(b.getModifiers());
System.out.println(b.getName());
}
// 通过反射创建对象
Class c1 = Class.forName("reflection.Student");
try {
// 相当于调用无参公有构造方法
Object o = c.newInstance();
// 强转
Student stu = (Student) o;
} catch (Exception e) {
e.printStackTrace();
}
try {
// 指定获取有一个参数并且为String类型的公有的构造方法
Constructor constructor = c.getConstructor(String.class);
Student ob = (Student)constructor.newInstance("玉燕");//实例化
System.out.println(ob.school);
} catch (Exception e) {
e.printStackTrace();
}
// 通过反射机制可以强制调用私有构造方法
// 指定获取有两个参数的构造方法
try {
Constructor dea = c.getDeclaredConstructor(String.class, int.class);
// 解除私有封装
dea.setAccessible(true);
Student ob = (Student)dea.newInstance("历史",45);
System.out.println(ob.age);
} catch (Exception e) {
e.printStackTrace();
}
//获取公有方法
Method[] methods = c.getMethods();
for (Method s :methods ){
// 获取返回值类型
System.out.println("++++++=++");
System.out.println(s.getReturnType());
System.out.println(s.getName());
}
// 获取所有方法
Method[] declaredMethods = c.getDeclaredMethods();
// 获取类(不包括父类)的公有属性
c.getFields();
// 获取类(不包括父类)的全部属性
c.getDeclaredFields();
// 获得属性类型
// getType()
// 获取类所在的包
Package aPackage = c.getPackage();
System.out.println(aPackage.getName());
}
}
package reflection;
public interface Stydy {
void stydyInfo();
}
package reflection;
/**
* @author 童泽沼
*/
public class Student extends Person implements Stydy,Move{
String school;
public Student(String school) {
this.school = school;
System.out.println("有参构造");
}
public Student() {
System.out.println("无参构造" +
"");
}
private Student(String name,int age) {
this.name=name;
this.age =age;
System.out.println("私有构造");
}
public void schoolShow(){
System.out.println(this.school);
}
@Override
public void stydyInfo() {
System.out.println("好家伙");
}
@Override
public void moveType() {
System.out.println("你还给我");
}
private void test(String s){
}
public String getSchool(){
return this.school;
}
}
package reflection;
/**
* @author 童泽沼
*/
public class Person {
String name;
int age;
}
package reflection;
public interface Move {
void moveType();
}
动态代理
package reflection;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
/**
* @author 童泽沼
* 注意:如果一个对象想要通过Proxy.newProxyInstance()方法被代理
* 那么这个对象的类一定要有相对应的接口
* 就像这个测试类一样
*/
public class Tese2 {
public static void main(String[] args) {
DaiLi daiLi = new TestDemo();
daiLi.test();
daiLi.test1();
System.out.println("==================");
//创建代理对象
InvocationHandler proxyDemo = new ProxyDemo(daiLi);
/*
* 参数1:代理对象的类加载器
* 参数2:被代理的对象接口
* 参数3:代理对象
*
* 返回的值就是成功代理后的对象,返回是超类,需要根据情况决定转换类型
* */
DaiLi o = (DaiLi) Proxy.newProxyInstance(proxyDemo.getClass().getClassLoader(), daiLi.getClass().getInterfaces(), proxyDemo);
o.test1();
System.out.println("=========================");
o.test();
}
}
package reflection;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//要实现接口
public class ProxyDemo implements InvocationHandler {
Object obj;//被代理对象
public ProxyDemo(Object obj) {
this.obj = obj;
}
public ProxyDemo() {
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(method.getName()+"开始");
//执行指定代理对象的指定方法
Object invoke = method.invoke(this.obj, args);
System.out.println(method.getName()+"结束");
return invoke;
}
}
package reflection;
public class TestDemo implements DaiLi{
@Override
public void test() {
System.out.println("1");
}
@Override
public void test1() {
System.out.println("2");
}
}
package reflection;
/**
* @author 童泽沼
*/
public interface DaiLi {
void test();
void test1();
}
浙公网安备 33010602011771号