george blank mike meehan asra sultana l.
Skip this Video
Loading SlideShow in 5 Seconds..
Type Compatibility, Conversion, Assignment and Casts PowerPoint Presentation
Download Presentation
Type Compatibility, Conversion, Assignment and Casts

Loading in 2 Seconds...

play fullscreen
1 / 34

Type Compatibility, Conversion, Assignment and Casts - PowerPoint PPT Presentation

  • Updated on

George Blank, Mike Meehan, Asra Sultana. Type Compatibility, Conversion, Assignment and Casts. Variables and Types. A variable is a location in memory where values can be stored and referenced.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

Type Compatibility, Conversion, Assignment and Casts

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
    Presentation Transcript
    1. George Blank, Mike Meehan, Asra Sultana Type Compatibility, Conversion,Assignment and Casts

    2. 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.

    3. Variable (a memory location) a value (a default value) a type address a name (identifier) The address or value may be passed as a parameter

    4. 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

    5. 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.

    6. Java Primitive Types • Boolean: boolean • Integer: byte, short, int, long • Character: char • Floating Point: float, double

    7. 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 it’s 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 .

    8. 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

    9. 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)

    10. 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)"); }

    11. 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); } }

    12. 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 thesize of the whole number is too large to fit into the target int type, then that value will be reduced modulo the target type’s range.

    13. 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

    14. 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

    15. 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);} }

    16. 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.

    17. 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.

    18. 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.

    19. 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!

    20. Type Conversion • 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.

    21. 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.

    22. 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

    23. 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.

    24. Proper ways of Downcasting • The pessimistic approach exp instanceof Type • instanceofoperator is used to check the class of an object before downcasting • The expression returns true ifexpis 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 }

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

    26. 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).

    27. 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 betweenIntegerandint!

    28. 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

    29. 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.

    30. 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.

    31. Managing Class Versions • Avoid incompatible changes as much as possible. • Serialize data in a format that is implementation-agnostic (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

    32. References • Integer (Java 2 Platform SE v1.4.2). Sun Microsystems. 2003. 4/29/06 <>. • Number (Java 2 Platform SE v1.4.2). Sun Microsystems. 2003. 4/29/06 <>.

    33. References, continued • Versioning of Serializable Objects. Sun Microsystems. 1997. 4/29/06 <>. • Java Practices: Implementing Serializable. John O'Hanley. 2006. 4/29/06 <>.

    34. References, continued • VM Spec Java Programming Language Concepts. Sun Microsystems. 1999. 4/29/06 <>. • Xiaoping Jia, Object Oriented Software Development Using Java. Addison Wesley, 2003 • Patrick Naughton and Herbert Schildt, Java 2: The Complete Reference, Third edition