J2SE 5.0新功能

类别:Java 点击:0 评论:0 推荐:

1.   Generic Types

在5.0以前,当我们需要从集合类当中提取出某个元素时,需要显式的对他进行下塑造型,如

ArrayList list = new ArrayList();

         list1.add(0, new Integer(42));

         int total = ((Integer)list1.get(0)).intValue();

 

在5.0当中,通过使用Generic Types,即将集合类(Collection)的声明写成Collection<E>,这样我们就可以在使用的时候不需要再进行显示的造型

         ArrayList<Integer> list = new ArrayList<Integer>();

         list.add(0, new Integer(42));

         int total = list.get(0).intValue();

 

2.   Autoboxing and Auto-Unboxing of Primitive Types

由于集合类(Collection)里面只能保存从Object当中继承而来的对象,所以对于基本类型(Primitive Type)的变量,如int,float等,在添加到Collection当中时,需要使用他们对应的封装类Integer,Float等,如:

          ArrayList<Integer> list = new ArrayList<Integer>();

         list.add(0, new Integer(42));

          int total = (list.get(0)).intValue();

 

在5.0当中,通过使用Autoboxing和Auto-Unboxing我们就不再需要显式的使用这些封装类了。

          ArrayList<Integer> list = new ArrayList<Integer>();

          list.add(0, 42);

          int total = list.get(0);

 

3.   Enhanced for Loop

一般来说,当我们需要对数组和集合进行遍历时,我们需要这样做:

          ArrayList<Integer> list = new ArrayList<Integer>();

           list.add(0,1);

           list.add(1,2);

          for (Iterator i = list.iterator(); i.hasNext();) {

                   Integer value=(Integer)i.next();

          }

但使用了5.0的Enhanced for Loop以后,我们的循环可以变得很简单:

         ArrayList<Integer> list = new ArrayList<Integer>();

         list.add(0,1);

         list.add(1,2);

         for(int i:list){

              System.out.println(i);

         }

 

同理,数组的遍历也从原来的:

         int[] b = new int[3];

         for(int i=0;i<b.length;i++){System.out.println(b[i]);}

变为:

         int[] b = new int[3];

         for(int i:b){System.out.println(i);}

 

总结:

Enhanced for Loop的语法:

for ( FormalParameter : Expression )
            Statement

等价于原来的:

for ( Iterator<E> #i = Expression.iterator(); #i.hasNext(); ) {
        FormalParameter = #i.next();
        Statement

}

 

即            FormalParameter = Expression.iteraotor().next();

 

4.   Enumerated Types

从5.0开始,j2se支持枚举类型。简单的枚举使用如下:

     public enum Color{RED,BLUE,GREEN;};

     public static void main(String[] args){       

         for(Color c:Color.values()){

              System.out.println(c);

         }

     }

     输出为

     RED

     BLUE

     GREEN

 

稍微复杂一点的使用,可以增加对枚举类型的定义:

     public enum Color{RED(1),BLUE(5),GREEN(7);

         private int value;

         Color(int value){this.value = value;}

         public int value(){return this.value;}

         };

     public static void main(String[] args){       

         for(Color c:Color.values()){

              System.out.println(c);

              System.out.println(c.value() == 1);

         }

     }

     输出为:

     RED

     True

     BLUE

     false

     GREEN

     false

 

     其中在枚举的声明当中的这部分内容:

private int value;

         Color(int value){this.value = value;}

         public int value(){return this.value;}

     就等价与声明了一个Color类:

          public class Color{

private int value;

               Color(int value){this.value = value;}

               public int value(){return this.value;}

}

    

还有就是,枚举也能用于switch结构当中,象

     switch(c){

         case RED:…

         case BLUE:…

}

 

5.   Static Import

以前,当我们要使用某个类当中的某个static变量,如BorderLayout.CENTER时,我们需要进行完整的书写,但通过使用Static Import,我们可以只书写CENTER即可,即:

import static java.awt.BorderLayout.*          //   导入

 

getContentPane().add(new JPanel(),CENTER);     //   使用

 

Static Import的使用,使得我们在不引入类的情况下,能只引用某个类的static变量

 

