The
compiler generates a warning when we use deprecated elements.
Example on @Deprecated
1.
public class DeprecatedDemo{
2.
/**
3.
* @deprecated this method got deprecated
it better
4.
* to
use {@link BetterSum#sum(int, int)}
5.
*/
6.
@Deprecated
7.
public void sum ( int a, int b) {
8.
System.out.println(a+b);
9.
}
10.
11.
public static void main(String[] args)
12.
{
13.
DeprecatedDemo demo= new
DeprecatedDemo();
14.
demo.sum();
15.
}
16.
}
NOTE: when we call sum()
method, it will show warning, so that the method got deprecated
Source code of @Deprecated
1.
@Documented
2.
@RetentionPolicy.RUNTIME)
3.
public
@interface Deprecated{
4.
5.
}
@SuppressWarnings
ð SuppressWarnings
annotation indicates to the compiler to suppress all the compiler warnings in
the annotated code element including its sub elements or block.
ð We should use
@SuppressWarnings when we know that we are using on API which results warnings,
have taken possible precautions and therefore we don’t want the compiler to
warn about the same.
Example on
@SuppressWarnings
1.
package com.nit.annotation;
2.
import java.util.ArrayList;
3.
import java.util.List;
4.
//@SuppressWarnings("deprecation ")
5.
public class SuppressWarningDemo {
6.
@SuppressWarnings("all")
7.
public
static void main(String[] args) {
8.
List list=new ArrayList();
9.
list.add("hi");
10.
list.add("hello");
11.
System.out.println(list);
12.
}
13.
public void test(){
14.
Int a;
15.
}
16.
17.
}
Source code of
@SuppressWarnings
1.
@Target({TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
2.
@Retention(RetentionPolicy.SOURCE)
3.
public @interface SuppressWarnings{
4.
String[] value();
5.
}
The following are
different values for SuppressWarning annotation
all, boxing, cast, dep-ann, deprecation, fallthrough,
finally, hiding, incomplete-switch, nls, null, rawtypes, restriction, serial,
static-access, synthetic-access, unchecked, unqualified-fieldaccess
|
Annotation type
|
TYPE
|
FIELD
|
METHOD
|
PARAMETER
|
CONSTRUCTOR
|
LOCAL-VARIABLE
|
PACKAGES
|
ANNOTATION-TYPE
|
|
@SuppressWarnings
|
 Applicable |
Applicable
|
Applicable
|
Applicable
|
Applicable
|
Applicable
|
Notapplicable
|
Notapplicable
|
|
@Override
|
Notapplicable
|
Notapplicable
|
applicable
|
Notapplicable
|
Notapplicable
|
Notapplicable
|
Notapplicable
|
Notapplicable
|
|
@Deprecated
|
Applicable
|
Applicable
|
Applicable
|
Applicable
|
Applicable
|
Applicable
|
Applicable
|
applicable
|
Enum types
ð
An enum type is a type whose fields consist of a fixed set of
constants.
ð
Common examples include
compass directions (values of NORTH, SOUTH, EAST, and WEST), days of the week, planet names…etc.
Simple
enum. The ; after the last element is optional, when this is
the end of enum definition.
public enum Color {
WHITE, BLACK, RED, YELLOW, BLUE; //; is optional
}
public enum Color {
WHITE, BLACK, RED, YELLOW, BLUE; //; is optional
}
Enum
embedded inside a class. Outside the enclosing class, elements are
referenced as
Outter.Color.RED,
Outter.Color.BLUE, etc.public class Outter {
public enum Color {
WHITE, BLACK, RED, YELLOW, BLUE
}
}
Enum
that overrides toString method. A semicolon after the last element is
required to be able to compile it. More details on overriding enum toString
method can be found here.
public enum Color {
WHITE, BLACK, RED, YELLOW, BLUE; //; is required here.
@Override public String toString() {
//only capitalize the first letter
String s = super.toString();
return s.substring(0, 1) + s.substring(1).toLowerCase();
}
}
Enum
with additional fields and custom constructor. Enum
constructors must be either private or package default, and protected or public
access modifier is not allowed. When custom constructor is declared, all
elements declaration must match that constructor.
public enum Color {
WHITE(21), BLACK(22), RED(23), YELLOW(24), BLUE(25);
private int code;
private Color(int c) {
code = c;
}
public int getCode() {
return code;
}
Enum
that implements interfaces. Enum can implement any interfaces. All enum
types implicitly implements
java.io.Serializable, andjava.lang.Comparable.public enum Color implements Runnable {
WHITE, BLACK, RED, YELLOW, BLUE;
public void run() {
System.out.println("name()=" + name() +
", toString()=" + toString());
}
}
A sample test program to invoke this run() method:
for(Color c : Color.values()) {
c.run();
}
Or,
for(Runnable r : Color.values()) {
r.run();
}
r.run();
}
Example
on Enum Types
Direction.java
1.
package com.neo.enums;
2.
3.
public enum Direction {
4.
NORTH(1),
EAST(2), SOUTH(3), WEST(4);
5.
6.
private
int code;
7.
8.
private
Direction(int code) {
9.
this.code
= code;
10.
}
11.
12.
public
int getCode(){
13.
return
code;
14.
}
15.
16.
}
EnumDemo.java
1.
package com.neo.enums;
2.
3.
public class EnumDemo {
4.
public
static void main(String[] args) {
5.
sop("Accessing
perticular instance...");
6.
Direction direction =
Direction.SOUTH;
7.
System.out.println(direction);
8.
sop("...all
instances of Direction are...");
9.
for
(Direction direction2 : Direction.values()) {
10.
sop(direction2
+ "==>" + direction2.getCode());
11.
}
12.
13.
}
14.
15.
public
static void sop(Object object) {
16.
System.out.println(object);
17.
}
18.
}
Types of
Annotations
There are
4 types of annotations
1. marker annotation
2. single member
annotation
3. multimember
(or)full annotation
4. complex (or) nested
annotation
Marker
Annotation
ð This annotation is
just like marker interface. So marker annotations can be used as an alternative
to marker interfaces.
ð Marker Annotation
is a special kind of annotation that contains no members. Its main purpose is
to mark java elements. The presence of marker annotation carries a special
meaning to a java element.
Ex : Override,
Deprecated, Documented, Inherited
Creation of marker
annotation
Immutable.java
19.
@Target(ElementType.TYPE)
20.
public @interface Immutable{
21.
22.
}
Usage of marker annotation
Account.java
1.
@Immutable
2.
public class Account{
3.
4.
}
Single
member annotation
ð A single member
annotation contains only one member
ð It works like a
normal annotation except that it allows a short hand form of specifying the
value of the member. when only one member is present (with name “value”) you
can simply specify the value for that member when the annotation is applied. We
don’t need to specify the name of the member.
ð However in order to
use this short hand the name of the member must be value.
Ex:
SupressWarnings, Retention, Target …etc.
|
Example
|
Usage
|
|
Public @interface Author{
String value();
}
|
@Author(“sekhar”)
public class
Demo{
}
|
|
@Author(value=“sekhar”)
public class Demo{
}
|
|
Example
|
Usage
|
|
Public @interface Author{
String name();
}
|
@Author(name=“sekhar”)
public class Demo{
}
|
ð Annotations can
have array members also.
ð Array members can
be primitive type, String, enum type or other annotation type or class only.
|
Example
|
Usage
|
|
Public @interface Author{
String[] value();
}
|
@Author({“kesav”,”sekhar”,”somu”})
public class
Demo{
}
|
|
@Author(value={“kesav”,”sekhar”,”somu”})
public class Demo{
}
|
ð When the annotation
has a member while using this annotation we should specify the member value
otherwise compilation error will be generated.
ð Annotation members
can have default values. Those default values will be used if we don’t specify
the value for a member when the annotation is applied. Default value is
specified by adding default clause
to a member’s declaration.
|
Example
|
Usage
|
|
Public @interface Author{
String value() default “sekhar”;
}
|
@Author(”somu”) // overridden the default
public class
Demo{
}
|
|
@Author // default value will be taken
public class Demo{
}
|
Multimember
Annotation
ð An annotation which
will contain more than one member is called multimember annotation or full
annotation. While applying multimember annotation shorthand form is not
allowed.
ð While applying the
multi member annotation, members should be specified as key-value pairs
separated by ‘,’(comma).
|
Example
|
Usage
|
|
public @interface Author{
String name();
String version() default “1.6”;
}
|
@Author(name=”sekhar”,
version=”1.8”)
public class
Demo{
}
|
|
Subject.java
public enum Subject {
STRUTS,
SPRING, HIBERNATE;
}
Author.java
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
public @interface Author {
String[]
name() default "sekhar";
double
version() default 1.0;
boolean
maritalStatus() ;
Subject
subName();
}
|
Demo.java
@Author(subName=Subject.SPRING,maritalStatus=false,
version=1.0)
public class Demo {
}
|
Complex (or)
Nested Annotation
ð Defining an
annotation inside another annotation is called nested annotation.
Licence.java
1.
public @interface Licence{
2.
String place() default “Tenali”;
3.
}
TrafficOfficer.java
1.
public @interface TrafficOfficer {
2.
Licence
licence();
3.
String
showMeLicence();
4.
}
Demo.java
1.
@TrafficOfficer(licence=@Licence(place="Hyd"),showMeLicence="sorry
sir take 200Rs")
2.
public class Demo {
3.
}
APT(Annotation
Processor Tool)
