To implement Java Program to demonstrate Generics

Explanation

This Java program demonstrates the fundamental concept of Generics. Generics allow you to write classes, interfaces, and methods that can operate on different types of data without needing to rewrite the code for each specific type. This promotes code reusability and enhances type safety.

Let's break down the code step by step:

1. class Box<T>:

   • This declares a class named Box. The <T> after the class name signifies that Box is a generic class. T is a type parameter—a placeholder that will be replaced by an actual data type (like Integer, String, Double, etc.) when an object of Box is created.
   • Inside the Box class, T value; declares an instance variable named value whose type is T. This means value can hold any type of object that T represents at runtime.

2. void setValue(T value):

   • This is a method within the Box class. It takes one argument, value, which is also of type T.
   • this.value = value; assigns the passed argument to the value instance variable of the Box object. This method allows us to store a value of the specified type into our Box.

3. void display():

   • This method simply prints the content of the value instance variable to the console, prefixed with "Value: ".

4. public class GenericClass:

   • This is the main class that contains the main method, which is the entry point for program execution.

5. public static void main(String[] args):

   • This is the standard main method.

6. Box <Integer> intBox = new Box<>();:

   • Here, we create an instance of the Box class. Crucially, we specify <Integer> in angle brackets. This tells the compiler that for this particular intBox object, the type parameter T will be replaced by Integer.
   • So, intBox is a "box" specifically designed to hold Integer objects.

7. intBox.setValue(100);:

   • We call the setValue method on intBox, passing the integer 100. Since intBox is an Integer box, this is a valid operation.

8. intBox.display();:

   • We call the display method on intBox, which prints "Value: 100".

9. Box <String> strBox = new Box<>();:

   • Next, we create another instance of the same Box class, but this time we specify <String>. This means strBox is a "box" specifically designed to hold String objects.

10. strBox.setValue("Generic Programming");:

    • We call setValue on strBox, passing the string "Generic Programming". This is valid because strBox is a String box.

11. strBox.display();:

    • We call display on strBox, which prints "Value: Generic Programming".

In essence, the Box class is written once, but it can be used with different data types (Integer, String, etc.) without any modification to its internal code. This is the power of Generics: it provides type safety (the compiler ensures you don't put a String into an Integer box) and eliminates the need for explicit type casting, making the code cleaner and less prone to runtime errors.

Algorithm

The program follows a straightforward algorithm to demonstrate Java Generics:

1. Define a Generic Class:

   • Create a class named Box that accepts a type parameter T.
   • Declare an instance variable value of type T within the Box class.
   • Implement a method setValue(T value) to assign a value of type T to the value instance variable.
   • Implement a method display() to print the stored value.

2. Demonstrate with Integer Type:

   • In the main method, create an object of the Box class, explicitly specifying Integer as its type parameter (e.g., Box<Integer> intBox).
   • Use the setValue() method of intBox to store an Integer value (e.g., 100).
   • Call the display() method of intBox to print the stored Integer value.

3. Demonstrate with String Type:

   • Create another object of the same Box class, but this time explicitly specifying String as its type parameter (e.g., Box<String> strBox).
   • Use the setValue() method of strBox to store a String value (e.g., "Generic Programming").
   • Call the display() method of strBox to print the stored String value.