6.   Formatted Output and Formatted Input

Formatted Output使得我们可以使用类C的printf方法中的格式化变量,对输出进行格式化,如

     System.out.printf(“%s %5d %n”,user,total);

 

7.   Varargs

先看一个5.0当中的例子:

public class Test{

          public Test(){}

    

          public void out(String ...args){

              for(String s:args){

                   System.out.println(s);

              }

          }

    

          public static void main(String[] args){       

               Test t = new Test();

              t.out("a","b","c");

          }

}

可以注意到,在out方法的参数表当中,我们的参数声明是…args,这就是5.0引入的Varargs概念,即允许你一次传达多个参数,同样的效果如果需要在5.0之前实现的话,我们可能需要把方法的参数列表声明为一个数组,或集合,然后在调用该方法时,把参数封装到一个数组或者集合当中。即:

         public void out(String[] args){}

         out(new String[]{“a”,”b”,”c”});

 

8.   同步集合-Queue,BlockingQueue

     J2SE 5.0里面添加了新的用于提高同步性能的集合类--Queue。Queue是一个FIFO队列,她的作用主要是提高了并发访问性能,她与原来集合类当中的List的区别包括:

1.      她提供了一些新的方法,用于添加元素的offer(),用于删除元素的poll(),用于获取队首元素的peak()。这些操作与原来的add(),remove()的区别在于,原有的add(),remove()和element()当所需操作失败的时候会抛出异常,而新的offer()和poll()则不会,当队列不能容纳新元素时,offer()直接返回,当队列没有元素可取的时候,poll()操作,返回null。

     例子:

    

     public class Test{

         private ArrayBlockingQueue<Integer> list;

 

          public Test(int capacity){

               list = new ArrayBlockingQueue<Integer>(capacity);

          }

    

          public void add(int size){

              for(int i=0;i<size;i++){

                   list.add(i);

                   output();

               }

          }

    

          public void output(){

              for(int i:list){

                   System.out.print(i+"  ");

              }

          }

 

          public static void main(String[] args){       

              Test t = new Test(2);

              t.add(3);    

          }   

     }

 

     往一个容量为2的队列里面添加3个元素,他的输出为:

     =======    Start   ===============================================

     0

     =========================================    Stop    ==============

    

     =======    Start   ===============================================

     0  1

     =========================================    Stop    ==============

 

     Exception in thread "main" java.lang.IllegalStateException: Queue full

            at java.util.AbstractQueue.add(Unknown Source)

             at Test.add(Test.java:14)

            at Test.main(Test.java:32)

 

     把上述代码修改为:

          public void add(int size){

              for(int i=0;i<size;i++){

                   list.offer(i);

                   output();

               }

          }

     输出为:

     =======    Start   ===============================================

     0

     =========================================    Stop    ==============

    

     =======    Start   ===============================================

     0  1

     =========================================    Stop    ==============

    

     =======    Start   ===============================================

     0  1

     =========================================    Stop    ==============

    

2.      BlockingQueue是Queue的一个子接口,她提供了新的用于阻塞的操作,take()和put(),当队列没有空间,而线程欲通过put()往队列中添加元素时,线程会被阻塞。同理,当队列没有空间,而线程欲通过take()往队列中获取元素时,线程也会被阻塞。利用BlockingQueeu,我们可以很简单的实现生产者和消费者问题。

 

 

     例子:

     生产者:

public class Producer extends Thread{

   

    private BlockingQueue queue;

    private int count;

   

    public Producer(BlockingQueue queue){

         this.queue = queue;

         count = 0;

    }

 

    public void run(){

         while(true){

             try{

                  queue.put(produce());

             }catch(Exception e){

                  e.printStackTrace();

             }

         }

    }

   

    private Integer produce(){

         System.out.println("Produce: "+count);

         return new Integer(count++);

    }

}

 

消费者:

public class Consumer extends Thread{   

    private BlockingQueue queue;

    private int id;   

   

    public Consumer(BlockingQueue queue){

         this.queue = queue;

    }

 

    public void run(){

         while(true){

             try{

                  Thread.currentThread().sleep(step);

                  consume((Integer)queue.take());

             }catch(Exception e){

                  e.printStackTrace();

             }

         }

    }

   

