---

Casting (or Type Conversion)

---

• Another look at the Primitive Types

  • Look carefully at the range of values that the number types covers in the following table:

    Type	Description	Size
    int	The integer type, with range -2,147,483,648 . . . 2,147,483,647	4 bytes
    byte	The type describing a single byte, with range -128 . . . 127	1 byte
    short	The short integer type, with range -32768 . . . 32767	2 bytes
    long	The long integer type, with range -9,223,372,036,854,775,808 . . . 9,223,372,036,854,775,807	8 bytes
    double	The double-precision floating-point type, with a range of about ±10308 and about 15 significant decimal digits	8 bytes
    float	The single-precision floating-point type, with a range of about ±1038 and about 7 significant decimal digits	4 bytes
    char	The character type, representing code units in the Unicode encoding scheme	2 bytes
    boolean	The type with the two truth values false and true	1 bit

    • The range of values of the byte type is contained in the range of values of the short type

    • The range of values of the short type is contained in the range of values of the int type

    • The range of values of the int type is contained in the range of values of the long type

    • The range of values of the long type is contained in the range of values of the float type
      (well, not precisely, but approximately - the error is not too bad)

    • The range of values of the float type is contained in the range of values of the double type

  • The "contained" relationship is graphically represented in the following diagram:

  • Note that the "contained" relationships is transitive...
    If the "range of values of the byte type is contained in the range of values of the short type" and the "the range of values of the short type is contained in the range of values of the int type", then also: "the range of values of the byte type is contained in the range of values of the int type.

    And so on...

    In other words, these relationships also hold:

    • The range of values of the byte type is contained in the range of values of the int type
    • The range of values of the byte type is contained in the range of values of the long type
    • The range of values of the byte type is contained in the range of values of the float type
    • And so on...

  ---

