高新技术34-40

34.注解的定义与反射调用

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

把它加在某个类上：@MyAnnotation public class Annotation Test{}

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

根据发射测试的问题,引出@Retention元注解的讲解,其三种取值:

RetetionPolicy.SOURCE、RetetionPolicy.CLASS、

RetetionPolicy.RUNTIME;分别对应:java源文件-->class文件-->内存中的字节码.

思考:@Override、@SupperssWarnings和@Deprecated这三个注解的属性值分别是什么?

演示和讲解@Target元注解

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

 

元注解以及其枚举属性值不用记,只要会看jdk提供那个基本注释的API帮助稳当的定义或其源代码,按图索骥即可查到,或者直接看java.lang.annotation包下面的类.

import javax.jws.soap.InitParam;

 

@ItcastAnnotation

public class AnnotationTest {

 

/**

* @param args

*/

@SuppressWarnings("deprecation")

public static void main(String[] args) throws Exception{

System.runFinalizersOnExit(true);

if(AnnotationTest.class.isAnnotationPresent(ItcastAnnotation.class)){

            ItcastAnnotation annotation =(ItcastAnnotation) AnnotationTest.class.getAnnotation(ItcastAnnotation.class);

            System.out.println(annotation);

 

}

}

@Deprecated

public static void sayHello(){

System.out.println("hi,黑马");

}

 

}

 

 

 

 

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target({ElementType.METHOD,ElementType.TYPE})

public @interface ItcastAnnotation {

 

}

 

 

35.为注解增加各种属性

什么是注解的属性

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

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

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

@MyAnnotation(colo="red)

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

MyAnnotation a= (MyAnnotation)AnnotationTest.class.getAAnnotation(MyAnnotation.clas);

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

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

为属性指定缺省值:

String color() default "yellow"

 

数组类型的属性

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是MyAnnotation类的一个实例对象,同样的道理,摁扣仪认为上面这个@MetaAnnotation是MetaAnnotation类的一个实例对象,调用代码如下:

MetaAnnotation ma = myAnnotation.annotationAttr();

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

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

 

36.入门泛型的基本应用

Jdk 1.5以前的集合类中存在什么问题

ArrayList collection = new ArrayList();

collection.add(1);

collection.add(1L);

collection.add("abc");

int i = (integer)arrayList.get(1);//编译要强制类型转换且运行时出错

 

Jdk 1.5的集合类希望你在定义集合时,明确表示你要向集合中装哪种类型的数据,无法加入指定类型以外的数据

ArrayList<integer>collection2 = new ArrayList<integer>();

collection2.add(1);

/*collection2.add(1L);

collection2.add("abc");*/   //这两行代码编译时就报告了语法错误

int i2 = collection2.get(0);  //不需要再进行类型转换

 

 

import java.lang.reflect.Constructor;

import java.util.ArrayList;

 

public class GenericTest {

 

/**

* @param args

*/

public static void main(String[] args) throws Exception {

ArrayList collection1 = new ArrayList();

collection1.add(1);

collection1.add(1L);

collection1.add("abc");

int i = (Integer)collection1.get(1);

ArrayList<String> collection2 = new ArrayList<String>();

// collection2.add(1);

// collection2.add(1L);

collection2.add("abc");

String element collection2.get(1);

Constructor<String> constructor1 = String.class.getClassLoader(StringBuffer.class);

String str2 = (String)constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));

        System.out.println(str2.charAt(2));

}

 

}

 

 

37.泛型的内部原理及更深应用

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

 

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

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

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

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

ArrayList<Integer>中的<>念着typeof

ArrayList称为原始类型

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

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

Collection<String> c= new Vector();

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

Collection c = new Vector<String>();

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

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

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

在创建数组实例时,数组的元素不能使用参数化的类型,例如,下面语句有错误:

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

 

38.泛型的通配符扩展应用

 printCollection(collection3);

 

}

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

//collection.add(1);

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

for(Object obj : collection){

System.out.println(obj);

 

39.泛型集合的综合引用案例

  //Class<Number> x = String.class.asSubclass(Number.class);

        Class<?> y;

        Class<String> x; //Class.forName("java.lang.String");

 

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

        maps.put("zxx",28);

        maps.put("zxx",25);

        maps.put("zxx",33);

 

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

        for(Map.Entry<String,Integer> entry:entrySet){

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

        }

 

 

 

}

 

40.自定义泛型方法及其应用

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[i] = t;

}

用语放置泛型的类型参数的尖括号应出现在方法的其它所有修饰符之后和在方法的返回类型之前,也就是紧邻返回值之前.按照掼例,类型参数通常用单个大写字母表示.

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

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

Class.getAnnotation()方法的定义.并且可以用&来指定多个边界,如<Vextends Serializable&cloneable> void method(){}

普通方法、构造方法和静态方法中都可以使用泛型,编译器也不循序创建类型变量的数组.

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

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

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

 

  add(3,5);

        Number x1 = add(3.5,3);

        Object x2 = add(3,"abc");

 

        swap(new String[]{"abc","xyz","itcast"},1,2);

        //swap(new int[]{1,3,5,4,5},3,4};

 

 

 

 

}