    private void consume(Integer i){

         System.out.println("\t\t Consume: "+i);

    }

}

 

测试程序:

public class CPTest{

    public static void main(String[] args){

         ArrayBlockingQueue queue = new ArrayBlockingQueue(3);

         Consumer c1 = new Consumer(queue);

         Consumer c2 = new Consumer(queue);

         Producer p = new Producer(queue);

        

         c1.start();

         c2.start();

         p.start();        

    }

}

 

3.      PriorityQueue提供了基于优先级的排序。她会根据元素的自然序对所有加入的元素进行排序,另外,通过初始化时,提供定制的Comparator实现,可以改变他的顺序。注意:通过PriorityQueue返回的Iterator并不会保证按序返回队列中的值。

     例子:

     public class PQTest{

    private PriorityQueue<Integer> queue;

    public PQTest(int capacity,Comparator com){

         queue = new PriorityQueue<Integer>(capacity,com);

    }

   

    public void add(int size){      

         for(int i=0;i < size;i++){

             queue.offer(i);   

         }       

    }

   

    public void output(){      

         for(int i:queue){

             System.out.print(i+"  ");

         }

         System.out.println();

         for(int i = 0 ; i<5;i++)

             System.out.print(queue.poll()+"  ");

    }

 

    public static void main(String[] args){       

         PQTest t = new PQTest(6,new PQComparator());

         t.add(5);    

         t.output();

    }   

     }

    

     Comparator实现为:

     public class PQComparator implements Comparator<Integer>{

          public int compare(Integer i1,Integer i2){

              return -1 * (i1.intValue() - i2.intValue());

          }   

     }

 

     输出为:

     =======    Start   ===============================================

     4  3  1  0  2

     4  3  2  1  0

     =========================================    Stop    ==============

 

 

 

 

 

 

 

 

 

9.   同步(Concurrent)

    

1.      Executor接口

     Executor接口提供了一个类似于线程池的管理工具。用于只需要往Executor中提交Runnable对象,剩下的启动线程等工作,都会有对应的实现类来完成。ScheduledExecutorService比ExecutorService增加了,时间上的控制,即用户可以在提交的时候额外的定义该任务的启动时机,以及随后的执行间隔和延迟等。

     例子:

     任务:

     public class ETask implements Runnable{

          private int id = 0;

          public ETask(int id){

               this.id = id;

          }

          public void run(){

               try{

                   System.out.println(id+" Start");

                   Thread.sleep(1000);

                   System.out.println(id+" Do");

                   Thread.sleep(1000);

                   System.out.println(id+" Exit");

              }catch(Exception e){

                   e.printStackTrace();

              }

          }

     }

    

     测试类:

     public class ETest{

          public static void main(String[] args){       

              ExecutorService executor = Executors.newFixedThreadPool(2);

              for(int i=0;i<5;i++){

                   Runnable r = new ETask(i);

                   executor.execute(r);

              }

              executor.shutdown();

          }

     }

 

     输出:

     0 Start

     1 Start

     0 Do

     1 Do

     0 Exit

     2 Start

     1 Exit

     3 Start

     2 Do

     3 Do

     2 Exit

     3 Exit

     4 Start

     4 Do

     4 Exit

 

2.      Future和Callable

     Callable是一个类似于Runnable的接口,他与Runnable的区别是,她在执行完毕之后能够返回结果。Future用于获取线程的执行结果,或者取消已向Executor的任务。当我们通过Future提供的get()方法获取任务的执行结果时,如果任务没有完成,则调用get()方法的线程将会被阻塞,知道任务完成为止。一般我们都会使用Future的实现类FutureTask。

     例子:

     Callable对象:

     public class ETask implements Callable{

          private String id = null;

          public ETask(String id){

               this.id = id;

          }

    

          public String call(){

              try{

                   System.out.println(id+" Start");

                   Thread.sleep(1000);

                   System.out.println(id+" Do");

                   Thread.sleep(1000);

                   System.out.println(id+" Exit");          

              }catch(Exception e){

                   e.printStackTrace();

              }

              return id;

          }

     }

 

     测试类:

     public class ETest{

          public static void main(String[] args){       

              ExecutorService executor = Executors.newFixedThreadPool(2);

              for(int i=0;i<5;i++){           

                   try{

                       Callable c = new ETask(String.valueOf(i));

                        FutureTask ft = new FutureTask(c);

                        executor.execute(ft);

                        System.out.println("Finish:" + ft.get());         

                   }catch(Exception e){

                       e.printStackTrace();

                   }

              }

               executor.shutdown();

          }

     }

 

     输出:

     0 Start

     0 Do

     0 Exit

     Finish:0

     1 Start

     1 Do

     1 Exit

     Finish:1

     2 Start

     …

