The values() and valueOf() Methods:  
All enumerations automatically contain two predefined methods: values() and valuesOf().
Their general forms are show here:
public static enum-type[]values()<br /> public static enum-type valueOf(String str)
The values() method returns an array that contains a list of the enumeration constants. The valueOf() method returns the enumeration constant whose value corresponds to the string passed in str. In both cases, enum-type is the type of the enumeration.
The following program demonstrates the values() and valuesOf() methods: enum City{Bhopal,Delhi, Nodia, Kanpur, Agra} class TestCtiy{ public static void main(String []arg){ City ct; System.out.println("Show all data: City Contantes"); /*use Values Method*/ City allCity[]=City.values(); for(City c:allCity){ System.out.println(c+" "); } /*Use valueOf Method*/ System.out.println("Show the ValueOf method data: City Contantes"); ct=City.valueOf("Nodia"); System.out.println(" "+ct); } }
Type of Wrappers: The type wrappers are Double, Float, Long, Integer, Short, Byte, Character and Boolean. These classes offer a wide array of methods that allow you to fully integrate the primitive types into java's object hierarchy.
The Numeric Type Wrappers:These are Byte, Short, Integer, Long, Float and Double. All of the numeric type Wrappers inherit the abstract class Number. Number declares methods that return the value of an object in each of the different number formats.These Methods are shown here.
byte byteValue() double doubleValue() float floatValue() int intValue() long longValue() short shortValue()
Example:class wrapper{ public static void main(String []arg){ Integer iob=new Integer(100); int i=iob.intValue(); System.out.println(i+" ,"+iob);// Output is 100, 100 }}
Autoboxing/Unboxing Autoboxing and unboxing take place whenever a conversion into an bject or from an object is required. This applies to expressions. within an expression, a numeric object is automatically unboxed. The outcome of the expression is reboxed, if necessary.
Example:class AutoBox{ public static void main(String []arg){ Integer iob=100, iob2; int i; System.out.println("Original value of iob:" +iob); //The following automatically unboxes iob. //perfoems the increment, and then reboxes. //the result back into iob. ++iob; System.out.println("After ++iob:" +iob); //Here, iob is unboxed, the expression is //evaluated. and the result is reboxed and //assigned to iob2. iob2=iob+(iob/3); System.out.println("iob after expression:" +iob2); // the same expression is evaluated, but the //result is not reboxed. i=iob+(iob/3); System.out.println("i after expression:" +i); } }
Output is :

Annotations(Metadata) : An annotation is created through a mechanism based on the interface. Let's begin with an example: Here is the declaration for an annotation called MyAnnotation
//A simple annotation type @interface MyAnnotation{ String str(); int val(); }