• Converting values between numeric types
  • Java allows you to convert a value of one numeric type into another numeric type.

  • What do we mean by "convert a value of one numeric type into another numeric type" ?

    Here is an example to illustrate conversion:

    public class Long2Int { public static void main(String[] args) { int i; long l; l = 2147483647; i = l; // WARNING: Can't be expressed like this in Java. // I only write it this way to express an intension: // l contains a long integer value // i can contain an int value // A "long" is different from "int", but similar // enough to be converted to each other } }

    • The variable i is of the type int and the value stored in variable i is also of the type int

    • The variable l is of the type long and the value stored in variable l is also of the type long

    • The intention of the assignment operation

      	i = l;
      

      is taking a long value stored in the (type long) variable l, and trying to store it in an type int variable i

      The above assignment operation is unaccaptable in Java, because long and int are different.

    • This assignment operation can only happen by:
      • First converting (changing) the type long value in variable l into a type int value
      • Then store the converted (type int) value into the variable i

    • Because the integer types are "similar" enough, you can request that Java convert a number from one type to another type.

      A conversion is called a cast.

  ---

  ---

• The Cast Operation
  • The computer science term "to cast" means "to convert one type to another type"

  • The syntax of the "cast" operation in Java is:

    (typeName) expression

    converts the value of the expression to the type typeName

  • Example 1:

    int i; long l; l = 2147483647; i = (int) l;

    i = (int) l: takes (long) value in l and converts it into an int value. Then the result is assigned to the int variable i.

  • Example 2:

    int i; double d; d = 827.3984; i = (int) d;

    i = (int) d: takes (double) value in d and converts it into an int value. Then the result is assigned to the int variable i.

    NOTE: when casting a floating point value into an integer value, Java will TRUNCATE: the floating point value !!! (Does NOT round up !)

  ---

  ---

• Thinking about the Cast Operation
  • Consider the example:

    int i; long l; l = 2147483647; i = (int) l;

  • Question:
    Can an int variable i always contain a value stored in a long variable l ???

    Answer:

    NO !

    The value stored in l can be one of these values: -9,223,372,036,854,775,808 . . . 9,223,372,036,854,775,807.

    The value that can be stored in i must be one of these values: -2,147,483,648 . . . 2,147,483,647

    Because the range of values that l can hold is larger (exceeds) the range of values that i can hold, we CANNOT be certain that i can hold the value that is currently stored in l....

    ---

  • Question:
    • What could be the problem if you insist on assigning l to i ?

    Answer:

    • We have seen this: overflow !!! (see: click here )

    ---

    ---

  • This problem also exist in example 2:

    int i; double d; d = 827.3984; i = (int) d;

    ---

    ---

  • DEMO Program: (Demo overflow when you assign long to int)                        
    • Prog file: click here

    ---

    ---

  • DEMO Program: (Demo overflow when you assign double to int)                        
    • Prog file: click here

  ---

  ---

• Safe conversions
  • In the previous examples, we tried to:
    • assign a long value to an int variable
    • assign a double value to an int variable

  • We saw that because the range of value of long exceeds the range of int, and also range of value of double exceeds the range of int, the assignment can cause problems.

  • Now consider the following conversion:

    public class Int2Long { public static void main(String[] args) { int i; long l; i = 2147483647; l = (long) i; // i can contain an int value // l contains a long integer value // A "int" is different from "int", but // similar enough to be converted to // each other } }

    In this example, a value in an int type variable is assigned to a long type variable.

    ---

    ---

  • Question:
    Can a long type variable l always contain a value stored in an int variable i ???

    Answer:

    YES !

    The value stored in i can be one of these values: -2,147,483,648 . . . 2,147,483,647

    The value that can be stored in l can be one of these values: -9,223,372,036,854,775,808 . . . 9,223,372,036,854,775,807.

    Because the range of values that l can hold is cotains the range of values that i can hold, we can be certain that l can hold the whatever value that is currently stored in i....

    ---

  • Question:
    • What could be the problem if you insist on assigning i to l ?

    Answer:

    • By the above argument, nothing bad will happen !!!

      The int to long conversion is safe !!!

    ---

    ---

  • In fact, the conversions depicted in the "contained" relatioship above are all safe (no overflow will occur if you perform such a conversion):

  • Programming short hand

    When a conversion is safe, the cast operation is not required Java will perform a safe conversion automatically without the programmer having to specify a cast operation)

  • Example:

    public class Int2Long { public static void main(String[] args) { int i; long l; i = 2147483647; l = i; // i can contain an int value // l contains a long integer value // int -> long conversion is safe // We do not need to specify the // cast operation (long) } }

  ---

  ---

• Unsafe conversions
  • As discussed above, the following conversion are UNSAFE because a "larger" type is converted into a "smaller" type:

  • You MUST specify a cast operation to tell Java to go ahead to perform an UNSAFE conversion

  • We have seen examples before:

    • Example 1:

      int i; long l; l = 2147483647; i = (int) l;

      i = (int) l: takes (long) value in l and converts it into an int value. Then the result is assigned to the int variable i.

    • Example 2:

      int i; double d; d = 827.3984; i = (int) d;

      i = (int) d: takes (double) value in d and converts it into an int value. Then the result is assigned to the int variable i.

    ---

    ---

  • So the bottom line of this is:
    • Java will not perform an unsafe conversion automatically.

    • But Java will perform unsafe conversions, if you tell Java to do so...

    • So if something does goes wrong in the conversion (which was unsafe), you are to blame (because you have asked for it !!!)

  ---

  ---

• Order of operations that involves a cast operation
  • As you know, arithmetic operations have different priorities.

    For instance, multiply goes before addition.

  • Example:

    4 + 4 * 4 = 4 + (4 * 4) = 4 * (16) = 20

    ---

    ---

  • The cast operation has the highest priority

  • Example:

    3 + (int) 4.7 * 5 = 3 + ((int) 4.7) * 5 = 3 + (4) * 5 = 3 + (4 * 5) = 3 + (20) = 23