ertificación en
AVA
Universidad Nacional de Colombia
Facultad de Ingeniería
Departamento de Sistemas
4. CONVERTING AND CASTING
Objectives
Primitive Conversion
Primitive Casting
Object Reference Conversion
Object Reference Casting
Objectives
Determine the effect upon objects and primitive values of
passing variables into methods and performing assignments
or other modifying operations in that method
Explicit and Implicit Type Changes
You can explicitly change the type of a value by
casting
To cast an expression to a new type, just prefix the
expression with the new type name in parenthesis
Button btn=(Button)(myVector.elementAt( 5 ));
There are situations in which the system implicitly
changes the type of an expression without you
explicitly performing a cast
myVector.addElement( mycolor );
Conversion: automatic non-explicit type change
All conversion rules are enforced at compile time
Most casting and conversion rules accord with
common sense
Primitives and conversion
Both primitive values and object references can be
converted and cast
Four general cases:
Conversion of primitives
Casting of primitives
Conversion of object references
Casting of object references
Primitives and conversion
Three contexts or situations:
Assignment
Method call
Arithmetic promotion
Primitive Conversion: Assignment
happens when you assign a value to a variable of
different type from the original value
int i;
double d;
i=10;
d=i; // assign an int to a double variable
double i;
short s;
d=1.2345;
s=d; // assign a double value to a short
// variable
Error:
“Incompatible type for =.”
Primitive assignment conversion rules
Source type Target type
1. boolean any other OK
2. non-boolean any non-boolean OK
widening conversion
3. non-boolean any non-boolean
narrowing conversion
Widening conversions
Source type Target type
1. byte short, int, long, float, double
2. short int, long, float, double
3. char int, long, float, double
4. int long, float, double
5. long float, double
6. float double
Widening conversion
xxxx ...
...
0 ... 0 xxxx ...
Widening conversions
char
int long float double
byte short
Narrowing conversions
Source type Target type
1. byte char
2. short byte, char
3. char byte, short
4. int byte, short , char
5. long byte, short , char, int
6. float byte, short , char, int, long
7. double byte, short, char, int, long, float
Primitive Conversion: Method call
happens when you pass a value of one type as an
argument to a method that expects a different
type
float frads;
double d;
frads=2.34567f;
d=Math.cos(frads); // pass float to method
// that expects double
double d=12.0;
Object ob=myVector.elementAt(d);
Error:
“Incompatible type for method. Explicit
cast needed to convert double to int”
Widening conversions
SAME AS IN ASSIGNMENT CONVERSIONS!!
char
int long float double
byte short
Narrowing conversions
ARE FORBIDDEN!!
Primitive Conversion: Arithmetic Promotion
happens within arithmetic statements
1. short s=9;
2. int i=10;
3. float f=11.1f;
4. double d=12.2;
5. if (++s*i >= f/d)
6. System.out.println(“>>>>”);
7. else
8. System.out.println(“<<<<”);
values are “promoted” to wider types
Unary operators
Operand Conversion
• byte int
• short int
• char int
otherwise NO CONVERSION
Binary operators
Rule conversion
if one of the operands is
• double then double
else if one of the operands is
• float then float
else if one of the operands is
• long then long
else both operands are converted to
int
Primitives and Casting
Casting: explicitly telling Java to make a conversion
a casting may widen or narrow its argument
To cast, just precede a value with the
parenthesized name of the desired type
int i=5;
double d=(double)i;
int i=5;
double d=i;
same result as above
short s=259;
byte b=s; // compiler error
System.out.println(“s=“+s+”, b= “+b);
Error:
“Explicit cast needed to convert short to byte”
short s=259;
byte b=(byte)s; // Explicit cast
System.out.println(”b= “+b);
0000000100000011
b=(byte)s
00000011
Casting a value to a wider value is always permitted
but never required; if you omit the cast, an
implicit conversion will be performed on your
behalf
1. int i=2;
2. double radians;
. // hundreds of
. // lines of
. // code
600. radians=(double)i;
Explicit casting can make your code more readable
Rules that govern casting of primitive
types
source target
Can any non-boolean any non-boolean
Cannot boolean any other type
Cannot any other type boolean
Object Reference Conversion:
1. Assignment conversion
2. Method-call conversion
3. Casting
Takes place at compile time, this is not the case
for object casting
Object reference assignment
Conversion
Happens when you assign an object reference to a
variable of different type
Classes of object reference type
1. Class type (e.g., Button, FileWriter)
2. Interface type (e.g., Cloneable, LayoutManager)
3. Array type (e.g., int[][], TextArea[])
Oldtype=new Oldtype();
Newtype y=x; // reference assignment
// conversion
Converting Oldtype to Newtype
Oldtype is a Oldtype is an Oldtype is an
class interface array
Newtype is Oldtype must Newtype must Newtype must be
a class be a subclass be Object Object
of Newtype
Newtype is Oldtype must Oldtype must Newtype must be
an interface implement be a Cloneable
interface subinterface of
Newtype Newtype
Newtype is Compiler error Compiler error Oldtype must be an
an array array of some object
reference type that
can be converted to
whatever Newtype
is an array of
Object reference conversion is permitted
when the direction of the conversion is
“up” the inheritance hierarchy
An interface type may only be converted to an
interface type or to Object. If the new type
is an interface, it must be a superinterface
of the old type
A class type may be converted to a class type
or to an interface type. If converting to a
class type, the new type must be a
superclass of the old type. If converting to
an interface type, the old class must
implement the interface
An array may be converted to the class Object,
to the interface Cloneable or Serializable, or
to an array. Only an array of object
reference types may be converted to an
array, and the old element type must be
convertible to the new element type
Object
Fruit
Citrus
(implements
Squeezable)
Lemon Tangelo Grapefruit
Tangelo tange=new Tangelo();
Citrus cit=tange;
This code is fine
Citrus cit= new Citrus();
Tangelo tange=cit;
Compiler Error!!
Grapefruit g=new Grapefruit();
Squeezable squee=g; // No problem
Grapefruit g2=squee; // Error
Fruit fruits[];
Lemon lemons[];
Citrus citruses[]=new Citrus[10];
for (int i=0; i<10; i++) {
citruses[i]=new Citrus();
}
Fruits=citruses; // No problem
lemons=citruses; // Error
Object Method-Call Conversion:
Same as the rules described above for
assignment conversion of objects
• An array may be converted to the class
Object, to the interface Cloneable or
Serializable, or to an array. Only an array of
object reference types may be converted to
an array, and the old element type must be
convertible to the new element type
An interface type may only be converted to an
interface type or to Object. If the new type
is an interface, it must be a superinterface
of the old type
A class type may be converted to a class type
or to an interface type. If converting to a
class type, the new type must be a
superclass of the old type. If converting to
an interface type, the old class must
implement the interface
An array may be converted to the class Object,
to the interface Cloneable or Serializable, or
to an array. Only an array of object
reference types may be converted to an
array, and the old element type must be
convertible to the new element type
Vector myVec=new Vector ();
Tangelo tange=new Tangelo();
myVec.addElement(tange);
Tange will be automatically converted to
type Object
Object Reference Casting:
By using a cast, you convince the compiler to
let you do a conversion that otherwise might
not be allowed
Any kind of conversion that is allowed for
assignments or method calls is allowed for
explicit casting
The power of casting appears when you
explicitly cast to a type that is not allowed by
the rules of implicit conversion
Lemon lem=new Lemon();
Citrus cit=(Citrus)lem;
Legal cast but not needed
Java programs do not deal with objects. They
deal with references to objects.
Color purple=new Color(222, 0, 255)
purple IS NOT an object; it is a REFERENCE TO
an object (the address of the object)
Reference and Object
1011 ... 0110
Object of type Blob
resides in memory at 1011 ... 0110
Object reference variable types can be
1. classes
2. interfaces, or
3. arrays
While an object’s class is unchanging, it may be
referenced by variables of many different
types
Object obj; Vector vec; Stack stk; Serializable s;
1001 ... 0110 1001 ... 0110 1001 ... 0110 1001 ... 0110
Object of type Blob
resides in memory at 1011 ... 0110
The type of reference variable is obvious at
compile time
The class of an object referenced by such a
variable cannot be known until runtime
The rules for casting are broader than for
conversion
Some rules can be enforced at compile time;
other rules can only be enforced during
execution
Possibilities for the old and new type
1. non-final class
2. final class
3. interface
4. array
Compile-time rules
Oldtype is a Oldtype is a Oldtype is an Oldtype is an array
non-final final class interface
class
Newtype Oldtype Oldtype must Always OK Newtype must be
is a non- must extend Object
final class extend Newtype
Newtype or
viceversa
Newtype Newtype Oldtype and Newtype Compiler error
is a final must Newtype must
class extend must be the implement
Oldtype same class interface
Oldtype
Newtype Always OK Oldtype must Almost Newtype must be
is an implement always OK Cloneable
interface interface
Newtype
Newtype Oldtype Compiler Compiler Oldtype must be an
is an must be error error array of some reference
array object type that can be cast to
whatever Newtype is
an array of
Assuming that a desired cast survives
compilation, second check must occur at
runtime
The second check determines whether the two
classes are compatible (i.e., the class can be
converted according to the conversion rules)
Rules of thumb
(compile-time)
When both Oldtype and Newtype are classes,
one class must be a sublcass of the other
When both Oldtype and Newtype are arrays,
both arrays must contain reference types (NOT
PRIMITIVES), and it must be legal to cast an
element of Oldtype to an element of Newtype
You can ALWAYS cast between an interface
and a non-final object
Rules of thumb
(run-time)
If Newtype is a class, the class of the
expression being converted must be Newtype
or must inherit from Newtype
If Newtype is an interface, the class of the
expression being converted must implement
Newtype
Object
Fruit
Citrus
(implements
Squeezable)
Lemon Tangelo Grapefruit
1. Grapefruit g, g1;
2. Citrus c;
3. Tangelo t;
4. g=new Grapefruit(); // class is Grapefruit
5. c=g; // Legal assignment conversion,
6. // no cast needed
7. g1=(Grapefruit)c; // Legal cast
8. t=(Tangelo)c; // Illegal cast
9. // (throws an exception)
1. Grapefruit g, g1;
2. Squeezable s;
3. Tangelo t;
4. g=new Grapefruit();
5. s=g; // Convert Grapefruit to Squeezable
6. // (OK)
7. g1=s; // Convert Squeezable to Grapefruit
8. //(Compiler error)
Implicitly converting an interface to a class is
never allowed; you HAVE to use an explicit cast
7. g1=(Grapefruit)s; // Convert Squeezable to
8. //Grapefruit
1. Grapefruit g[];
2. Squeezable s[];
3. Citrus c[];
4. g=new Grapefruit[500];
5. s=g; // Convert Grapefruit array to
6. // Squeezable array (OK)
7. c=(Citrus[])s; // Cast Squeezable array to
8. // Citrus array (OK)
