乐趣区

关于java:Java进阶-泛型机制与反射原理

一、泛型的概念

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 类型。

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 ;}
        } ;
    }
}

通过下面这个案例,能够分明的感觉到泛型机制的灵便和弱小。

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 中放入程序语义上的非法值类型,在运行过程中获取值的时候才抛出类型转换异样。

二、反射机制

1、根底形容

反射机制能够在程序运行时获取类的残缺构造信息,并且能够动静的操作属性和办法等。

对于反射机制的了解,必须要对类编译和 JVM 加载,运行时数据区有分明的意识,这块内容能够移步 JVM 系列的文章。

通过运行时动静获取类的构造,而后动静的创建对象并操作属性和办法,这种形式在理论开发中并不多用,这样很显著会耗费 JVM 资源,并且会疏忽一些封装导致平安问题,这在下面【1】中曾经案例阐明了。

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 根底】【设计模式】【构造与算法】【Linux 零碎】【数据库】

【分布式架构】【微服务】【大数据组件】【SpringBoot 进阶】【Spring&Boot 根底】

【数据分析】【技术导图】【职场】

退出移动版