Java 9：装B之前你必须要会的——泛型，注解，反射

2023-11-18

1 泛型

1.1 基本概念

泛型提供了编译期的类型检查，但问题远非这么简单

///原生态类型
List list1 = new ArrayList();   ///规避的类型检查
List list1 = new ArrayList<String>();

///参数化类型
List<Object> list2 = new ArrayList<Object>();  //可以放任何类型的对象，没指导意义
List<String> list3 = new ArrayList<String>();

///通配符类型
//无限制通配符类型
List<?> list4 = new ArrayList<Dog>();
//有限制通配符类型
List<? extends Animal> list4 = new ArrayList<Dog>();
List<? extends Animal> list4 = new ArrayList<Cat>();


List<String>里的String是：实际类型参数

在类和方法定义时，引入形式类型参数
public class List<T>{
    T[] data;
}
这里T是形式类型参数
List<T>就叫做：泛型

public class PrimitiveList<E extends Number>{
    E[] data;
}
<E extends Number>是有限制通配符类型


泛型方法
public <E> void do_sth(E e){

}

类型令牌
String.class
List.class
String[].class

带泛型的类型可以降级为不带泛型的类型


public static void main(){
    List<String> strings = new ArrayList<String>();
    unsafeAdd(strings, new Integer(42));
    String s = strings.get(0);
}

private static void unsafeAdd(List list, Object o){
    list.add(o);  //unchecked call to add(E) in raw type list
}
这段代码可以通过编译，
但会收到警告，unchecked call to add(E) in raw type list,
而且明显在运行时会收到ClassCastException

这种使用方式并不是一无是处，如果unsafeAdd是一个不关心List具体泛型类型的实现逻辑，
或者没法知道List的泛型类型，或者需要处理各种泛型类型的List，则这种写法是可取的

如果这样，则无法通过编译
private static void unsafeAdd(List<Object> list, Object o){
    list.add(o);  //unchecked call to add(E) in raw type list
}

无限制的通配符类型

如果一个方法需要传入List，但不关心List的具体泛型类型，则可以使用一个问号代替泛型，
这就是无限制的通配符

static int numElementsInCommon(Set<?> s1, Set<?> s2){
    int result = 0;
    for(Object o1: s1){
        if(s2.contains(o1))){
            result++;
        }

    }
    return result;
}

Set<?> set1 = ..;
Set set2 = ..;
set1和set2的区别是什么？
1 这两个都能接受所有泛型类型的Set
2 但是set1只能add一个类型的对象，set2可以add任何类型的对象

有限制的通配符类型

Set<? extends Aminal> set = ..;


对于Stack<E>，如果提供如下方法
public void pushAll(Iterable<? exnteds E> src){
    for(E e: src){
        push(e);
    }
}
试想，如果参数不用<? exnteds E>，怎么样才合适呢
<? exnteds E>在这里就是最好的选择


对于Stack<E>，如果提供如下方法
public void popAll(Collection<E> dst){
    while(!isEmpty()) dst.add(pop());
}
如果是Stack<Dog>，本来你用List<Dog>作为参数传入，可以
但如果你要用List<Animal>传入，就不行了，但逻辑上这么做是没问题的，所以方法一改：
public void popAll(Collection<? super E> dst){

}
意思是Collection的泛型类型是E的某个超类


所以对于泛型类型对应的对象E e
如果你要生产（put），即给e值，则E和E的子类都可以给，<? extends E>
如果你要消费（get），即x = e，则x即可以是E，也可以是E的基类或接口，<? super E>
这就是PECS原则，Producer extends，Consumer super

1.2 关于class对象：

List.class
String[].class
int.class
都是合法的

但是List.class不合法， List


if(o instanceof Set){
    Set<?> m = (Set<?>)o;
}

但你不能 o instanceof Set<String>

1.3 消除非受检警告：

情况1：


Set<Animal> animals = new HashSet();
这种情况可以很容易的得到编译器提醒unchecked

情况2：
如果你确定代码是类型安全的，可以@SuppressWarnings(“unchecked”)

1.4 数组和集合：


数组是协变的
Animal[] animals;
Dog[] dogs = new Dog[2];
animals = dogs;  //对的
animals[0] = new Cat(); //错的，ArrayStoreException

泛型是不可变的
List<Animal> animals;
List<Dog> dogs = new ArrayList<Dog>();
animals = dogs;  //错误的，编译报类型不匹配

数组是具体化的，reified，所以数组会在运行时才知道并检查他们的元素类型约束
泛型是通过擦除的，erasure，只能在编译时强化其类型信息，运行时丢弃

有泛型信息时，不能创建数组，以下都非法
List<E>[]
new List<String>[]
new E[]
为什么不可以这么创建数组呢，看下面的例子，如果可以这么创建数组的话：
List<String>[] stringLists = new List<String>[1];
List<Integer> intList = Arrays.asList(42);
Object[] objects = stringLists;
Object[0] = intList;
String s = stringLists[0].get(0);
上述代码的错误如果放到运行时，就是ClassCast错误，所以编译时第一行就会报错

