关于java:类加载器-反射-java动态代理

类加载器

类加载

类加载器

反射

JAVA 反射机制是在运行状态中，对于任意一个类，都可能晓得这个类的所有属性和办法；对于任意一个对象，都可能调用它的任意一个办法和属性；这种动静获取的信息以及动静调用对象的办法的性能称为 java 语言的反射机制。
反射就是把 java 类中的各种成分映射成一个个的 Java 对象

• 在运行时判断任意一个对象所属的类
• 在运行时结构任意一个类的对象
• 在运行时怕判断任意一个类所具备的成员变量和办法
• 在运行时调用任意一个对象的成员变量和办法

• 生成动静代 C 理
  

  Class 类

  
  

• Class 自身也是一个类
• Class 对象只能由零碎建设对象
• 一个类在 JVM 中只会有一个 class 实例
• 一个 Class 对象对应的是一个加载到 JVM 中的一个.class 文件
• 每个类的实例都会记得本人是由那个 Class 实例所生成
• 通过 Class 能够残缺的失去一个类中的残缺构造

通过反射获取一个类的父类和接口

Class clazz = Class.forName("day14.Student")
// 通过包. 类名的字符串，调用 class.forName 办法获取指定类的 Class 实例

Class superClazz = clazz.getSuperclass();// 获取父类
sout(superClazz .getName())// 输入父类名字

Class[] interfaces = clazz.getInterfaces();// 获取以后类的所有接口
for(Class c : interfaces){sout(c.getName())// 输入接口名字
}

通过反射获取一个类的构造方法

退出三个构造方法

getConstructors 获取类的私有的构造方法
getModifiers 获取构造方法的修饰符，返回数组 1 代表 public
getParameterTypes 获取构造方法的参数类型，有几个参数数组的元素就有几个

import java.lang.reflect.Constructor;
Constructor[] cons = clazz.getConstructors();// 获取以后类的所有构造方法
for(Constructor c : cons){sout(c.getName());// 输入构造方法名字
    sout(c.getModifiers());// 输入构造方法修饰符
    Class[] paramClazz = c.getParameterTypes();
    for(Class pc : paramClazz){sout(pc.getName());// 输入构造方法的参数类型
    }
}

getDeclaredConstructors 获取类的所有的构造方法，包含私有和公有
getModifiers 获取办法的修饰符，返回数组 2 代表 private

Constructor[] cons1 = clazz.getDeclaredConstructors();// 获取以后类的所有接口
for(Constructor c : cons1){sout(c.getName());// 输入构造方法名字
    sout(c.getModifiers());// 输入构造方法修饰符
}

通过反射创立一个对象

都是 class 类型的参参数。

// 相当于调用 Student 类的无参私有的构造方法
Object obj = clazz.newInstance();
Student stu = (Student)obj;//obj 强转为 Student 对象

// 相当于调用 Student 类的有一个参数并且为 String 类型的私有的构造方法
Constructor c= clazz.getConstructor(String.class);
Object obj = c.newInstance("第一中学");// 通过 newInstance 实例化对象，相当于调用构造方法
Student stu = (Student)obj;//obj 强转为 Student 对象

通过反射机制，能够强制调用公有的构造方法

// 相当于调用 Student 类的有两个个参数并且为 String 类型和 int 类型的的构造方法
Constructor c= clazz.getConstructor(String.class,int.class);
c.setAccessible(true);// 解除公有的封装，上面就能够对这个公有办法进行强制调用
Object obj = c.newInstance("张三",12);// 通过 newInstance 实例化对象，相当于调用构造方法
Student stu = (Student)obj;//obj 强转为 Student 对象

通过反射获取类的办法

获取所有类的私有的办法

// 获取所有类的私有的办法
Method[] ms= clazz.getMethods();
for(Method m : ms){sout(m.getName());// 输入办法名字
    sout(m.getReturnType());// 输入办法返回类型
    sout(m.getModifiers());// 输入办法修饰符
    // 获取办法的参数类型，是一个数组，办法有几个参数，数组就有几个元素
    Class[] pcs = m.getParameterTypes();
    if(pcs!=null&&pcs.length>0){for(Class pc : pcs){sout(pc.getName());// 输入办法的参数类型
        } 
    }
   
}

获取所有类的所有办法，蕴含私有公有

