This directory contains code that shows how the Java reflection API
can be used to obtain information about annotations at runtime. To
learn about annotations, please read the text provided below first.

The code is essentially derived from this source:
<http://www.javalobby.org/forums/thread.jspa?threadID=17324&tstart=0>

/js

* Java Annotations

  - Information for the compiler — Annotations can be used by the
    compiler to detect errors or suppress warnings.
  - Compile-time and deployment-time processing — Software tools can
    process annotation information to generate code, XML files, and so
    forth.
  - Runtime processing — Some annotations are available to be examined
    at runtime

** Standard Annotations

   Compile-time annotations:

   - @Override - declares that the method is an override
   - @Deprecated - indicates that a method is deprecated
   - @SuppressWarnings - suppress certain warnings
   - @FunctionalInterface - declare that the interface is functional

   Annotations about other annotations:

   - @Retention - specifies how the marked annotation is stored
   - @Documented - annotations should appear in documentation
   - @Target - restricts to what an annotation can be applied to
   - @Inherited - indicates that the annotation type can be inherited from the super class
   - @Repeatable - indicates that an annotation can be applied more than once

** Custom Annotations

   You can define annotations by defining interfaces that start with
   with an @ in the name.

   @interface Coder {
       String first();
       String last();
   }

   @Coder(first = "Joe", last = "Looser")
   public class foo
   {
	// ...
   }

   You can make the meta-information passed via this annotation appear
   in documentation by annotating the interface:

   import java.lang.annotation.Documented;

   @Documented
   @interface Coder {
       String first();
       String last();
   }

** Examples: Junit Annotations

   import org.junit.Test;

   public class FooTest
   {
	@Test
	public void fooIsGood()
	{
	}
   }

   - @Test - declare a public void method to be a test case

   - @Before - declares a public void method to run before a test case

   - @After - declares a public void method to be run after a test case

   - @Ignore - declares that a test case should be temporarily ignored

   - @BeforeClass - declares a public static void method to be run before all test cases of a class

   - @AfterClass - declares a public static void method to be run after all test cases of a class

   - @Category - allows to categorize tests in to fast and slow tests

   - @IncludeCategory - only run tests of a certain category

   - @ExcludeCategore - exclude tests of a certain category

   And many many more...