E, List<E>, List<String>
这些都是不可具体化的类型，其运行时表示法包含的信息，要少于其编译时表示法包含的信息

注意：创建List<?>[] arr是合法的

1.5 泛型的类型推导

很复杂，规则很多，据说光文档就有16页

Lang.isEmpty(s)这种形式叫做显式类型参数

1.6 运行时获取泛型的具体类型：

参考TypeToken

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

public class TypeToken<T> {

    private final Type type;

    protected TypeToken(){
        Type superClass = getClass().getGenericSuperclass();

        type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
    }

    public Type getType() {
        return type;
    }

    public final static Type LIST_STRING = new TypeToken<List<String>>() {}.getType();



}


System.out.println(new TypeToken<List<Animal>>(){}.getType());
打印：
java.util.List<com.cowthan.Animal>

2 注解

注解是元数据

2.1 内置注解

提醒编译器的
@Override
@Deprecated
@SuppressWarnings 关闭警告

2.2 自定义注解

四大元注解：

@Target：注解能用在哪儿
- @Target(ElementType.METHOD)
- ElementType可能的值：
  - TYPE 用于class定义
  - CONSTRUCTOR 用于构造方法
  - METHOD 用于方法
  - FIELD 用于成员变量
  - LOCAL_VARIABLE 局部变量声明
  - PACKAGE 包声明
  - PARAMETER 方法参数声明
  - ANNOTATION_TYPE
  - TYPE_PARAMETER
  - TYPE_USE
@Retention：注解信息在哪个阶段有效
- @Retention(RetentionPolicy.RUNTIME)
- RetentionPolicy可能的值：
  - SOURCE：源码阶段，编译时，一般是用来告诉编译器一些信息，将被编译器丢弃
  - CLASS：注解在class文件中可用，会被VM丢弃
  - RUNTIME：运行时，VM在运行时也保留注解，这个才能通过反射获取到
Documented
- 将此注解包含在JavaDoc中
Inherited
- 允许子类继承父类中的注解

注解处理器：通过反射拿到注解

2.3 自定义注解实例

简单的例子，只展示了如何定义和使用注解，没有阐明如何处理注解

/**
 * 描述一个测试用例
 *
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface UseCase {

    public int id();
    public String description() default "no description";

}

public class UseCaseDemo {

    @UseCase(id = 1, description = "密码的格式必须规范")
    public boolean testPassword(String password){
        return false;
    }

    @UseCase(id = 2, description = "用户名的格式必须规范")
    public boolean testUsername(String username){
        return false;
    }

    @UseCase(id = 3, description = "新密码不能等于旧密码")
    public boolean testNewPwd(String password){
        return false;
    }
}

2.4 处理注解：运行时

下面是一个简单的序列化框架，使用了注解@Seriable的字段可以被序列化为json

@Target({ ElementType.FIELD, ElementType.TYPE })  
@Retention(RetentionPolicy.RUNTIME)  
public @interface Seriable  
{  

}  


public class User  
{  
    @Seriable  
    private String username;  
    @Seriable  
    private String password;  

    private String three;  
    private String four;  
}  

public boolean isSeriable(Field f){
    f.setAccessible(true);
    Seriable annotation = f.getAnnotation(Seriable.class);
    if(id == null){
        return false;
    }else{
        return true;
    }
}

2.5 处理注解：编译期

ButterKnife能根据注解生成代码，怎么做到的呢，涉及到apt和编译期处理器

http://www.cnblogs.com/avenwu/p/4173899.html

http://www.bubuko.com/infodetail-826234.html 这篇讲的挺好

http://www.jianshu.com/p/1910762593be 安卓版

http://blog.csdn.net/lmj623565791/article/details/43452969

重点有三个
- 定义注解和注解处理器
- 打成jar包
- 在任何项目里使用注解，编译时触发注解处理器


import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.Name;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.util.Elements;

@SupportedAnnotationTypes({"com.avenwu.annotation.PrintMe"})
public class BeanProcessor extends AbstractProcessor {

    // 元素操作的辅助类
    Elements elementUtils;

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        // 元素操作的辅助类
        elementUtils = processingEnv.getElementUtils();
    }


    @Override
    public boolean process(Set<? extends TypeElement> annotations,
            RoundEnvironment roundEnv) {

        for (TypeElement currentAnnotation : annotations) {
            Name qualifiedName = currentAnnotation.getQualifiedName();
            if (qualifiedName.contentEquals("com.avenwu.annotation.PrintMe")){
                Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(currentAnnotation);
                for (Element element : annotatedElements) {
                    Version v = element.getAnnotation(Version.class);
                    int major = v.major();
                    int minor = v.minor();
                    if(major < 0 || minor < 0) {
                        String errMsg = "Version cannot be negative. major = " + major + " minor = " + minor;
                        Messager messager = this.processingEnv.getMessager();
                        messager.printMessage(javax.tools.Diagnostic.Kind.ERROR,errMsg,element);
}
                }
            }
        }
        return true;
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

}

3 反射

反射等以后吧，安卓里面反射用的也不多，EventBus2就是基于反射，在EventBus3里已经
改成了预处理注解的方式

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Java专题

Java

泛型

对象

class