java基础加强（三）（注解与泛型）

注解与泛型

 

九、注解

 

java提供的几个基本注解

 

@SuppressWarnings

通过System.runFinalizersOnExit(true);的编译警告引出@SuppressWarnings

 

("deprecation")

@Deprecated

直接在刚才的类中增加一个方法，并加上@Deprecated标注，在另外一个类中调用

 

这个方法。

@Override

public boolean equals(Reflect other)方法与HashSet结合讲解

总结：

注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则

 

等于没有某种标记，以后，javac编译器，开发工具和其他程序可以用反射来了解

 

你的类及各种元素上有无何种标记，看你有什么标记，就去干相应的事。标记可以

 

加在包，类，字段，方法，方法的参数以及局部变量上。

看java.lang包，可看到JDK中提供的最基本的annotation。

 

为注解增加基本属性

 

什么是注解的属性

一个注解相当于一个胸牌，如果你胸前贴了胸牌，就是传智播客的学生，否则，就

 

不是。如果还想区分出是传智播客哪个班的学生，这时候可以为胸牌在增加一个属

 

性来进行区分。加了属性的标记效果为：@MyAnnotation(color="red")

定义基本类型的属性和应用属性：

   在注解类中增加String color();

   @MyAnnotation(color="red")

用反射方式获得注解对应的实例对象后，再通过该对象调用属性对应的方法

   MyAnnotation a = (MyAnnotation)

 

AnnotationTest.class.getAnnotation(MyAnnotation.class);

   System.out.println(a.color());

可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象

为属性指定缺省值：

  String color() default "yellow";

value属性：

  String value() default "zxx";

如果注解中有一个名称为value的属性，且你只想设置value属性（即其他属性都

 

采用默认值或者你只有一个value属性），那么可以省略value=部分，例如：

 

@MyAnnotation("lhm")。

 

 

为注解增加高级属性

 

数组类型的属性

   int [] arrayAttr() default {1,2,3};

   @MyAnnotation(arrayAttr={2,3,4})

   如果数组属性中只有一个元素，这时候属性值部分可以省略大括

枚举类型的属性

   EnumTest.TrafficLamp lamp() ;

   @MyAnnotation(lamp=EnumTest.TrafficLamp.GREEN)

注解类型的属性：

   MetaAnnotation annotationAttr() default @MetaAnnotation("xxxx");

   @MyAnnotation(annotationAttr=@MetaAnnotation(“yyy”) )

可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象，同样的道理

 

，可以认为上面这个@MetaAnnotation是MetaAnnotation类的一个实例对象，调

 

用代码如下：

       MetaAnnotation ma =  myAnnotation.annotationAttr();

       System.out.println(ma.value());

注解的详细语法可以通过看java语言规范了解，即看java的language

 

specification。

 

 

 十、泛型

   泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡

 

住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，

 

使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和

 

原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编

 

译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再

 

调用其add方法即可。

 

   了解泛型：

ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：

整个称为ArrayList<E>泛型类型

ArrayList<E>中的E称为类型变量或类型参数

整个ArrayList<Integer>称为参数化的类型

ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数

ArrayList<Integer>中的<>念着typeof

ArrayList称为原始类型

参数化类型与原始类型的兼容性：

参数化类型可以引用一个原始类型的对象，编译报告警告，例如，

 

Collection<String> c = new Vector();//可不可以，不就是编译器一句话的

 

事吗？

原始类型可以引用一个参数化类型的对象，编译报告警告，例如，
Collection

 

c = new Vector<String>();//原来的方法接受一个集合参数，新的类型也要能

 

传进去

参数化类型不考虑类型参数的继承关系：

Vector<String> v = new Vector<Object>(); //错误!///不写<Object>没错，

 

写了就是明知故犯

Vector<Object> v = new Vector<String>(); //也错误!

编译器不允许创建泛型变量的数组。即在创建数组实例时，数组的元素不能使用参

 

数化的类型，例如，下面语句有错误：

      Vector<Integer> vectorList[] = new Vector<Integer>[10];

 

   泛型中的？通配符

问题：

定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据，该方法如

 

何定义呢？

错误方式：

public static void printCollection(Collection<Object> cols) {

              for(Object obj:cols) {

                     System.out.println(obj);

              }

              /* cols.add("string");//没错

               cols = new HashSet<Date>();//会报告错误！*/

}

正确方式：

public static void printCollection(Collection<?> cols) {

              for(Object obj:cols) {

                     System.out.println(obj);

              }

              //cols.add("string");//错误，因为它不知自己未来匹配就

 

一定是String

              cols.size();//没错，此方法与类型参数没有关系

               cols = new HashSet<Date>();

       }

总结：

使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，

 

可以调用与参数化无关的方法，不能调用与参数化有关的方法

 

   泛型中的？通配符的扩展

 

限定通配符的上边界：

正确：Vector<? extends Number> x = new Vector<Integer>();

错误：Vector<? extends Number> x = new Vector<String>();

限定通配符的下边界：

正确：Vector<? super Integer> x = new Vector<Number>();

