Java泛型机制与反射原理相关知识总结

一、泛型的概念

1.1 基础案例

泛型在Java中的应用非常广泛,最常见则是在集合容器中,先看下基础用法:

public class Generic01 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>() ;
        map.put(88,"hello") ;
        // map.put("99","world") ; 输入编译错误
        String value = map.get(88) ;
        // Integer value = map.get(88) ; 输出编译错误
        System.out.println("value:"+value);
    }
}

声明一个map类型的容器,并且明确限定key和value的类型:分别为Integer,String,这样显然不能体现特别之处,可以对比下面的用法:

Map newMap = new HashMap() ;
newMap.put("hello","world");
newMap.put(88,99);

在不指定类型的情况下,键值对都默认为Object类型,这样的容器在使用的时候要时刻注意不同的key类型和取出的value值类型,并且value要做类型转换,相比之下泛型机制就很有必要。

可以看下Map接口的定义:

public interface Map<K,V> {
    V get(Object key);
    V put(K key, V value);
}

在Map接口中,<K,V>显然没有指定明确的类型,只是起到类型传递的作用,即K是key的类型,V是value的类型,在上面的源码中描述的很清楚,结合上面案例,在Map对象声明的时候可以明确指定<K,V>的类型,也可以缺省为Object类型。

1.2 泛型描述

泛型即可以理解为把数据类型作为参数,即参数化类型,用来提高代码的安全性,灵活性,避免类型转换;代码简洁明了,同时对于程序的可扩展性起到至关重要的作用。

首先设计一个简单的顶层接口,只定义一个callBack方法,和对出入参数的简单逻辑设定,这种设计在Java的源码设计中随处可见,例如上面的集合体系:

/**
 * 基础接口设计
 * @param <R> 返参类型
 * @param <V> 入参类型
 */
interface CallBack<R,V> {
    /**
     * 回调方法:V 方法入参 ,R 方法返回值
     */
    R callBack (V v) ;
}

为了实现具体的业务,再基于顶层接口向下做扩展,这里声明两个扩展接口,作为具体业务类的接口:

/**
 * 扩展接口设计01
 */
interface ExtCallBack01<R extends Integer,V extends List<String>>
                        extends CallBack<Integer,List<String>> {
    @Override
    Integer callBack (List<String> list) ;
}
/**
 * 扩展接口设计01
 */
interface ExtCallBack02<R extends Boolean,V extends Map<String,Long>>
        extends CallBack<Boolean,Map<String,Long>> {
    @Override
    Boolean callBack (Map<String,Long> map) ;
}

这样可以通过扩展接口去设计具体的业务类,提高程序的灵活可扩展性:

public class Generic02 {
    public static void main(String[] args) {
        new ExtCallBack01<Integer,List<String>>(){
            @Override
            public Integer callBack(List<String> list) {
                list.add("hello");
                return list.size();
            }
        };
        new ExtCallBack02<Boolean,Map<String,Long>> (){
            @Override
            public Boolean callBack(Map<String, Long> map) {
                map.put("Fire",119L) ;
                return map.size()>0 ;
            }
        } ;
    }
}

通过上面这个案例,可以清楚的感觉到泛型机制的灵活和强大。

1.3 泛型本质

泛型虽然可以使用在类,接口,方法,参数等各个地方,但是其约束能力是在代码的编译期:

public class Generic03 {
    public static void main(String[] args) {
        DefEntry<String> defEntry1 = new DefEntry<>("hello") ;
        DefEntry<Long> defEntry2 = new DefEntry<>(999L) ;
        // Always True
        System.out.println(defEntry1.getClass()==defEntry2.getClass());
    }
}
class DefEntry<T> {
    private T param ;
    public DefEntry (T param){
        this.param = param ;
    }
}

编译过程中,会对泛型合法性作校验,校验成功编译的class文件没有泛型信息,即泛型擦除掉,通过一个简单的命令查看编译后的文件:

javap -v Generic03.class

当然这也会带来安全问题:

public static void main(String[] args) throws Exception {
    Map<String, String> map = new HashMap<>();
    Method method = HashMap.class.getDeclaredMethod("put",
                                new Class[] { Object.class, Object.class });
    method.invoke(map,888L, 999L);
    // {888=999}
    System.out.println(map);
    // java.lang.ClassCastException
    System.out.println(map.get(888L));
}

这里即通过反射的机制,绕开泛型,在map中放入程序语义上的非法值类型,在运行过程中获取值的时候才抛出类型转换异常。