3.      CompletionService和ExecutorCompletionService

     CompletionService类似于一个Executor和Queue的混合。我们可以通过submit()向CompletionService提交任务,然后通过poll()来获取第一个完成的任务,也可以通过take()来阻塞等待下一个完成的任务。ExecutorCompletionService是CompletionService的实现类,他需要提供一个Executor作为构造函数的参数。

     例子:

     Executor executor = …;

     CompletionService cs = new ExecutorCompletionService(executor);

     Future fs = cs.submit(…);

     Future ft = cs.take();

 

4.      Semaphore

     信号量是用于同步和互斥的低级原语。信号量提供的acquire()和release()操作,与操作系统上的p,v操作同。

     例子:

     缓冲区:

     public class Buffer{

          private Semaphore s = null;

          private Semaphore p = null;

          Vector<Integer> v = new Vector<Integer>();

         

          public Buffer(int capacity){

               s = new Semaphore(capacity);

              p = new Semaphore(0);

          }

    

          public void put(int i){

              try{

                   s.acquire();

                   v.add(new Integer(i));

                   p.release();

               }catch(Exception e){

                   e.printStackTrace();

              }

          }

    

          public int get(){ 

               int i = 0;

              try{

                   p.acquire();

                   i = ((Integer)v.remove(0)).intValue();

                   s.release();

              }catch(Exception e){

                   e.printStackTrace();

              }

               return i;

          }   

     }

 

     生产者:

     public class Producer extends Thread{

          private Buffer b;

          private int count;

          private int step;

          private int id;

 

          public Producer(Buffer b,int step,int id){

               this.b =  b;

              this.step = step;

              this.id = id;

               count = 0;

          }

    

          public void run(){

              try{

                   while(true){

                       System.out.println("In put");

                        b.put(count);

                        System.out.println("Producer "+id+":"+count);

                        count++;

                       Thread.sleep(step);

                        System.out.println("Out put");

                   }

               }catch(Exception e){

                   e.printStackTrace();

              }

          }

     }

 

     消费者:

     public class Consumer extends Thread{

          private Buffer b;

          private int step;

          private int id;

    

          public Consumer(Buffer b,int step,int id){

              this.b = b;

               this.step = step;

              this.id = id;

          }

         

          public void run(){

              try{

                   while(true){

                        System.out.println("In get");

                       System.out.println("\t\tConsume "+id+":"+b.get());

                        System.out.println("Out get");

                        Thread.sleep(step);

                   }

               }catch(Exception e){

                   e.printStackTrace();

              }   

          }

     }

 

     测试程序:

     public class CPTest{

          public static void main(String[] args){

               Buffer b = new Buffer(3);

              Consumer c1 = new Consumer(b,1000,1);

              Consumer c2 = new Consumer(b,1000,2);

               Producer p1 = new Producer(b,100,1);

              Producer p2 = new Producer(b,100,2);

        

              c1.start();

               c2.start();

              p1.start();

              p2.start();

          }

     }

 

5.      CyclicBarrier

     CyclicBarrier可以让一组线程在某一个时间点上进行等待,当所有进程都到达该等待点后,再继续往下执行。CyclicBarrier使用完以后,通过调用reset()方法,可以重用该CyclicBarrier。线程通过调用await()来减少计数。

 