错误：Vector<? super Integer> x = new Vector<Byte>();

提示：

限定通配符总是包括自己。

?只能用作引用，不能用它去给其他变量赋值

       Vector<? extends Number> y = new Vector<Integer>();

       Vector<Number> x = y;

       上面的代码错误，原理与Vector<Object > x11 = new

 

Vector<String>();相似，

       只能通过强制类型转换方式来赋值

 

   泛型集合类的综合案例

 

  能写出下面的代码即代表掌握了Java的泛型集合类：

 HashMap<String,Integer> hm = new HashMap<String,Integer>();

  hm.put("zxx",19);

  hm.put("lis",18);

 

  Set<Map.Entry<String,Integer>> mes= hm.entrySet();

  for(Map.Entry<String,Integer> me : mes) {

   System.out.println(me.getKey() + ":" + me.getValue());

  }

 

  定义泛型方法：

 

Java的泛型方法没有C++模板函数功能强大，java中的如下代码无法通过编译：

<T> T add(T x,T y) {

              return (T) (x+y);

              //return null;

       }

用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的

 

返回类型之前，也就是紧邻返回值之前。按照惯例，类型参数通常用单个大写字母

 

表示。

交换数组中的两个元素的位置的泛型方法语法定义如下：

static <E> void swap(E[] a, int i, int j) {

       E t = a[i];

       a[i] = a[j];

       a[j] = t;

}//或用一个面试题讲：把一个数组中的元素的顺序颠倒一下

只有引用类型才能作为泛型方法的实际参数，swap(new int[3],3,5);语句会报告

 

编译错误。

除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限

 

定符，例如，Class.getAnnotation()方法的定义。并且可以用&来指定多个边界

 

，如<V extends Serializable & cloneable> void method(){}

普通方法、构造方法和静态方法中都可以使用泛型。

也可以用类型变量表示异常，称为参数化的异常，可以用于方法的throws列表中，

 

但是不能用于catch子句中。

在泛型中可以同时有多个类型参数，在定义它们的尖括号中用逗号分，例如：

public static <K,V> V getValue(K key) { return map.get(key);}

 

类型参数的类型推断：

 

编译器判断范型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉

 

推断的，其实现方法是一种非常复杂的过程。

根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：

当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么

 

根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接

 

根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：

        swap(new String[3],3,4)   ?    static <E> void swap(E[] a,

 

int i, int j)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调

 

用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断

 

出来，例如：

        add(3,5)   ? static <T> T add(T a, T b)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调

 

用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候

 

取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编

 

译没问题，只是运行时出问题：

        fill(new Integer[3],3.5f)   ? static <T> void fill(T[] a, T

 

v)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调

 

用方法时这多处的实际应用类型对应到了不同的类型， 并且使用返回值，这时候

 

优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将

 

报告错误，将变量x的类型改为float，对比eclipse报告的错误提示，接着再将变

 

量x类型改为Number，则没有了错误：

        int x =(3,3.5f)   ? static <T> T add(T a, T b)

参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编

 

译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为

 

String类型，编译将出现问题：

       copy(new Integer[5],new String[5]) ? static <T> void copy(T

 

[] a,T[]  b);

       copy(new Vector<String>(), new Integer[5]) ? static <T> void

 

copy(Collection<T> a , T[] b);

 

定义泛型类型：

 

如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型

 

要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级

 

别的泛型，语法格式如下：

       public class GenericDao<T> {

              private T field1;

              public void save(T obj){}

              public T getById(int id){}

       }

类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如

 

下两种方式都可以：

GenericDao<String> dao = null;

new genericDao<String>();

注意：

在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。

当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态

 

变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员

 

不应该有类级别的类型参数。

问题：类中只有一个方法需要使用泛型，是使用类级别的泛型，还是使用方法级别

 

的泛型？

 

通过反射获得泛型的参数化类型：

 

示例代码：

       Class GenericalReflection {

                private Vector<Date> dates = new Vector<Date>();

                public void setDates(Vector<Date> dates) {

                  this.dates = dates;

                }

                public static void main(String[] args) {

                 Method methodApply =

 

GenericalReflection.class.getDeclaredMethod("applyGeneric",

 

Vector.class);

                 ParameterizedType pType = (ParameterizedType)

                                  (methodApply

 

.getGenericParameterTypes())[0];

                          System.out.println("setDates("

                                  + ((Class) pType.getRawType

 

()).getName() + "<"

                                  + ((Class)

 

(pType.getActualTypeArguments()[0])).getName()

                                  + ">)" );

                }

       }

 

泛型DAO的应用：

public abstract class DaoBaseImpl<T> implements DaoBase<T> {

       protected Class<T> clazz;

       public DaoBaseImpl() {

              Type type = this.getClass().getGenericSuperclass();

              ParameterizedType pt = (ParameterizedType) type;

              this.clazz = (Class) pt.getActualTypeArguments()[0];

              System.out.println("clazz = " + this.clazz);

       }

       }

public class ArticleDaoImpl extends DaoBaseImpl<Article> implements

 

ArticleDao {

       }