Type Compatibility, Conversion, Assignment and Casts

George Blank, Mike Meehan, Asra Sultana

Variables and Types

A variable is a location in memory where values can be stored and referenced. Variables are associated with types, which have particular data sizes and a restricted set of valid operations that can be performed on them. Variable declarations assign an identifier, a type, and may declare an initial value. Many types have a default value. For example, an uninitialized integer defaults to 0.

Variable (a memory location)

a value (a default value)

address

a type

a name (identifier)
The address or value may be passed as a parameter

Identifiers
Identifiers are used in Java to give a name to classes, methods and variables that can be used to access them. Java identifiers begin with a letter, followed by letters or digits. A Java letter includes the letters of any alphabet in Unicode plus the underscore _ and dollar sign $. There is a Java standard naming convention for the use of identifiers, which can be found at

http://java.sun.com/docs/codeconv/

Sample Code Standards

Here are a few examples of code standards from the section on declarations:
6.1 Use one declaration per line to encourage comments 6.2 Try to initialize local variables where they are declared 6.3 Put declarations only at the beginning of blocks

There are a lot of details to learn, and it will take a while to be proficient in Java coding.

Java Primitive Types

Boolean: boolean Integer: byte, short, int, long Character: char Floating Point: float, double

Type Compatibility
Two Types are compatible if values of one type can appear wherever values of the other type are expected, and vice versa. Java is a strongly typed language and from there comes its safety and robustness. Every variable has a type which is strictly defined. All assignments ,whether explicit or via parameter passing in method calls ,are checked for type compatibility and any mismatches result in errors .

Type Conversion in Primitive Types

Widening
When one type of data is assigned to another type of variable, an automatic(implicit) type conversion will take place if,the two types are compatible and the destination type is larger than the source type. Example: int i; byte b; i=b; //valid conversion

Narrowing
Converting a value of larger range to value of smaller range. Example: int i; byte b; b=i; //invalid

Common misunderstanding
Implicit and explicit typecasting of primitive types is frequently misunderstood. The next slide is a small test program, overloaded with multiple constructors to show when and how type conversion promotion is done with implicit casting. In this example, since the third value is an integer, but there is no constructor that takes an integer, its value and the float value automatically convert to double. (Case 5: double, double, double)

public class typetest { typetest(double a, double b, short c){ System.out.println("1 (dbl dbl short)"); } typetest(float a, byte b, long c) { System.out.println("2 (float byte long)"); } typetest(long a, long b, long c) { System.out.println("3 (long long long)"); }

typetest(float a, long b, short c) { System.out.println("4 (float long short)"); } typetest(double a, double b, double c) { System.out.println("5 (dbl dbl dbl)"); } public static void main(String[] args) { typetest t = new typetest(); t.typetest(3.4, 3L, 3); } }

Type Casting in Primitive Types

A cast is an explicit type conversion of incompatible types. General form : (target-type)value Target-type is the desired type to convert the value to. A different type of conversion called truncation will occur when a floating point value is assigned to an integer type. If the size of the whole number is too large to fit into the target int type, then that value will be reduced modulo the target types range.

Assignment
For type conversion and casting the Assignment Operator is used between the two values. General form: var = exp Example: int i=10;
long m=10000L; double d=Math.PI;//PI=3.1415. i=(int)m;//cast m=i;//widening m=(long)d;//cast d=m;widening

Type Conversion in Expressions

In addition to assignments, type conversions may occur in expressions. Promotion rules that apply to expressions:
all byte and short values are promoted to int If one operand is long,the whole expression is promoted to long If one operand is a float ,the whole expression is promoted to float If one operand is double ,the whole expression is promoted to double

Promotion rules example

class Promote { Public static void main(String args[]){ byte b=12; char c=a; short s=1004; int i=20000; float f=5.67f; double d=.1234; double res=(f*b)+(i/c)-(d*s); System.out.println(result : +res);} }

Java Reference Types

In addition to the primitive types, Java allows types that are objects, and which can be user defined with a class definition. Since objects can have a hierarchy, with supertypes and subtypes, some operations can be inherited by subtypes. Guidelines for this must be understood to avoid problems.

The Object Type

All reference types are subclasses of the java.lang.Object type. Any object may be referred to by a reference variable of type Object. However, Objects have limited functionality, and it is advantageous to convert the generic Object to a more specific class, if possible.

Type Casting Returns

Type casting comes in two flavors: narrowing and widening. Narrowing casts force a variable of one type into a more restrictive structure (e.g. a parent class casted to a child class, or an interface casted to an implementing class). Widening casts do the opposite, moving from a child class to a parent class.