CyclicBarrier

 

 

 

 

 

 

     例子:

     任务:

     public class Task extends Thread{

          private String id;

          private CyclicBarrier c;

          private int time;

    

          public Task(CyclicBarrier c,String id,int time){

               this.c = c;

              this.id = id;

               this.time = time;

          }

    

          public void run(){

               try{

                   System.out.println(id+" Start");

                  Thread.sleep(time);

                   System.out.println(id+" Finish");

                   c.await();

                   System.out.println(id+" Exit");         

               }catch(Exception e){

                   e.printStackTrace();

              }

          }   

     }

 

     测试类:

     public class Test{

          public static void main(String[] args){

              CyclicBarrier c = new CyclicBarrier(3,new Runnable(){

                   public void run(){

                        System.out.println("All Work Done");

                   }

              });

               Task t1 = new Task(c,"1",1000);

              Task t2 = new Task(c,"2",3000);

              Task t3 = new Task(c,"3",5000);

               t1.start();

              t2.start();

              t3.start();       

          }

     }

 

     输出结果:

     1 Start

     2 Start

     3 Start

     1 Finish

     2 Finish

     3 Finish

     All Work Done

     3 Exit

     1 Exit

     2 Exit

 

6.      CountdownLatch

     CountdownLatch具有与CyclicBarrier相似的功能,也能让一组线程在某个点上进行同步。但是与CyclicBarrier不同的是:1.CountdownLatch不能重用,2.线程在CountdownLatch上调用await()操作一定会被阻塞,直到计数值为0时才会被唤醒,而且计数值只能通过conutDown()方法进行减少。

特别的,当CountdownLatch的值为1时,该Latch被称为“启动大门”,所有任务线程都在该Latch上await(),直到某个非任务线程调用countDown()触发,所有任务线程开始同时工作。

 

7.      Exchanger

     Exchanger是一个类似于计数值为2的CyclicBarrier。她允许两个线程在某个点上进行数据交换。

       例子:

     public class FillAndEmpty {

         Exchanger<DataBuffer> exchanger = new Exchanger();

         DataBuffer initialEmptyBuffer = ... a made-up type

         DataBuffer initialFullBuffer = ...

 

         public class FillingLoop implements Runnable {

              public void run() {

                   DataBuffer currentBuffer = initialEmptyBuffer;

                   try {

                       while (currentBuffer != null) {

                            addToBuffer(currentBuffer);

                            if (currentBuffer.full())

                                 currentBuffer = exchanger.exchange(currentBuffer);

                       }

                   }catch(InterruptedException ex) { ... handle ... }

              }

         }

 

         public class EmptyingLoop implements Runnable {

              public void run() {

                   DataBuffer currentBuffer = initialFullBuffer;

                   try {

                       while (currentBuffer != null) {

                            takeFromBuffer(currentBuffer);

                            if (currentBuffer.empty())

                                 currentBuffer = exchanger.exchange(currentBuffer);

                       }

                   } catch (InterruptedException ex) { ... handle ...}

              }

         }

 

         public void start() {

              new Thread(new FillingLoop()).start();

              new Thread(new EmptyingLoop()).start();

         }

     }

Exchange

 

    

 

 

 

 

 

 

 

 

8.      Lock,Condition

     锁是最基本的同步原语。通过在锁上面调用lock()和unlock()操作,可以达到与synchronized关键字相似的效果,但是有一点要注意的是,锁必须显式释放,如果由于抛出异常,而没有释放锁,将导致死锁出现。Condition提供的await(),signal(),signal()操作,与原来的wai(),notify(),notifyAll()操作具有相似的含义。Lock的两个主要子类是ReentrantLock和ReadWriteLock。其中ReadWriteLock的作用是允许多人读,而一人写。

     例子:

     使用Lock和Condition的生产者,消费者问题

     public class BoundedBuffer {

         final Lock lock = new ReentrantLock();

         final Condition notFull  = lock.newCondition();

         final Condition notEmpty = lock.newCondition();

         final Object[] items = new Object[100];

         int putptr, takeptr, count;

        

         public void put(Object x) throws InterruptedException {

              lock.lock();

              try {

                   while (count == items.length)

                       notFull.await();

                   items[putptr] = x;

                   if (++putptr == items.length)

                        putptr = 0;

                   ++count;

                   notEmpty.signal();

              } finally {

                   lock.unlock();

               }

          }

    

          public Object take() throws InterruptedException {

               lock.lock();

              try {

                   while (count == 0)

                       notEmpty.await();

                   Object x = items[takeptr];

                   if (++takeptr == items.length)

                        takeptr = 0;

                   --count;

                   notFull.signal();

                   return x;

               } finally {

                   lock.unlock();

              }

          }

     }   

 

