java基础(9) - 泛型解析

泛型

定义简单的泛型类 泛型方法

    /**
     * 1.定义一个泛型类
     *      在类名后添加类的泛型参数 <T>
     *      泛型类里面的所有T会根据创建泛型类时传入的参数确定类型
     * 2.定义泛型方法
     *      在方法名之前添加泛型参数 <U>
     *      U的类型会根据方法调用时传入的参数类型来确定
     */
    public class Box<T> {
        private T something;
        public T getSomething() {
            return something;
        }

        public <U> U getNewThing(U t){
            return t;
        }

        public void setSomething(T something) {
            this.something = something;
        }

        public static void main(String[] args) {
            Box<String> box1 = new Box<String>();
            box1.setSomething("圣杯");
            System.out.println(box1.getSomething());
            System.out.println(box1.getNewThing("先挣它的一个亿"));
        }
    }

泛型变量的限定

extends 后可接 接口 或 类 ，用 & 隔开多个限定类型（将接口放到最后，避免虚拟机进行转换操作）

    public <T extends People> T getPeople(T people){
            return people;
    }

通配符类型

    //通配符  匹配people的子类
    public String getSomething(Box<? extends People> b){
        return b.getSomething().getName();
    }

    //匹配 Hero的父类
    public String getSomething2(Box<? super Hero> b){
        return b.getSomething().toString();
    }

注意事项

不能使用基础类型初始化泛型参数（如int,只能用Integer）

不能实例化类型变量（如 new T()）

静态属性，方法不能使用泛型参数

不能抛出，捕获泛型参数异常

反射

• 运行中分析一个类
• 运行中查看对象
• 实现通用的操作

    /**
     * 解析类
     */
    String className = "knowledge.oop.Hero";
    Class<?> clazz = Class.forName(className);
    //解析类名
    Class<?> superClazz = clazz.getSuperclass();
    System.out.println("父类名: "+ superClazz.getName());

    //解析类修饰符
    String modifier = Modifier.toString(clazz.getModifiers());
    System.out.println("类修饰符: "+ modifier);

    //解析构造器
    Constructor[] constructors = clazz.getDeclaredConstructors();
    for(Constructor<?> c :constructors){
        System.out.println("构造器: " + c.getName());
        //解析构造器修饰符
        String mc = Modifier.toString(c.getModifiers());
        System.out.println("构造器修饰符: "+mc);
        //解析构造器 参数
        Class [] cp = c.getParameterTypes();
        for(int i =0;i< cp.length;i++){
            System.out.println("构造器参数: "+cp[i].getName());
        }
        System.out.println();System.out.println();
    }
    /**
     * 解析方法
     */
    Method [] methods = clazz.getMethods();
    for(Method m : methods){
        System.out.print("方法名: " + m.getName());
        String mc = Modifier.toString(m.getModifiers());
        System.out.print(" 方法修饰符: "+mc);
        Class returnType = m.getReturnType();
        System.out.print(" 方法返回类型: " + returnType.getName());
        //解析构造器 参数
        Class [] cp = m.getParameterTypes();
        if(cp.length > 0) System.out.println();
        for(int i =0;i< cp.length;i++){
            System.out.print("方法参数: "+cp[i].getName());
        }
        System.out.println();System.out.println();
    }

    /**
     * 解析属性
     */
    Field [] fields = clazz.getDeclaredFields();
    for(Field f : fields){
        System.out.println("属性名: " + f.getName());
        Class type = f.getType();
        System.out.println("属性类型: "+type.getName());
        String mc = Modifier.toString(f.getModifiers());
        System.out.print("属性修饰符: "+mc);
        System.out.println();System.out.println();
    }

    /**
     * 实例属性 操作
     */
    Field iFeild = clazz.getDeclaredField("skill");
    //这里不允许获取私有域的值 ,设置允许访问
    iFeild.setAccessible(true);
    System.out.println(iFeild.get(hero));
    //修改值
    iFeild.set(hero, "狂化");
    System.out.println(iFeild.get(hero));

    /**
     * 实例方法操作
     */
    Method iMethod = clazz.getMethod("getName");
    String s = (String) iMethod.invoke(hero);
    System.out.println(s);