Son of Type Casting

It is generally safer to perform wider casts, and the JVM will handle them implicitly. Narrowing requires explicit type casting, and may result in a ClassCastException.
Object thing = new String(); String stringThing = (String) thing; Thread bogus = (Thread) thing; // raises exception!

 It most cases it makes sense to consider an Object in the context of several different types. An integer may be represented as a long, a float, a double or a String. Objects may be represented as integers when using Container classes.

Type Conversion

Conversion of Reference types

Widening
The conversion of a subtype to one of its supertypes is called widening. The widening of reference types is always allowed and is carried out implicitly.

Narrowing
Conversion of supertype to one of its subtypes is called narrowing. (downcasting) It requires explicit casting,it is allowed at compile time,it is not always safe and may result in runtime Exceptions.

Sample code fragment

class Student {..} //super class class Undergraduate extends student{..}//subclass class Graduate extends Student{..}//subclass // instances Student student1, student2; student1 =new UnderGraduate();//widening,valid student2 =new Graduate();//widening,valid Graduate student3; student3 = student2;//compilation error student3 = (Graduate)student2;//explicit cast //done,valid

Polymorphic Assignment
Polymorphic Assignment Rule:
The type of the expression at the right hand side of an assignment must be a subtype of the type of the variable at the left hand side of the assignment.

In the previous example,

student3=(Graduate)student2; //compilation OK, //runtime exception

Downcasting results in exceptions being thrown,so,it should be done with proper care There are two proper ways of downcasting.

Proper ways of Downcasting

The pessimistic approach
exp instanceof Type
instanceof operator is used to check the class of an object

before downcasting The expression returns true if exp is an instanceof a class or an interface type named Type.
if(student1 instanceof Graduate){ Graduate gradStudent=(Graduate)student1; }else { //student1 is not a graduate student }

Continue..
The optimistic approach
ClassCastException is caught as follows,
try{ // Graduate gradStudent=(Graduate)student1; // } catch(ClassCastException e){ //student1 is not a graduate student }

Conversion Functions
Primitives have Object wrapper classes that facilitate type conversions. The Integer class, for example is a wrapper for int. An Integer may be used anywhere an Object is required (it extends java.lang.Object).

Integer Class: Usage

int i = 24; Integer aye = new Integer(7); Integer jay = new Integer(j); Integer kay = new Integer(144); String ess = aye.toString(); double dee = aye.floatValue() / jay.intValue(); Distinguish between Integer and int!

Integer Class: Static Methods

Static methods exist for on-the-spot type conversions: System.out.println(Integer.toString(42)) ; int bug = Integer.valueOf(0xF00F); See also: java.lang.Number

Type Assignment
Type conversion by assignment is a more restrictive form of type conversion. Essentially, conversion by assignment may only occur in cases where the assigned type is wider than the assigning type. A notable exception is in the conversion from int to byte, short, or char. Assignment is permissible if the int may be losslessly represented by the narrower class.

Type Compatibility
After an iteration of development, it is possible that a class becomes incompatible with previous versions. It is the responsibility of the new class to maintain compatibility with older versions. Indicate incompatible versions of a class using the serialVersionUID.

Managing Class Versions

Avoid incompatible changes as much as possible. Serialize data in a format that is implementationagnostic (e.g. HashMap stores data in key-value pairs, rather than using an internal hash structure). If an incompatible change in necessary, change the serialVersionUID and prepare to handle the invalidClassException

References
Integer (Java 2 Platform SE v1.4.2). Sun Microsystems. 2003. 4/29/06 <http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Int eger.html>. Number (Java 2 Platform SE v1.4.2). Sun Microsystems. 2003. 4/29/06 <http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Nu mber.html>.

References, continued
Versioning of Serializable Objects. Sun Microsystems. 1997. 4/29/06 <http://java.sun.com/products/jdk/rmi/doc/serialspec/version.doc.html>. Java Practices: Implementing Serializable. John O'Hanley. 2006. 4/29/06 <http://www.javapractices.com/Topic45.cjp>.

References, continued
VM Spec Java Programming Language Concepts. Sun Microsystems. 1999. 4/29/06 <http://java.sun.com/docs/books/vmspec/2ndedition/html/Concepts.doc.html>. Xiaoping Jia, Object Oriented Software Development Using Java. Addison Wesley, 2003 Patrick Naughton and Herbert Schildt, Java 2: The Complete Reference, Third edition