二、反射机制

2.1 基础描述

反射机制可以在程序运行时获取类的完整结构信息,并且可以动态的操作属性和方法等。

对于反射机制的理解,必须要对类编译和JVM加载,运行时数据区有清楚的认识,这块内容可以移步JVM系列的文章。

通过运行时动态获取类的结构,然后动态的创建对象并操作属性和方法,这种方式在实际开发中并不多用,这样很明显会消耗JVM资源,并且会忽略一些封装导致安全问题,这在上面【1】中已经案例说明了。

2.2 反射的类库

  • java.lang.Class:Class类
  • java.lang.reflect.Constructor:构造器
  • java.lang.reflect.Field:属性
  • java.lang.reflect.Method:方法

API之Class对象

获取目标类型的Class对象常见方式,通过Class对象再获取相关结构信息,从而操作或者访问:

public static void main(String[] args) throws Exception {
    // Class对象回去
    User user1 = new User(1,"name01") ;
    Class userClass1 = user1.getClass() ;
    Class userClass2 = Class.forName("com.java.reflect.User");
    Class userClass3 = User.class ;
    System.out.println(User.class.getName());
    System.out.println("userClass1==userClass2?"+(userClass1==userClass2));
    System.out.println("userClass2==userClass3?"+(userClass2==userClass3));
    // 类型创建和判断
    Object object = User.class.newInstance() ;
    System.out.println("类型:"+(object instanceof User));
    System.out.println("类型:"+(userClass3.isInstance(user1)));
}

输出结果:

这里有个注意点:通过Class对象的newInstance()方法,即基于User类的无参构造器,首先要求User类具有无参构造方法。

API之Constructor构造器

Class对象读取构造方法,可以分别获得全部构造方法,不同修饰类型的构造方法,或者根据构造参数类型指定获取:

public static void main(String[] args) throws Exception {
    Class userClass = User.class ;

    // 读取公共构造方法
    Constructor[] userConArr = userClass.getConstructors();
    printCon(userConArr);

    // 读取指定私有构造方法
    Constructor privateCon = userClass.getDeclaredConstructor(Integer.class);
    System.out.println(privateCon);

    // 读取全部构造方法
    userConArr = userClass.getDeclaredConstructors();
    printCon(userConArr);

    // 调用公共构造方法创建对象
    Constructor pubCon = userClass.getConstructor(Integer.class,String.class);
    Object pubUser = pubCon.newInstance(1,"hello") ;

    // 调用私有构造方法创建对象
    Constructor priCon = userClass.getDeclaredConstructor(Integer.class);
    // 忽略private权限修饰符
    priCon.setAccessible(Boolean.TRUE);
    Object priUser = priCon.newInstance(2) ;
    System.out.println(pubUser+"\n"+priUser);
}
public static void printCon (Constructor[] constructors){
    for (Constructor constructor:constructors){
        System.out.println(constructor);
    }
}

这里需要注意的是,通过调用setAccessible(Boolean.TRUE)方法,可以基于私有构造方法创建对象,这里明显违背了Java的基本设计原则,破坏代码的安全性。

API之Field属性

Field保证成员变量的属性,修饰符,值管理等相关操作:

public static void main(String[] args) throws Exception {
    Class userClass = User.class ;
    // 获取公共字段
    Field[] pubArr = userClass.getFields() ;
    printField(pubArr);

    // 获取全部字段
    Field[] fieldArr = userClass.getDeclaredFields() ;
    printField(fieldArr);

    // 获取指定字段
    Field emailField = userClass.getField("email") ;
    Field nameField = userClass.getDeclaredField("name") ;
    printField(new Field[]{emailField,nameField});

    // 创建对象并操作属性
    Object userObj = userClass.newInstance() ;
    nameField.setAccessible(Boolean.TRUE);
    nameField.set(userObj,"world");
    emailField.set(userObj,"test@email.com");
    System.out.println("userObj:"+userObj);
}
/**
 * 打印成员变量信息
 */
public static void printField (Field[] fields){
    for (Field field : fields){
        System.out.println("声明:"+field);
        UserAnno userAnno = field.getAnnotation(UserAnno.class) ;
        System.out.println("注解:"+userAnno.desc());
        String fieldName = field.getName() ;
        System.out.println("名称:"+fieldName);
        Type type = field.getGenericType() ;
        System.out.println("类型:"+type);
    }
}

