黑马程序员—Java高新技术3

 

---------------------- android培训、java培训、期待与您交流！ ----------------------

今天学习了两个大的知识点：注解和泛型，之前没有系统的学习过，所以是作为新知识来接受的，可能一天二天不可能掌握的那么透彻，但我相信自己的学习能力，在以后的学习中，会逐渐巩固加强......

 

9、注解（JDK1.5）

1.了解注解及java提供的几个基本注解

1).注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则等于没有某种标记，以后，javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记，看你有什么标记，就去干相应的事。标记可以加在包，类，字段，方法，方法的参数以及局部变量上。

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

2).Java中的三个基本注解

1).@Override（RetetionPolicy.SOURCE）

2).@SuppressWarnings（RetetionPolicy.SOURCE）

3).@Deprecated（RetetionPolicy.RUNTIME）

2.注解的应用结构图

注解就相当于一个你的源程序中要调用的一个类，要在源程序中应用某个注解，得先准备好了这个注解类。就像你

要调用某个类，得先有开发好这个类。

3、自定义注解及其应用

定义一个简单的注解：public @interface MyAnnotation {}

@Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD,ElementType.TYPE}) public @interface MyAnnotation {     String color() default "yellow";     String value() ;     int [] arrayAttr() default {1,2};     EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.RED;     MetaAnnotation annotationAttr() default @MetaAnnotation("xxx"); }

把它加在某个类上：@MyAnnotation public classAnnotationTest{}

@SuppressWarnings("deprecation") @MyAnnotation(value="zxx",arrayAttr={3,5,6},lamp=EnumTest.TrafficLamp.GREEN) public class AnnotationTest {     public static void main(String[] args) {         System.runFinalizersOnExit(true);         if(AnnotationTest.class.isAnnotationPresent(MyAnnotation.class))         {             MyAnnotation myAnnotation = AnnotationTest.class.getAnnotation(MyAnnotation.class);             System.out.println(myAnnotation.color());             System.out.println(myAnnotation.value());             System.out.println(                     myAnnotation.arrayAttr().length);             System.out.println(                     myAnnotation.lamp().next().name());             System.out.println(myAnnotation.annotationAttr().value());         }       }     @Deprecated     public static void sayHello()     {         System.out.println("hello,传智播客");     } }

用反射进行测试AnnotationTest的定义上是否有@MyAnnotation

用反射进行测试的代码：

if(ReflectPoint.class.isAnnotationPresent(MyAnnotation.class)) {     System.out.println(AnnotationTest.class.getAnnotation(MyAnnotation.class) );

@Retention元注解的三种取值：RetetionPolicy.SOURCE、RetetionPolicy.CLASS、RetetionPolicy.RUNTIME;分别对应：java源文件-->class文件-->内存中的字节码。

@Target的默认值为任何元素，设置Target等于ElementType.METHOD，原来加在类上的注解就报错了，改为用数组方式设置{ElementType.METHOD,ElementType.TYPE}就可以了。

4、为注解增加基本属性

1).什么是注解的属性

一个注解相当于一个胸牌，如果你胸前贴了胸牌，就是传智播客的学生，否则，就不是。如果还想区分出是传智播客哪个班的学生，这时候可以为胸牌在增加一个属性来进行区分。加了属性的标记效果为：@MyAnnotation(color="red")

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

在注解类中增加Stringcolor();

@MyAnnotation(color="red")

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

MyAnnotationa = (MyAnnotation)AnnotationTest.class.getAnnotation(MyAnnotation.class);

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

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

4).为属性指定缺省值：

Stringcolor() default "yellow";

5).value属性：

Stringvalue() default "zxx";

如果注解中有一个名称为value的属性，且你只想设置value属性（即其他属性都采用默认值或者你只有一个value属性），那么可以省略value=部分，例如：@MyAnnotation("lhm")。

5、    为注解增加高级属性

1).数组类型的属性

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

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

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

2).枚举类型的属性

EnumTest.TrafficLamplamp() ;

@MyAnnotation(lamp=EnumTest.TrafficLamp.GREEN)

3).注解类型的属性：

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

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

可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象，同样的道理，可以认为上面这个@MetaAnnotation是MetaAnnotation类的一个实例对象，调用代码如下：

      MetaAnnotation ma =  myAnnotation.annotationAttr();

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

 

10、泛型

1.泛型概念

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

2.了解泛型

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

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

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

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

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

e.ArrayList<Integer>中的<>念着typeof

f.ArrayList称为原始类型

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

a.参数化类型可以引用一个原始类型的对象，编译报告警告，例如，
Collection<String> c = new Vector();

b.原始类型可以引用一个参数化类型的对象，编译报告警告，例如，
Collection c = new Vector<String>();//原来的方法接受一个集合参数，新的类型也要能传进去

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

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

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

编译器不允许创建泛型变量的数组。即在创建数组实例时，数组的元素不能使用参数化的类型，例如，下面语句有错误：

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

3.泛型中的？通配符

1).使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。

2).泛型中的？通配符的扩展

a.限定通配符的上边界：

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

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

b.限定通配符的下边界：

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

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

3).范例

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

        System.out.println(collection.size());

        for (Object obj : collection) {

            System.out.println(obj);

        }

4.泛型集合类的综合案例

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

5.定义泛型方法

 1).<T>用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前，也就是紧邻返回值之前。按照惯例，类型参数通常用单个大写字母表示,即如<T>。

 2).只有引用类型才能作为泛型方法的实际参数，method (new int[3]);语句会报告编译错误。

 3).除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符，例如，Class.getAnnotation()方法的定义。并且可以用&来指定多个边界，如<V extends Serializable& cloneable> void method(){}-à(加强理解)

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

 5).也可以用类型变量表示异常，称为参数化的异常，可以用于方法的throws列表中，但是不能用于catch子句中。

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

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

7).代码示例：

private static <T> void fillArray(T[] a, T obj) {         for (int i = 0; i < a.length; i++) {             a[i] = obj;         }     }       private static <T> T autoConvert(Object obj) {         return (T) obj;     }       private static <T> void swap(T[] a, int i, int j) {         T tmp = a[i];         a[i] = a[j];         a[j] = tmp;     }

 

6. 类型参数的类型推断

1>.编译器判断范型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断的，其实现方法是一种非常复杂的过程。

2>.根据调用泛型方法时实际传递的参数类型或返回值的类型来推断。

7．定义泛型类型

1).如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型。

 2).定义泛型类型时涉及的问题：

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

B.当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数。

3).示例代码

import java.util.Set; public class GenericDao<E>  {      public void add(E x){                  }        public E findById(int id){             return null;      }        public void delete(E obj){                  }         public void delete(int id){                  }             public void update(E obj){                  }        public static <E> void update2(E obj){                  }        public E findByUserName(String name){             return null;      }      public Set<E> findByConditions(String where){             return null;      } }

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

示例代码：

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()                                 + ">)" );               }      }

 

 

----------------------android  java培训、期待与您交流！----------------------

详细请查看：http://edu.csdn.net/heima