6 - Primitive Values, Wrapper Classes, Types, and Casting

6.1 Introduction to Primitive Values

• What are Primitive Data Types?
• Primitive data types are the basic data types in Java that represent single values. These types are built into the language and are not objects. They are the most basic units for storing data in memory and are used to define variables directly.
• Java Primitive Data Types:
• Java provides eight built-in primitive data types:
  • byte: 8-bit signed integer (range: -128 to 127)
  • short: 16-bit signed integer (range: -32,768 to 32,767)
  • int: 32-bit signed integer (range: -2^31 to 2^31-1)
  • long: 64-bit signed integer (range: -2^63 to 2^63-1)
  • float: 32-bit floating-point number (single precision)
  • double: 64-bit floating-point number (double precision)
  • char: 16-bit Unicode character (range: 0 to 65,535)
  • boolean: Represents true or false values (1-bit size).

6.2 Wrapper Classes

• What are 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 for Primitive Types:
• Byte for byte
• Short for short
• Integer for int
• Long for long
• Float for float
• Double for double
• Character for char
• Boolean for boolean.
• Why Use Wrapper Classes?
• Wrapper classes are used when we need to store primitive types in collections (like ArrayList) since collections only work with objects. These 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.

6.3 Types of Data in Java

• Primitive Types:
• Primitive types are predefined by the language and are not objects. They store simple values and are faster to use because they require less memory.
• Reference Types:
• Reference types are types that refer to objects. They store memory addresses that point to the actual data in memory. Arrays and objects (instances of classes) are reference types in Java.
  • Example: String str = "Hello, World!"; // String is a reference type.
  • int[] numbers = {1, 2, 3}; // Array is a reference type.
• Difference Between Primitive and Reference Types:
• Primitive types are stored directly in memory, while reference types store a reference (memory address) to the object they refer to.
• Primitive types have fixed sizes, whereas reference types can be of variable size depending on the object being referenced.

6.4 Type Conversion and Casting

• What is Type Conversion?
• Type conversion is the process of converting one data type to another. There are two main types of type conversion in Java:
  • Implicit (Automatic) Type Conversion: Java automatically converts smaller data types to larger ones when there’s no loss of data.
  • Explicit (Manual) Type Conversion (Casting): This occurs when you need to convert from a larger data type to a smaller one or when converting between incompatible data types. This type of conversion requires casting.
• Implicit Type Conversion (Widening):
• Java automatically converts a smaller type into a larger type when necessary.
• Example: int to float or char to int.

public class TypeConversion {
    public static void main(String[] args) {
        int num = 50;
        double result = num; // Implicit conversion from int to double
        System.out.println("Result: " + result); // Output: Result: 50.0
    }
}

• Explicit Type Conversion (Casting) (Narrowing):
• When converting from a larger type to a smaller type, you need to manually cast the data using the cast operator (type).
• Example: double to int, long to int.

public class TypeCasting {
    public static void main(String[] args) {
        double num = 9.99;
        int intNum = (int) num; // Explicit casting from double to int
        System.out.println("Integer value: " + intNum); // Output: Integer value: 9
    }
}

6.5 AutoBoxing and UnBoxing

• AutoBoxing:
• AutoBoxing is the automatic conversion of a primitive type to its corresponding wrapper class object. This happens automatically when a primitive is passed as an argument to a method that expects an object.
• Example: Converting a primitive int to an Integer object automatically.

public class AutoBoxingExample {
    public static void main(String[] args) {
        int num = 100;
        Integer numWrapper = num; // AutoBoxing: int to Integer
        System.out.println("Integer value: " + numWrapper); // Output: Integer value: 100
    }
}

• UnBoxing:
• UnBoxing is the reverse process of AutoBoxing, where a wrapper class object is automatically converted back to its corresponding primitive type.
• Example: Converting an Integer object back to a primitive int.

public class UnBoxingExample {
    public static void main(String[] args) {
        Integer numWrapper = Integer.valueOf(200);
        int num = numWrapper; // UnBoxing: Integer to int
        System.out.println("Primitive int value: " + num); // Output: Primitive int value: 200
    }
}

6.6 Conclusion

• Summary of Key Points:
• Primitive data types in Java represent simple values and are the most basic types of data used in the language.
• Wrapper classes allow primitive types to be treated as objects, enabling the use of objects in collections and providing utility methods.
• Type conversion helps in converting one type of data into another, either implicitly or explicitly through casting.
• AutoBoxing and UnBoxing provide a convenient way of converting between primitive types and their corresponding wrapper class objects automatically.
• The Importance of Type Conversion in Java:
• Type conversion is essential in Java as it allows you to work with different data types efficiently and effectively. Understanding both implicit and explicit conversions, as well as AutoBoxing and UnBoxing, is crucial for writing robust Java programs.