Java Programming 3 rd class – Department of Network
Mehdi Ebady Manaa College of IT- University of Babylon
Type Checking
Java is
language, which means that the Java compiler checks the code to ensure that every assignment and every call is type correct. If a type error is discovered, compilation fails with an error message.
Type checking depends on the fact that every variable declaration gives the type checking of the variable, and the header of every method and constructor defines its
the types of its arguments and results (and also the types of any exceptions it throws).
This information allows the compiler to deduce an
for any expression and this deduction then allows it to determine the legality of an assignment
For example consider int y= 7; int z= 3; int x= num.gcd (z,y); // discuss that
When the compiler processes the call to Num.gcd, it knows that the
Num.gcd requires two integer arguments and it also knows that expressions z and y are both of type int. therefore; it knows the call of
is legal. Furthermore it knows that
returns an
and therefore it knows that the assignment to x is legal.
Note Java has an important property: legal Java programs (that is, those accepted by the compiler) are guaranteed to be
.
This mean that there cannot by any type errors when the program runs.
Page 1 Date: Wednesday, November 19, 2014

Java Programming 3 rd class – Department of Network
Mehdi Ebady Manaa College of IT- University of Babylon
Java types are organized into a have a number of
in which a type can
, we say the type is a subtype of each its
In addition, some texts say a type
another type to mean it is a subtype of the other type.
The subtype relation is transitive: if R is a subtype of S, and S is a subtype of T, then R is a subtype of T. the relation is also reflexive:
Type S is a subtype of itself.
Since objects of a subtype behave like those of a super-type , it makes sense to allow them to be referred to by a variable whose declared type is a
. This usage is permitted by Java: an assignment v=e is legal if the type of e is a subtype of the type of v. for example, the following is
Object o1= a; // a is an array defined previously
Object o2= s; // is a string defined previously
Here a is an array and s is a string
An implication of the assignment rule is that
of the object obtained by the evaluating an expression is a subtype of the
of the expression deduced by the compiler using declaration. For example, the
of o2 is Object, but it actual type is
Type checking is always done using the apparent type. This means, for example, that any method calls made using the object
Page 2 Date: Wednesday, November 19, 2014

Java Programming 3 rd class – Department of Network
Mehdi Ebady Manaa College of IT- University of Babylon will be determined to be legal based on the apparent type.
Therefore only Object method like equal can be called on Object
O2, string method like length (which returns a count of the number of characters in the string) cannot be called:
Example
If ( o2.equals(“abc”)// legal
If ( o2.lenght ( ) ) // illegal
Furthermore, the following is illegal:
S=o2; // illegal
Because the apparent type of o2 is not a subtype of String.
Compilation will fail when the program contains illegal code as in these examples.
Sometimes a program needs to determine the actual type of an object
, for example, so that a method not provided by the apparent type can be called. This can be done by
In the example, the casts check whether o2’s actual type is the same as the indicated type string, these checks succeed, and therefore, the assignment of the statement is allowed.
Page 3 Date: Wednesday, November 19, 2014

Java Programming 3 rd class – Department of Network
Mehdi Ebady Manaa College of IT- University of Babylon
Example:
Object o=”abc”;
We have a following code, we need to indicate whether or not a compile time error will occur, and for those statements that are legal at compile time, indicate whether they will return normally or by throwing an exception boolean b= o.equals( "a,b,c" ); char c= o.charAt(1);
Object o2=b;
String s=o;
String t=(String)o;
t.lenght ()// 3 c=t.charAt(1); c=t.charAt(3);
Page 4 Date: Wednesday, November 19, 2014

Java Programming 3 rd class – Department of Network
Mehdi Ebady Manaa College of IT- University of Babylon
Casting on a primitive types
Casting means assigning a value of one type to a variable of another type. If two types are compatible, the java software performs the conversation automatically.
If information might be lost in an assignment, the programmer must confirm the assignment with a cast.
• The assignment between long and int requires an explicit cast. long bigValue = 99L; int x = bigValue; // Wrong, needs a cast int x = (int) bigValue; // OK int x = 99L; // Wrong, needs a cast int x = (int) 99L; // OK, but... int x = 99; // default integer literal
Example
Short a,b,c; a=1; b=2; c=a+b; // is this correct?
Page 5 Date: Wednesday, November 19, 2014

Java Programming 3 rd class – Department of Network
Mehdi Ebady Manaa College of IT- University of Babylon
Page 6 Date: Wednesday, November 19, 2014