// 获取所有类的私有的办法，蕴含私有公有
Method[] ms= clazz.getDeclaredMethods();
for(Method m : ms){sout(m.getName());// 输入办法名字
    sout(m.getReturnType());// 输入办法返回类型
    sout(m.getModifiers());// 输入办法修饰符
    // 获取办法的参数类型，是一个数组，办法有几个参数，数组就有几个元素
    Class[] pcs = m.getParameterTypes();
    if(pcs!=null&&pcs.length>0){for(Class pc : pcs){sout(pc.getName());// 输入办法的参数类型
        } 
    }
   
}

通过反射获取类的办法属性和包

获取类的私有的属性，蕴含父类的私有属性

// 获取类的私有的属性，蕴含父类的私有属性
Field[] fs= clazz.getFields();
for(Field f : fs){sout(m.getModifiers());// 输入属性修饰符
    sout(m.getType());// 输入属性的类型
    sout(m.getName());// 输入属性名称
}

获取本类（不蕴含父类）的私有的属性，包含私有、公有

// 获取本类（不蕴含父类）的所有的属性，包含私有、公有
Field[] fs= clazz.getDeclaredFields();
for(Field f : fs){sout(m.getModifiers());// 输入属性修饰符
    sout(m.getType());// 输入属性的类型
    sout(m.getName());// 输入属性名称
}

获取类所在的包

// 获取类所在的包
Package p = clazz.getPackage();
sout(p.getName());// 输入包的名称

通过反射获取类的指定办法和指定属性

调用私有办法

// 获取类的指定办法
Constructor c= clazz.getConstructor();// 获取无参结构
Object obj = con.newInstance();// 应用无参结构创建对象

clazz.getMethod(办法名，参数类型);
Method m = clazz.getMethod("setInfo"，String.class,String.class);// 失去名称叫 setInfo，参数是 String，String 的类型的办法

m.invoke(obj(须要实例化的对象),args(调用以后办法的理论参数))
m.invoke(obj,"zhangsan","第一中学")

调用公有有参数办法

// 获取类的指定办法
Constructor c= clazz.getConstructor();// 获取无参结构
Object obj = con.newInstance();// 应用无参结构创建对象

clazz.getDeclaredMethod(办法名，参数类型);
Method m1 = clazz.getDeclaredMethod("test"，String.class);// 失去名称叫 test，参数是一个 String 的类型的办法

m1.setAccessible(true);// 解除公有封装，上面能够强制调用公有办法
m1.invoke(obj(须要实例化的对象),args(调用以后办法的理论参数))
m1.invoke(obj,"李四")

不论是反射调用的私有办法和公有办法，都是调用的创建对象 obj 的办法,obj 对象工夫上就是 student 办法
调用重载办法
重载 setInfo 办法

// 获取类的指定办法
Constructor c= clazz.getConstructor();// 获取无参结构
Object obj = con.newInstance();// 应用无参结构创建对象


Method m2 = clazz.getMethod("setInfo"，int.class);// 失去 setInfo 的重载办法

m2.invoke(obj(须要实例化的对象),args(调用以后办法的理论参数))
m2.invoke(obj,1)

调用有返回值但没有参数的办法

Method m3 = clazz.getMethod("getSchool");// 失去办法名为 getSchool，并且没有参数的办法

String school = (String)m3.invoke(obj);//Object 类强转为 String 类
sout(school);

调用指定属性

输入私有的属性

// 反射创立一个对象
Constructor c= clazz.getConstructor();// 获取无参结构
Student stu = (Student)con.newInstance();// 应用无参结构创建对象

// 拜访属性
Field f = clazz.getField("school");// 失去名称为 school 的属性

f.set(stu,"第三中学");// 对 stu 对象的 school 属性设置值第三中学
String school = (String)f.set(stu,"第三中学");// 获取 stu 对象的 school 属性的值
sout(school);

输入公有的属性

// 拜访属性
Field f1 = clazz.getDeclaredField("privateField");// 失去名称为 privateField 的属性

f1.setAccessible(true);// 解除公有封装，上面能够强制调用公有属性
f1.set(stu,"测试公有属性");
sout(f1.get(stu));

java 动静代理

写一个接口

写一个实现类实现这个接口

写一个主办法
在执行外面的办法时须要退出一些货色，执行后打印执行结束

做一个代理类
须要实现 InvocationHandler 接口


在主程序应用代理类