public class Animal {
 
    public void speak() {
    }
 
    public String getType() {
       return "Generic animal";
    }
}
 
public class Cat extends Animal {
 
    @Override
    public void speak() { // This is a good override.
       System.out.println("Meow.");
    }
 
    @Override
    public String gettype() { // throws compile warning due to mistyped name.
       return "Cat";
    }
}

  // @Twizzle is an annotation to method toggle().
  @Twizzle
  public void toggle() {
  }
 
  // Declares the annotation Twizzle.
  public @interface Twizzle {
  }

  // Same as: @Edible(value = true)
  @Edible(true)
  Item item = new Carrot();
 
  public @interface Edible {
    boolean value() default false;
  }
 
  @Author(first = "Oompah", last = "Loompah")
  Book book = new Book();
 
  public @interface Author {
    String first();
    String last();
  }

  @Retention(RetentionPolicy.RUNTIME) // Make this annotation accessible at runtime via reflection.
  @Target({ElementType.METHOD})       // This annotation can only be applied to class methods.
  public @interface Tweezable {
  }

  @Entity                                           // Declares this an entity bean
  @Table(name = "people")                           // Maps the bean to SQL table "people"
  class Person implements Serializable {
    @Id                                             // Map this to the primary key column.
    @GeneratedValue(strategy = GenerationType.AUTO) // Database will generate new primary keys, not us.
    private Integer id;
 
    @Column(length = 32)                            // Truncate column values to 32 characters.
    private String name;
 
    public Integer getId() {
      return id;
    }
 
    public void setId(Integer id) {
      this.id = id;
    }
 
    public String getName() {
      return name;
    }
 
    public void setName(String name) {
      this.name = name;
    }
  }

package com.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD,
 ElementType.CONSTRUCTOR,ElementType.ANNOTATION_TYPE,
 ElementType.PACKAGE,ElementType.FIELD,ElementType.LOCAL_VARIABLE})
@Inherited
 
public @interface Unfinished {
        public enum Priority { LOW, MEDIUM, HIGH }
        String value();
        String[] changedBy() default "";
        String[] lastChangedBy() default "";
        Priority priority() default Priority.MEDIUM;
        String createdBy() default "James Gosling";
        String lastChanged() default "08/07/2011";
}

package com.annotation;
 
public @interface UnderConstruction {
        String owner() default "Patrick Naughton";
        String value() default "Object is Under Construction.";
        String createdBy() default "Mike Sheridan";
        String lastChanged() default "08/07/2011";
}

package com.validators;
 
import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.Validator;
import javax.faces.validator.ValidatorException;
 
import com.annotation.UnderConstruction;
import com.annotation.Unfinished;
import com.annotation.Unfinished.Priority;
import com.util.Util;
 
@UnderConstruction(owner="Navin Gujarish")
public class DateValidator implements Validator{
 
        public void validate(FacesContext context, UIComponent component, Object value)
                        throws ValidatorException
        {
                String date = (String) value;
                String errorLabel = "Please enter a valid date.";
                if(!component.getAttributes().isEmpty())
                {
                        errorLabel = (String) component.getAttributes().get("errordisplayval");
                }
 
                if(!Util.validateAGivenDate(date))
                {
                        @Unfinished(changedBy = "Steve"
                                ,value="whether to add message to context or not, confirm"
                                ,priority=Priority.HIGH
                        )
                        FacesMessage message = new FacesMessage();
                        message.setSeverity(FacesMessage.SEVERITY_ERROR);
                        message.setSummary(errorLabel);
                        message.setDetail(errorLabel);
                        throw new ValidatorException(message);
                }
        }
}

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
 
// this is the annotation to be processed
// default for Target is all Java Elements
// change retention policy to RUNTIME (default is CLASS)
@Retention(RetentionPolicy.RUNTIME)
public @interface TypeHeader {
        // default value specified for developer attribute
        String developer() default "Unknown";
        String lastModified();
        String [] teamMembers();
        int meaningOfLife();
}
 
// this is the annotation being applied to a class
@TypeHeader(developer = "Bob Bee",
            lastModified = "2013-02-12",
            teamMembers = { "Ann", "Dan", "Fran" },
            meaningOfLife = 42)
 
public class SetCustomAnnotation {
        // class contents go here
}
 
// this is the example code that processes the annotation
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
 
public class UseCustomAnnotation {
   public static void main(String [] args) {
      Class<SetCustomAnnotation> classObject = SetCustomAnnotation.class;
      readAnnotation(classObject);
   }
 
   static void readAnnotation(AnnotatedElement element) {
      try {
         System.out.println("Annotation element values: \n");
         if(element.isAnnotationPresent(TypeHeader.class)) {
            // getAnnotation returns Annotation type
            Annotation singleAnnotation = 
                       element.getAnnotation(TypeHeader.class);
            TypeHeader header = (TypeHeader) singleAnnotation;
 
            System.out.println("Developer: " + header.developer());
            System.out.println("Last Modified: " + header.lastModified());
 
            // teamMembers returned as String []
            System.out.print("Team members: ");
            for(String member : header.teamMembers()) 
               System.out.print(member + ", "); 
            System.out.print("\n");
 
            System.out.println("Meaning of Life: "+ header.meaningOfLife());
         }
      } catch (Exception exception) {
            exception.printStackTrace();
      }
   }
}