关于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());//输入属性名称
}

获取来源gaodai#ma#com搞@代~码网本类（不蕴含父类）的私有的属性，包含私有、公有

//获取本类（不蕴含父类）的所有的属性，包含私有、公有
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接口


在主程序应用代理类

喜欢 (0)赏

[搞代码]

分享 (0)