注意这里获取Type类型信息,在有些特定的业务场景下还是十分有用的。

API之Method方法

public static void main(String[] args) throws Exception {
    Class userClass = User.class ;
    // 获取所有公共方法[包括父类和Object类方法]
    Method[] pubMethods = userClass.getMethods() ;
    printMethod(pubMethods);
    // 获取全部方法
    Method[] allMethods = userClass.getDeclaredMethods() ;
    printMethod(allMethods);
    // 获取指定方法
    Method method = userClass.getMethod("parName",String.class) ;
    printMethod(new Method[]{method});
    // 调用方法
    Object userObj = userClass.newInstance() ;
    Method setId = userClass.getDeclaredMethod("setId", Integer.class);
    setId.invoke(userObj,99) ;
    Method setName = userClass.getDeclaredMethod("setName", String.class);
    setName.invoke(userObj,"java") ;
    Method sayHi = userClass.getDeclaredMethod("sayHi", String.class);
    sayHi.setAccessible(Boolean.TRUE);
    sayHi.invoke(userObj,"c++");
    System.out.println(userObj);
}
/**
 * 打印方法信息
 */
public static void printMethod (Method[] methods){
    for (Method method : methods){
        System.out.println("定义:"+method);
        System.out.println("命名:"+method.getName());
        UserAnno userAnno = method.getAnnotation(UserAnno.class) ;
        if (userAnno != null){
            System.out.println("注解:"+userAnno.desc());
        }
        Type[] paramTypeArr = method.getParameterTypes();
        for (int i=0 ; i< paramTypeArr.length; i++){
            System.out.print("参数"+(i+1)+"类型:"+paramTypeArr[i]+" ; ");
        }
        System.out.println("参数个数:"+method.getParameterCount());
    }
}

注意这里对方法的获取远远不止类本身定义的,包括从父类继承的,和Java基础Object类中的。

三、源代码地址

GitHub·地址
https://github.com/cicadasmile/java-base-parent

GitEE·地址
https://gitee.com/cicadasmile/java-base-parent