9.      小结:新的concurrent包提供了一个从低到高的同步操作。

 

10.Annotation

Annotation是J2SE提供的一种新语法,根据规范的说明,他的作用简单来说就是简化代码的维护。例如,EJB需要7个文件,一个XML文件来表示,通过Annotation,我们可以只需要维护源代码,其他工作都可以通过自动生成达到。这个做法跟Lomboz的效果比较一致,不过Lomboz是通过XDoclet来实现,而现在只要使用Annotation就可以了,但是Annotation只是一个必要条件,如果真要达到自动生成其他文件的目的,除了Annotation之外,还需要其他类,或者工具的支持。

1.      预定义Annotation

Tiger为我们预定义了3个可以用的Annotation,分别是Override,Deprecated,SuppressWarnings。

                      i.              Override

1.        作用:

Override的作用就是,被生命为Override的方法,必须是对父类中方法的覆盖,如果父类中没有出现该方法,或者方法没有正确覆盖父类中的方法,则编译期就会出错。

 

 

2.        语法:

@Override public void methodA(){…}

 

3.        例子:

父类:

/*

 * Created on 2005-1-4

 *

 */

package test;

/**

 *

 * @author [email protected]

 */

public class Test {

    public Test() {

    }

    public void hello() {

        System.out.println("hello");

    }

    public void bye() {

        System.out.println("bye");

    }  

}

子类:

/*

 * Created on 2005-1-5

 *

 */

package test;

 

/**

 *  

 * @author [email protected]

 */

public class OverTest extends Test{

    @Override public void hello(){}

    @Override public void methodA(){}

}

错误信息:

The method methodA() of type OverTest must override a superclass method   

4.        评价:

通过Override,我们能够确保子类中的方法的确覆盖了父类中的方法。但是现在一般的IDE都可能提供了这种表示覆盖的提示,像我正在使用的Eclipse就有一个对应的符号,表示某个方法是否覆盖了父类中的方法,所以这个标记,或者只对那些还在使用Ultraedit的程序员有比较明显的作用。

 

                   ii.              Deprecated

1.        作用:

用于声明一个方法不建议再被使用。

 

2.        语法:

@Deprecated public void methodA(){…}

 

3.        例子:

声明类:

/*

 * Created on 2005-1-4

 *

 */

/**

 *

 * @author [email protected]

 */

public class Test {

    public Test() {

    }

    /**

     *

     * @deprecated

     * */

    public void hello() {

        System.out.println("hello");

    }

    @Deprecated public void bye() {

        System.out.println("bye");

    }

}

调用类:

/*

 * Created on 2005-1-5

 *

 */

/**

 * 

 * @author [email protected]

 */

public class CallTest {

    public CallTest(){

        Test t = new Test();

        t.hello();

        t.bye();

    }

}

编译信息:

CallTest.java:14: warning: [deprecation] hello() in Test has been deprecated

        t.hello();         ^

CallTest.java:15: warning: [deprecation] bye() in Test has been deprecated

        t.bye();         ^

2 warnings

 

4.        评价:

对于Deprecated这个标记,我认为,已经有一个deprecated在之前的JavaDoc标记中定义过了,为什么J2SE还要额外的增加这样的一个,完全搞不懂。

 

                iii.              SuppressWarnings

1.        作用:

这个标记的作用就是可以让编译器忽略掉一些编译期的错误,不报错。

 

2.        语法:

@SuppressWarnings("unchecked") public void void methodA(){…}

 

3.        例子:

原文件:

public void bye() {

ArrayList list = new ArrayList();

     list.add("Hello");

     System.out.println("bye");

}

错误信息:

warning: [unchecked] unchecked call to add(E) as a member of the raw type java.util.ArrayList

        list.add("Hello"); 

