Java Programming Type Casting And Wrapper Classes Complete Guide

Java Programming: Type Casting and Wrapper Classes

Introduction

In Java, type casting is the process of converting a variable of one data type to another. This is necessary when you want to perform operations between variables of different data types or when you need to store one type of data into another. Java supports two types of casting:

1. Implicit Casting (Widening): Java automatically performs this conversion when the target type can hold the value of the source type without losing any information.
2. Explicit Casting (Narrowing): You must explicitly convert the data type to avoid data loss or truncation.

Wrapper Classes are classes that provide a way to use primitive data types (int, double, char, etc.) as objects. Each primitive type has a corresponding wrapper class in Java:

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

Wrapper classes provide several useful methods and allow you to use primitive types in collections, which require objects.

Type Casting in Java

Implicit Casting (Widening)

Implicit casting happens automatically when you assign a smaller data type to a larger data type.

Example:

public class ImplicitCastingExample {
    public static void main(String[] args) {
        // Declare variables
        int intValue = 100;
        long longValue;
        float floatValue;
        
        // Implicit casting
        longValue = intValue; // int to long
        floatValue = intValue; // int to float
        
        // Print results
        System.out.println("int value: " + intValue);
        System.out.println("long value: " + longValue);
        System.out.println("float value: " + floatValue);
    }
}

Output:

int value: 100
long value: 100
float value: 100.0

Explicit Casting (Narrowing)

Explicit casting must be done manually when you assign a larger data type to a smaller data type. This can result in data loss or truncation.

Example:

public class ExplicitCastingExample {
    public static void main(String[] args) {
        // Declare variables
        double doubleValue = 256.74;
        int intValue;
        byte byteValue;
        
        // Explicit casting
        intValue = (int)doubleValue; // double to int
        byteValue = (byte)intValue; // int to byte
        
        // Print results
        System.out.println("double value: " + doubleValue);
        System.out.println("int value: " + intValue);
        System.out.println("byte value: " + byteValue);
    }
}

Output:

double value: 256.74
int value: 256
byte value: 0

Note: The byte range is from -128 to 127. Since 256 is outside this range, the value gets truncated to 0.

Wrapper Classes in Java

Autoboxing

Autoboxing is the automatic conversion that the Java compiler makes between the primitive types and their corresponding object wrapper classes.

Example:

public class AutoboxingExample {
    public static void main(String[] args) {
        // Declare a primitive int
        int intValue = 10;
        
        // Autoboxing - converting int to Integer
        Integer integerValue = intValue;
        
        // Print the results
        System.out.println("Primitive int: " + intValue);
        System.out.println("Wrapper Integer: " + integerValue);
    }
}

Output:

Primitive int: 10
Wrapper Integer: 10

Unboxing

Unboxing is the opposite of autoboxing, where the Java compiler automatically converts an object of a wrapper class to its corresponding primitive type.

Example:

public class UnboxingExample {
    public static void main(String[] args) {
        // Declare a wrapper Integer
        Integer integerValue = 20;
        
        // Unboxing - converting Integer to int
        int intValue = integerValue;
        
        // Print the results
        System.out.println("Wrapper Integer: " + integerValue);
        System.out.println("Primitive int: " + intValue);
    }
}

Output:

Wrapper Integer: 20
Primitive int: 20

Using Wrapper Class Methods

Wrapper classes come with several useful methods that can be used to manipulate and convert data.

Example:

public class WrapperClassMethodsExample {
    public static void main(String[] args) {
        // Declare a primitive int
        int intValue = 30;
        
        // Autoboxing to Integer
        Integer integerValue = intValue;
        
        // Using methods of the Integer class
        String strValue = integerValue.toString(); // Convert to String
        int parsedValue = Integer.parseInt("40"); // Parse String to int
        
        // Print the results
        System.out.println("Integer value: " + integerValue);
        System.out.println("String value: " + strValue);
        System.out.println("Parsed int value: " + parsedValue);
    }
}

Output:

Integer value: 30
String value: 30
Parsed int value: 40

Complete Example: Combining Type Casting and Wrapper Classes

Let's create a program that demonstrates both type casting and the use of wrapper classes.

Example:

public class TypeCastingAndWrappersExample {
    public static void main(String[] args) {
        // Declare a double variable
        double doubleValue = 123.45;
        
        // Explicit casting to int
        int intValue = (int) doubleValue;
        
        // Autoboxing int to Integer
        Integer integerValue = intValue;
        
        // Using wrapper class methods
        // Convert Integer to String
        String strValue = integerValue.toString();
        
        // Parse String to int
        int parsedValue = Integer.parseInt("678");
        
        // Print results
        System.out.println("Original double value: " + doubleValue);
        System.out.println("Casted int value: " + intValue);
        System.out.println("Autoboxed Integer: " + integerValue);
        System.out.println("String value: " + strValue);
        System.out.println("Parsed int value: " + parsedValue);
    }
}

Output:

Original double value: 123.45
Casted int value: 123
Autoboxed Integer: 123
String value: 123
Parsed int value: 678

Summary

• Type Casting allows you to convert a variable of one data type to another.

  • Implicit Casting (Widening): Automatic when converting smaller to larger data types.
  • Explicit Casting (Narrowing): Manual conversion necessary to avoid data loss.

• Wrapper Classes are used to convert primitive data types to objects, which is useful for collections and object-oriented programming.

  • Autoboxing: Automatic conversion from primitive to wrapper.
  • Unboxing: Automatic conversion from wrapper to primitive.
  • Methods: Wrapper classes provide various methods for manipulation and conversion.