Question

Write short note on Wrapper class with example.

Short answer

Wrapper classes convert primitives to objects, allowing use in collections and providing utility operations such as autoboxing and unboxing.

Step-by-step solution

Introduction to Wrapper Classes

Wrapper classes in Java are used to convert primitive data types into objects. Java provides a corresponding wrapper class for each of the eight primitive types (int, char, boolean, etc.). These wrapper classes fall under the `java.lang` package.

Why Use Wrapper Classes

Primitive types in Java are not objects, so wrapper classes are useful when working with frameworks that need objects. Wrapper classes provide a way to use primitive data types as objects, offer utility functions for conversions, and handle default values with nulls in collections.

Example of a Wrapper Class

Consider the Integer wrapper class for the int primitive type. You can create an Integer object: ```java int num = 5; Integer intObj = Integer.valueOf(num); ``` This allows `intObj` to be used like an object, with methods such as `intObj.toString()`. It also allows null assignments like `Integer anotherInt = null;`, which is not possible with primitive data types.

Autoboxing and Unboxing

Java automatically converts between primitive types and their corresponding wrapper class objects. This feature is known as autoboxing and unboxing. For example: ```java Integer intObj = 10; // Autoboxing int num = intObj; // Unboxing ``` Autoboxing converts the primitive to an object, while unboxing does the reverse, providing a seamless operation.

Key concepts

Primitive Data Types

In Java, primitive data types are the most basic kinds of data available to a programmer. These data types are not objects, but rather they are the building blocks for data manipulation in Java. The primitive data types include:

• int for integers
• char for characters
• boolean for true and false values
• byte, short, long, float, double for other numerical values

Primitive data types have no additional methods; they're simple and efficient. They directly hold their values in memory, which makes operations faster. However, because they are not objects, you can't call methods on them, and they can't be null. This is where Java's Wrapper Classes come in handy, converting these primitives into objects when necessary. This transformation allows for enhanced functionality which is crucial when working with Java collections and other frameworks.

Autoboxing

Autoboxing in Java refers to the automatic conversion that the Java compiler makes between primitive data types and their corresponding object wrapper classes. This feature simplifies coding by reducing the tasks of manually converting data types when dealing with collections or other scenarios where objects are required. Here’s how it works:

• When a primitive value needs to be assigned to a variable of a corresponding wrapper class, Java automatically "boxes" the primitive into an object of the respective wrapper class.
• An example would be:

  Integer intObj = 10;

  The integer 10 here is automatically converted into an Integer object.

Autoboxing saves developers from writing additional boilerplate code to manually convert primitives to objects, making the code cleaner and simpler. This functionality enhances usability in Java collections that operate on objects, such as lists and maps.

Unboxing

Unboxing is essentially the reverse of autoboxing. It is the automatic conversion that the Java compiler makes from an object of a wrapper class back to a primitive data type. This happens seamlessly in Java, making it easier for developers to work with both objects and primitives interchangeably in their code.

• When a wrapper class object needs to be assigned to a variable of a primitive type, Java automatically "unboxes" the object to its corresponding primitive value.
• An example would be:

  int num = intObj;

  Here, the Integer object intObj is automatically converted to an int.

Unboxing helps in maintaining the balance between object-oriented and procedural programming paradigms within Java, providing flexibility in data handling.

Java Objects

In Java, everything that isn’t a primitive data type can be considered an object. Java Objects are instances of classes, created using constructors, which are blueprints for creating objects. Java being a strongly object-oriented programming language, emphasizes on the use of objects to store data and methods to work with that data.

• Java objects allow you to store methods along with your data, which can manipulate or report on the data within your object.
• Objects make code cleaner and more structured, allowing for reusable and modular code.

Wrapper classes in Java facilitate the conversion process between primitive types and objects, allowing these primitive values to be stored as Java Objects. This has important implications for Java’s Collection Framework, where objects can be added, removed, and modified more easily. With Wrapper classes, primitives can now participate in this object-centric approach, thereby enriching the capabilities of the Java language.