到此这篇关于Java泛型机制与反射原理相关知识总结的文章就介绍到这了,更多相关Java泛型机制与反射原理内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java注解与反射原理说明

    一 点睛 注解若想发挥更大作用,还需借助反射机制之力.通过反射,可以取得一个方法上声明的注解的全部内容. 一般有两种需求: 1 取得方法中全部的注解,通过调用getAnnotations来实现. 2 判断操作是否是指定注解,通过调用getAnnotation来实现. 下面从源码角度来说明怎样获取这些注解信息. 二 源码导读--取得方法中全部的注解 public class AccessibleObject implements AnnotatedElement { ... //取得全部Annot

  • Java基础之反射原理与用法详解

    本文实例讲述了Java基础之反射原理与用法.分享给大家供大家参考,具体如下: 1.什么是反射? 反射其实就是动态的加载类,我们在写JDBC的时候加载驱动Class.forName("xxx")时就涉及到了反射. 反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制. 2.反射机制能做什么? 1. 在运行时判断任意一个对象的所属的类Class.

  • Java泛型机制必要性及原理解析

    泛型程序设计(Generic Programming) "使用泛型机制编写的程序代码要比那些杂乱地使用Object变量,然后再进行强制类型转换的代码具有更好的安全性和可读性.泛型对于集合类尤其有用." 1.意义.必要性.重要性 泛型程序设计 意味着编写的代码可以被很多不同类型的对象所重用.例如,我们并不希望为聚集String和File对象分别设计不同的类.实际上,也不需要这样做,因为一个ArrayList类就可以聚集任何类型的对象.这是一个泛型程序设计的实例. 事实上,在Java增加泛

  • Java泛型机制的程序演示详解

    本文为大家分享了Java泛型机制的程序演示具体代码,供大家参考,具体内容如下 package packA; import java.util.*; public class GenericDemo { public static void main(String[] args) { TreeSet<String> ts = new TreeSet<String>( new LenSort() ); //<String> 泛型 ts.add("hidwju&qu

  • java反射原理制作对象打印工具

    主要运用java反射原理,格式化输出java对象属性值,特别是list 和map. MyTestUtil.java package utils; import java.lang.reflect.Field; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Collection; import java.util.Date; import java.util.Iterator; import

  • Java泛型机制与反射原理相关知识总结

    一.泛型的概念 1.1 基础案例 泛型在Java中的应用非常广泛,最常见则是在集合容器中,先看下基础用法: public class Generic01 { public static void main(String[] args) { Map<Integer,String> map = new HashMap<>() ; map.put(88,"hello") ; // map.put("99","world") ;

  • Java基础之反射技术相关知识总结

    一.反射概念 Java的反射(reflection)机制是指在程序的运行状态中,可以构造任意一个类的对象,可以了解任意一个对象所属的类,可以了解任意一个类的成员变量和方法,可以调用任意一个对象的属性和方法.这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制.反射被视为动态语言的关键. 二.反射应用场景 1.几乎所有的框架都会用到反射 2.程序解耦合使用 3.代码更加的优雅 三.反射更多细节 1.Jdk中的位置: java.lang.reflect包下 2.获取字节码方式 //

  • Java并发编程之死锁相关知识整理

    一.什么是死锁 所谓死锁是指多个线程因竞争资源而造成的一种僵局(互相等待),若无外力作用,这些进程都将无法向前推进 二.死锁产生的条件 以下将介绍死锁的必要条件,只要系统发生死锁,这些条件必然成立,而只要上述条件之一不满足,就不会发生死锁 互斥条件 进程要求对所分配的资源(如打印机〉进行排他性控制,即在一段时间内某资源仅为一个进程所占有.此时若有其他进程请求该资源,则请求进程只能等待 不可剥夺条件 进程所获得的资源在未使用完毕之前,不能被其他进程强行夺走,即只能由获得该资源的进程自己来释放(只能

  • 深入理解Java显式锁的相关知识

    目录 一.显式锁 二.Lock的常用api 三.Lock的标准用法 四.ReentrantLock(可重入锁) 五.ReentrantReadWriteLock(读写锁) 六.Condition 一.显式锁 什么是显式锁? 由自己手动获取锁,然后手动释放的锁. 有了 synchronized(内置锁) 为什么还要 Lock(显示锁)? 使用 synchronized 关键字实现了锁功能的,使用 synchronized 关键字将会隐式地获取锁,但是它将锁的获取和释放固化了,也就是先获取再释放.

  • Java基础学习之运算符相关知识总结

    1.算术运算符 +表示加法运算符 -表示减法运算符 *表示乘法运算符 /表示除法运算符 %表示取模/取余运算符 package com.lagou.Day03; /** * 算术运算符 */ public class Demo01 { public static void main(String[] args) { //1.声明两个int类型的变量并初始化 //int ia = 6;ib = 2;//表示声明两个int类型的变量ia和ib,不推荐使用 int ia = 6; int ib = 2

  • Java集合的总体框架相关知识总结

    一.集合概述 数组其实就是一个集合.集合实际上就是一个容器.可以来容纳其它的数据. 二.集合在开发中的应用 集合是一个容器,是一个载体,可以一次容纳多个对象.在实际开发中,假设连接数据库,数据库当中有10条记录,那么假设把这10条记录查询出来,在Java程序中会将10条数据封装成10个Java对象,然后将10个Java对象放到某一个集合当中,将集合传到前端,然后遍历集合,将一个数据一个数据展现出来 三.集合存储的数据 Java集合中实际存放的只是对象的引用,每个集合元素都是一个引用变量,实际内容

  • Java之SSM中bean相关知识汇总案例讲解

    bean 的生命周期 对象创建 实例化Bean对象,默认选择无参构造方法,如果只有一个有参构造那么调用有参构造,如果只有多个有参构造那么报错,除非其中一个有参构造添加了@AutoWired注解: 设置Bean的属性: 依赖注入以及判断是否实现了Aware相关接口(BeanNameAware, BeanFactoryAware, ApplicationContextAware) 如果这个 Bean 关联了 BeanPostProcessor 接口,将会调用BeanPostProcessor.pos

  • Java全面解析IO流相关知识

    目录 前言 一.File 1.File类的概述和构造方法 2.File类创建功能 3.File类判断和获取功能 4.File类删除功能 二.字节流 1.IO流的概述和分类 2.字节流写数据 3.字节流写数据的两个小问题 字节流写数据如何换行 字节流写数据如何实现追加写入 4.字节流写入数据假异常处理 5.字节流读数据(重点) 6.字节缓冲流 7.如何选择怎样得数据读取呢? 三.字符流 1.为什么会出现字符流? 2.字符串中的编码解码问题 3.如何实现解决编译解码的问题 4.字符流写数据的方法 5

随机推荐