Next page | Contents page |

Casting

Sometimes it is necessary to convert a value from one type to a closely related type, eg from int to long. That particular conversion is very easy and always permitted because the range of values for long encompasses the entire range for int. So we can write

int i = 32000; long l = i;

But the opposite will be rejected by the compiler, even if the actual value used is OK:

long l = 32000; int i = l; // FAILS TO COMPILE

If we know that the values will in fact always be within range, or even if we don't, we can force the compiler to accept it with a "cast" which consists of putting the target type in parentheses:

long l = 32000; int i = (int) l; // ACCEPTED

Here are some further examples. Read this as one continuous program:

	short sx = 10, sy = 1000; // Used in all the following
	int ix = (int) sx;        // Safe enough. (int) is the cast
	float fx = (float) sx;    // Similar - quite safe.
	byte b1 = sy;             // Compiler rejects as error.
	byte b2 = (byte) sy;      // Compiler allows but
			          // what does this do?
	int iy = sy;              // Compiler allows - cast is
			          // optional, there's no risk.
	float fy = sy;            // Ditto
	int iy2 = (int) fy;       // Allowed, but next line...
	int iy3 = Math.round (fy);
			          // ... is likely to be better. Why?
	boolean bb = true;
	int ib = (int) bb;        // No way! Not a related type.
		

Casting char to int

This is allowed, and it is the way to get the character code:

	char ch = 'A';
	int code = (int) ch;
		

More general casting

All examples above were casting between base (primitive) types. Later we will often cast between related class types. The same kind of syntax will be used:

	String s = (String) object;
	Customer cust1 = (Customer) person;
		
Next page | Contents page |