6.2. Wrapper Classes

In Java, every primitive data type has a corresponding wrapper class. A wrapper class allows primitive data to be treated as an object. These classes are part of the java.lang package and provide methods for converting between primitive values and objects.

Wrapper classes in Java allow you to use primitive data types like int and boolean as objects. This is important because Java collections (like ArrayLists) only work with objects, not primitives. The wrapper classes create a bridge, allowing this conversion, thereby giving you access to object methods to manipulate primitive values.

Think of a wrapper class like a gift box. The primitive data type is the gift, and the box allows you to keep it safe and gives you the ability to decorate or write on the outside of it. You can't directly write on the gift itself (the primitive), but the box (the wrapper class) allows you to personalize or treat it with special attention.

○ Byte for byte ○ Short for short ○ Integer for int ○ Long for long ○ Float for float ○ Double for double ○ Character for char ○ Boolean for boolean

Java has a specific wrapper class for each of its primitive data types. For example, 'int' has the wrapper class 'Integer', and 'boolean' has the wrapper class 'Boolean'. This one-to-one mapping allows programmers to easily use the primitive types as objects when necessary.

Imagine a school where each student has a unique ID. The ID is like the primitive data type (e.g., an int), while the student record containing their name, classes, and grades acts as the wrapper, holding additional information about the student. You can use just their ID for simple tasks but can refer to the full record for comprehensive details.

Wrapper classes are used when we need to store primitive types in collections (like ArrayList) since collections only work with objects. Wrapper classes also provide utility methods, such as:

• parseInt(), parseDouble(): Convert a String to a primitive type.
• toString(): Convert a primitive value to its String representation.
• valueOf(): Convert a primitive value to its wrapper class object.

You use wrapper classes when you want to put primitive values into collections such as ArrayLists, which cannot store primitives directly. In addition, wrapper classes come with useful methods that help convert between types, which simplifies working with different data types. For instance, if you have a string representing a number, you can easily convert it to an int using 'parseInt'.

Consider a toolbox where only specific tools (objects) can fit. Wrapping the tools (primitives) allows you to place them inside the toolbox. Utility methods are like instructions provided with your toolbox that help you convert between different tools or know how to use them properly, like turning a flathead screwdriver into a Phillips one.

public class WrapperExample {
    public static void main(String[] args) {
        // Using the Integer wrapper class
        int num = 5;
        Integer numWrapper = Integer.valueOf(num); // Convert int to Integer object
        System.out.println("Integer value: " + numWrapper); // Output: Integer value: 5

        // Converting String to primitive int
        String str = "123";
        int parsedInt = Integer.parseInt(str);
        System.out.println("Parsed integer: " + parsedInt); // Output: Parsed integer: 123
    }
}

In this example, we see how to use the Integer wrapper class. First, we convert a primitive int (5) into an Integer object using 'Integer.valueOf()'. This allows us to treat the number as an object. Next, we demonstrate converting a String ('123') back into a primitive int using 'Integer.parseInt()'. This showcases how wrapper classes facilitate working with primitive and non-primitive data types together.

Imagine a vending machine where you put coins (primitive ints) but get drinks (objects) in return. The coins are like the primitive data types, while the drinks represent the wrapper objects. You can also return an empty bottle (String) to get back the exact amount of coins you originally spent, similar to converting between types using methods like parseInt.

--