Enumerations, Autoboxing and Annotations (Metadata)

Over the years, the Java programming language has evolved to be more efficient and easier to use for developers. Sun Microsystems makes most of Java features free of charge, and lately, a range of concepts has been embedded in the JDK to make it simpler, improve uniformity and security. In accordance with Sun’s philosophy of ensuring simplicity and clean coding in Java, the concepts of enumerations, autoboxing, and annotations were added to the JDK to ensure more efficiency and ease of compilation. These features are important because they play a major role in handling the issues of primitive data types, and they simplify program development. The advantages of these concepts include fewer codes, neater codes, readable codes, elimination of typecasting, prevents errors, and a decrease of technical debt.

Enumerations

Enumerations in Java are a class created specifically to represent a group of constants. Constants are variables that do not change, and they are known as Final variables in Java. Enumerations in Java are abbreviated as enum, and they differ from a Class. Just like a class, enum also has methods and attributes, but the primary difference between an enum and a class is that constants in an enum are public, static, and final, which implies that they cannot be changed or overridden. An enum cannot be used to extend a class, and it cannot be used to create objects; rather, it is used to implement interfaces. Hence enums are used to represent constants and should be used only when there are values that you know are not going to examples of values that do not change are days, months, years, color, and so much more.

Defining and Using Enumeration in Java

Enumeration was added in the Java Development Kit 5 (JDK5), and it can be created using the enum keyword. Before you create an enum, the constants must be known, and enums cannot be instantiated using New. To use the enum, you have to create a list of constant variables, and in this example, we would create a list of color using the enum keyword.

//Enumeration definition – This is the comment section of your program code that enables 
you to make reference

enum Year
{
	January, February, March, April, May, June
}

In this code example, January, February, March, April, May, June are the constants, and they cannot be changed. They are static, public constants, and they are final.

Example of Enumeration

This example would use the enum reference variable to define an enumeration and access its constants

Enum YearMonths //This is a pascal casing style
{ 
January, February, March, April, May, June July, August
}
Class Example
{
Public static void main (Strings args[])
{
YearMonths ym;
Ym = YearMonths.January;
System.out.printLn (“The Month is “+ym);
}
}

Points to note in Enumerations

  • Enumerations cannot be initiated using the new keyword in Java
  • By default, enumerations in java inherit a class called the java.lang.Enum
  • Enums are a type of constant class with variables that cannot be changed or overridden
  • Enumerations can be used in the switch statement and if-else constructs

Autoboxing

Autoboxing was introduced in Java 1.5. It’s a special feature in the programming language that automatically converts primitive types to the corresponding wrapper class and from a corresponding wrapper class to primitive types known as unboxing. Some examples are the conversion of data types from long to Long, int to Integer short to Short, double to Double, etc. Java programming language also comes with Unboxing features, which is the reverse of Autoboxing. Its function is in the conversion of an object wrapper class to its corresponding primitive types. Unboxing would automatically convert Integer to int, Double to double, Long to long, Short to short, etc

With autoboxing, Java programmers would be able to make cleaner and faster codes that are easier to read and understand. Java compilers simplify programming and automatically convert Wrapper classes to primitive types and vice versa. Here is an example of the Wrapper class and primitive types.

Wrapper classPrimitive Data types
Floatfloat
Integerint
Shortshort
Doubledouble
Bytebyte
Characterchar
Longlong
Booleanboolean

Autoboxing Example

List <Integer> BA = new ArrayList<>();
For (int i =1; i <10; i +=4)
BA.add(i);

In this example the code would still compile even though the int values were added as primitive data types rather than INTEGER objects.  The Java compiler would not issue a compile error because of autoboxing. Java compiler would compile the previous code into a new one below

List <Integer> BA = new ArrayList<>();
For (int i =1; i <10; i +=4)
BA.add(Integer.ValueOf(i));

So essentially, converting a primitive value into the corresponding wrapper class is known as autoboxing, while the reverse is known as unboxing.

Annotations

Annotations allow developers to add metadata information to source codes. Metadata is a set of data that describes other data in the program. Annotations and metadata are not part of the source code and would not be compiled. The use of annotations was first added in JDK 5 (Java Development Kit). Annotations do not have a direct effect on the operation of the program.

Uses of Annotations in Java

Annotations are used to give instructions to the java compiler, and their three primary inbuilt annotation types in java. They are @Deprecated @Override and @SurpressWarning. Annotations in Java must start with the @symbol before the name of the annotation. The @symbols tells the compiler that it is an annotation.

The Override Annotation

The @override annotation is used to give the compiler an override instruction, for example, when a method is overriding another method. Annotations can be used in class, method, or functions. Here is an example of @override annotation.

Public class YourLesson {
	Public void TestMethod() {
		System.out.println (“This is your lesson time”);
	}
}
Public class AnotherLesson  extends YourLesson  {
@Override TestMethod() {
		System.out.println (“ this is another lesson”);
	}
}

Deprecated Annotation

The @Deprecated annotation is used to inform the compiler when a class, method, or field is deprecated, and the compiler would display a warning sign when someone attempts to use any of them. A deprecated method or class means it is no more in use and not important, so the compiler would give a warning signal to inform you that the method or class is no more in use.

/**
*@deprecated
* This method is deprecated because it is no longer needed, this is a comment section
@Deprecated
Public void lessonMethod(){
}

The SupressWarning Annotation

The @SupressWarning annotation was introduced in JDK 1.5. It instructs the java compiler to suppress or ignore a specific compiler warning in annotated elements. It is meant to suppress a warning inside a class by the compiler, which is usually helpful. Annotations give two types of instructions, which are the compile-time instructions and the run-time instructions. The Runtime instructions are available only at runtime and are accessed using a tool called java reflection. Compile-time instructions can be defined at the compile time, and they can be used by software build tools to generate XML files.

@SuppressWarning (“deprecation”)
	Void YourMethod(){
	ThisObject.deprecatedMethord();
}

Final Notes

The JDK incorporated new features, which are annotations, autoboxing, and enumerations, which ensures that programs are developed more rapidly, faster executed, and with cleaner codes. Annotations enable developers to embed additional information into the source code of a program without affecting the outcome or compilation of the program. This additional information is in the form of metadata, which is intended to describe functions and classes in source code. Autoboxing in Java automatically converts primitive data types into its equivalent wrapper class to ensure that programs are developed more rapidly. While enumerations are intended to define constants in a class, and it is created using the enum keyword.

Comments are closed.