修改后的文件:

@SuppressWarnings( { "unchecked" }) public void bye() {

ArrayList list = new ArrayList();

     list.add("Hello");

     System.out.println("bye");

}

 

 

4.        评价:

SuppressWarnings的作用就是可以隐藏某些编译期的消息,他主要使用的地方或者就是在范型方面。但是,实际上这个标记在Tiger当中是没有实现的,所以上述修改后的代码,在他的输出结果当中,还是会输出同样的错误,呵呵。

 

2.      自定义Annotation

程序员可以根据自己的需求自定义一些特定的Annotation。但是,我认为有一点是很重要的,就是Annotation的存在不应该影响Java程序的语义,也就是说,使用Annotation前后,程序的含义,执行都不应该发生改变,即使一个程序员完全不了解Annotation的语法,他也应该能够毫无障碍的阅读Java源代码。

                      i.              语法:

Annotation一般有三种形式,就是不含有属性的,只有一个属性,和含有多个属性的。

1.        不含属性:

public @interface MyAnno{}

注:不含属性的Annotation的作用就跟不含方法的接口类似,只是作为标记的用途。

 

2.        一个属性:

public @interface MyAnno{

     String value();

}

注:当只含有一个属性时,属性的名称需要命名为value,这是Annotation里面的一个规定。

 

3.        多个属性:

public @interface MyAnno{

     String hello();

     int income() default 1;

}

注:当有多个属性时,属性名称可以任意。注意的是,属性的类型必须是基本类型,String,enum,Class,Annotations和这些类型的数组形式,而且属性可以通过default来声明默认值。

 

                   ii.              使用:

Annotation使用的时候,跟声明符(public,private等)类似,但一般他们都是放在第

一个,即public之前。

1.        不含属性:

@MyAnno public void methodA(){…}

 

2.        一个属性:

@MyAnno("hello") pubic void methodA(){…}或者

@MyAnno(value="hello") public void methodA(…)

 

3.        多个属性:

@MyAnno(hello="hello",income="1") public void methodA(){…}

                iii.              例子:

Annotation类:

/*

 * Created on 2005-1-4

 *

 */

package test;

 

import java.lang.annotation.*;

/**

 * 

 * @author [email protected]

 */

@Retention(RetentionPolicy.RUNTIME)

public @interface Remote {}

 

使用类:

/*

 * Created on 2005-1-4

 *

 */

package test;

import java.lang.reflect.*;

/**

 *

 * @author [email protected]

 */

public class Test {

    public Test() {}

    @Remote public void hello() {

        System.out.println("hello");

    }

    @Remote public void bye() {

        System.out.println("bye");

    }

    public static void main(String[] args) {

        try {

            Class c = Class.forName("test.Test");

            Method[] ms = c.getMethods();

            for (Method m : ms) {

                if (m.isAnnotationPresent(Remote.class)) {

                    System.out.println(m.getName());

                }

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

 

                   iv.              注意事项:

在声明一个新的Annotation时,一般需要带上@Retention标记,因为这个表明了Annotation的存活时间。@Retention的取值有3个,RetentionPolicy.SOURCE表示Annotation只在编译期有效,编译之后就会被编译器丢掉。RetentionPolicy.CLASS表示Annotaion将会保存到.class文件当中,但是并不会被VM提取。RetentionPolicy.RUNTIME表示Annotaion将会保存到.class文件当中,而且运行时,也会被VM提取,即通过reflect方法,能够获取到该标记。

 

3.      评价:

总的来说,Annotation的意义并不如之前提到的enhance for loop,generic types等新功能大,但这个只是相对来说,由于Annotation并不影响Java的语义,所以,对于一般Java程序员来说,完全可以忽略。而且,如果真的要利用Annotation,程序员还需要自己书写reflect方面的代码来提取这些Annotation来做其他额外的工作,这个一般来说,应该比较少出现。但是Annotation对于像插件开发商,其他程序员是的确有用的,像EJB开发的时候,我们可以不需要通过XDoclet的方式,也能达到所需的效果。

 

 

 

本文地址:http://com.8s8s.com/it/it12085.htm