java-反射

来源：互联网发布：软件测试目的编辑：程序博客网时间：2024/06/11 04:52

1 .java中的类加载器有3种

JVM有三种类加载器：bootstrap负责加载系统类，extclassloader负责加载扩展类，appclassloader负责加载应用类

这三个加载器就构成我们的 Java 类加载体系。他们分别从以下的路径寻找程序所需要的类： BootstrapLoader ： sun.boot.class.path ExtClassLoader: java.ext.dirs AppClassLoader: java.class.path

2.通过反射可以获得类的完整结构

package cn.itcast; 
  
import java.lang.reflect.Constructor; 
import java.lang.reflect.Field; 
import java.lang.reflect.Method; 
import java.lang.reflect.Modifier; 
  
public class ClassDemo05 { 
    publicstaticvoid main(String[] args) {
        Class<?> c1 =null;
  
        try{
            c1 = Class.forName("cn.itcast.Person");
        }catch(ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("-----------------获取实现的全部接口----------------");
        // 获取实现的全部接口
        Class<?> interfaces[] = c1.getInterfaces();
        for(Class<?> thisclass : interfaces) {
            System.out.println(thisclass.getName());
        }
  
        System.out.println("-----------------取得父类----------------");
        Class<?> superclass = c1.getSuperclass();
        System.out.println(superclass.getName());
  
        System.out.println("-----------------取得一个类中的全部的构造方法----------------");
        Constructor<?> constructors[] = c1.getConstructors();
        for(inti = 0; i < constructors.length; i++) {
            Class<?> parameterTypes[] = constructors[i].getParameterTypes();
            //取得权限
            intmodifiers = constructors[i].getModifiers();
            //还原权限(public static String toString(int mod))
            System.out.println(Modifier.toString(modifiers));
            //输出构造方法名称
            String name = constructors[i].getName();
            //循环打印参数类型
            for(intj = 0; j < parameterTypes.length; j++) {
                System.out.println(parameterTypes[j]);
                System.out.println(modifiers);
                System.out.println(name);
            }
              
        }
        System.out.println("-----------------------取得全部的方法-------------------------");
        //获取全部的方法
        Method[] methods = c1.getMethods();
        for(intj = 0; j < methods.length; j++) {
            System.out.println(methods[j]);
            //得到方法的返回值类型
            Class<?> returnType = methods[j].getReturnType();
            System.out.println(returnType);
            //得到全部参数的类型
            Class<?>[] parameterTypes2 = methods[j].getParameterTypes();
            for(Class<?> class1 : parameterTypes2) {
                System.out.println(class1);
            }
            //获得全部异常抛出
            Class<?>[] exceptionTypes = methods[j].getExceptionTypes();
            //判断是否有异常
            if(exceptionTypes.length>0)
            {
                System.out.println(") throws ");
            }else{
                System.out.println(")");
            }
            for(inti = 0; i < exceptionTypes.length; i++) {
                System.out.println(exceptionTypes[i].getName());
                if(i<exceptionTypes.length-1)
                {
                    System.out.println(",");
                }
            }
            System.out.println();
        }
        System.out.println("==================取得本类全部属性==================");
        //得到本类中的属性
        Field[] declaredFields = c1.getDeclaredFields();
        for(inti = 0; i < declaredFields.length; i++) {
            //取得本类中属性类型
            Class<?> type = declaredFields[i].getType();
            System.out.println(type);
            //得到修饰符的数字
            intmodifiers = declaredFields[i].getModifiers();
            System.out.println(modifiers);
            //取得属性的修饰符
            String priv = Modifier.toString(modifiers);
            System.out.println(priv);
              
        }
        System.out.println("==================取得父类全部属性==================");
        Field[] fields = c1.getFields();
        for(inti = 0; i < fields.length; i++) {
            Class<?> type = fields[i].getType();
            System.out.println(type);
            intmodifiers = fields[i].getModifiers();
            System.out.println(modifiers);
            String priv = Modifier.toString(modifiers);
            System.out.println(priv);
        }
    }
}

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
Person类： 
package cn.itcast02; 
  
public class Person implementsChina{
    privateString name;
    privateintage; 
    privatecharsex; 
  
    publicPerson() {
        super();
    }
  
    publicPerson(String name,intage, char sex) { 
        super();
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
  
    publicString getName() {
        returnname;
    }
  
    publicvoidsetName(String name) {
        this.name = name;
    }
  
    publicintgetAge() { 
        returnage;
    }
  
    publicvoidsetAge(intage) {
        this.age = age;
    }
  
    publicchargetSex() { 
        returnsex;
    }
  
    publicvoidsetSex(charsex) {
        this.sex = sex;
    }
    publicvoideat() 
    {
        System.out.println("吃了");
    }
  
    @Override
    publicString toString() {
        return"Person [name="+ name +", age="+ age +", sex=" + sex +"]"; 
    }
  
    @Override
    publicvoidsayChina() { 
        // TODO Auto-generated method stub
        System.out.println("作者："+ AUTHOR +"国籍："+ NATIONAL);
    }
  
    @Override
    publicString sayHello(String name,intage, char sex) { 
        // TODO Auto-generated method stub
        return"姓名:"+ name +"年龄："+ age +"性别:"+ sex;
    }
  
}

1
2
3
4
5
6
7
8
9
10
11
China接口： 
package cn.itcast02; 
  
public interface China { 
    publicstaticfinal String NATIONAL ="China";
    publicstaticfinal String AUTHOR = "成龙";
  
    publicvoidsayChina(); 
  
    publicString sayHello(String name,intage, char sex); 
}

3.利用反射创建类则需要该类有无参的构造函数

以前写的些方法都是这样干的：

Class cls = Class.forName(“className”);

*** inst = cls.newInstance();

那样只能调用默认构造函数，也就是没有参数的，前几天要整个反射类，调用的是有参构造函数，解决如下：

   Class cls = Class.forName(className);
   Class[] paramTypes = { String.class, String.class, String.class,
     String.class };
   Object[] params = {bankCde, branchCde, buzDate, loanNo}; // 方法传入的参数

Constructor con = cls.getConstructor(paramTypes); //主要就是这句了
BatcherBase base = (BatcherBase) con.newInstance(params); //BatcherBase 为自定义类

4.动态代理用到反射模式

0 0