1. EECE 309: Software Engineering
Lecture 2: Understanding Objects in Java and Types

2. Why Java ? Automated memory management Strong type safety for security
Portability through VM
No legacy baggage of C
Excellent in-built libraries for networking/graphics

3. Brief history of Java … Developed by James Gosling at Sun in 1995
Initially code-named ‘Oak’, was meant to target small, embedded devices (such as microwaves)
Became popular with the growth of WWW – Netscape had support for Applets
Mature alternative to C/C++ by late nineties
MS develops C# as alternative to Java (early 2000)
Today: Java used mainly in server/business apps

4. Learning Objectives
Differentiate between objects on stack and heap and understand garbage collection
Understand differences between mutable and immutable objects and Java calling semantics
Define apparent types and actual types and identify them for various statements
Identify implicit type conversions in Java and overloading

5. Objects and Variables Local variables Objects
Confined to single context: allocated on stack
Primitive types such as int or object references
Must be initialized before use (or fail compilation)
Objects
Shared among multiple procedure contexts
Allocated on heap using new operator
Can be initialized after creation (by constructor)

6. Variables and Objects: Example
heap
int i = 6; int j; int [] a = {1, 3, 5, 7, 9}; int [] b = new int[3]; String s = “abcdef”; String t = null; j = i; b = a; t = s;
i = 6
j = 6 j a b
“abcdef” s
t = null t
Stack

7. Object references All object references are uninitialized initially
Can be initialized to null, but not necessary
Need to explicitly allocate the object on the heap or assign it to (the start of ) an existing object
No pointer arithmetic possible once assigned
No need to explicitly de-allocate the reference (garbage collection frees it when not in use)
Can be passed to procedures and copied around

8. Example of Objects and References
{ Object b = null; Object a = new Object(); b = a; } int c = b.hashCode();
Reference b is allocated on stack
and initialized to null
Reference a is allocated on stack
Object is allocated on the heap and reference a points to it
b and a both point to the same object
a goes out of scope, so only b points to object
b goes out of scope too, so nobody points to the object.
Object is automatically reclaimed by garbage collector

9. Learning Objectives
Differentiate between objects on stack and heap and understand garbage collection
Understand differences between mutable and immutable objects and Java calling semantics
Define apparent types and actual types and identify them for various statements
Identify implicit type conversions in Java and overloading

10. Object Mutability
By default, Java objects are mutable
Modifications made through one reference will be visible when the object is accessed through another reference to the object
Example: Arrays
int [] a = {1, 3, 5, 7, 9};
a[3] = -1;
b = a;
b[4] = -2;

11. Exception: Immutable objects
State of immutable object never changes once it is assigned
Example: String object
String s1 = “abcdef”;
String s2 = “ghij”;
String s3 = s1;
s3 = s1 + s2;
String s4 = s3;
s4 = s2 + s1;
“abcdef”
“ghij”
“abcdefghij”
“ghijabcdef”
Heap

12. Group Activity: Try it yourself
What happens after these ? int[ ] a = {1, 2, 3}; int[ ] b = new int[2]; int[] c = a; int x = c[0]; b[0] = x; a[1] = 6; x = b[1]; int y = a[1];
What happens after these ? String s1 = “ace”; String s2 = “f”; String s3 = s1; String s4 = s3 + s2; s1 = s4; s4 = s1 + s2;

13. Java Calling Convention
Some textbooks will say the following
In Java, Objects are passed by reference, and primitives are passed by value… […]
This is wrong ! Java has only call-by-value
Both primitive types and object references are passed by value i.e., copied in to the stack frame
Can modify the object through the passed in reference provided object is not immutable

14. Calling convention: Call-by-value
stack
void foo(int a, int[] b) { a = a + 1; b[0] = 3; }
heap
a = 11
a = 10 b 3
int[] q = new int[3];
int p = 10;
foo (p, q);
// What are p and q’s value ?
p = 10 q

15. Method calls in Java – Example 1
public static void swap(int a, int b) { int temp = a; a = b; b = temp; } m = 5; n = 10; swap(m, n); // What are the values of m and n here ?

16. Method calls in Java – Example 2
public static void findAndRemove(int[ ] a, int m) { if (a ==null) return; // avoid null pointer exception for (int i = 0; i < a.length; ++i) { if (a[i]==m) a[i] = 0; } int[ ] b = { 0, 2, 4, 6, 8 }; findAndRemove( b, 2 ); // What is the value of the array b here ?

17. Method calls in Java – Example 3
public static void findAndRemove(int[ ] a, int m) { if (a ==null) return; // avoid null pointer exception a = new int[5]; // initialized to all ‘0’s for (int i = 0; i < a.length; ++i) { if (a[i]==m) a[i] = 0; } int[ ] b = { 0, 2, 4, 6, 8 }; findAndRemove( b, 2 ); // What is the value of the array b here ?

18. Learning Objectives
Differentiate between objects on stack and heap and understand garbage collection
Understand differences between mutable and immutable objects and Java calling semantics
Define apparent types and actual types and identify them for various statements
Identify implicit type conversions in Java and overloading

19. Type Safety Java is strongly typed (i.e., type-safe)
No “unsafe” casts are possible (e.g., reference to int)
Type-safety enforced by compiler (by language design)
Memory safety follows from type-safety
No writing past the end of an object (buffer overflows)
Automatic garbage collection provided by runtime, so no explicit frees or dangling pointers

20. Type Checking
public static void findAndRemove(int[] a, int m); The compiler checks the call-site of the function to ensure that it matches its type-signature. int[] b = [0, 2, 4, 8, 10]; int n = 5; Vector v = new Vector(); findAndRemove(b, n); // Is this legal ? findAndRemove(n, b); // What about this ? findAndRemove(v, n); // Ok, what about this ?

21. Type Hierarchy
Consider a type S which is a sub-type of T (i.e., S is a sub-class of T). Now, S can be substituted in place of T whenever a function expects T.
Example: All objects in Java are sub-types of Object, which defines an equals method.
String s1 = “hello;
Object 01 = s1;
if ( 01.equals(“hello”) ) ….; // legal
if ( O1.length() ) …. ; // illegal

22. Type Conversions
Type-checking is done using the apparent type of an object, NOT its actual type
If the actual type supports a member function, but the apparent type does not, it is ILLEGAL to invoke the member directly
However, if we cast the apparent type of an object to its actual type, we can invoke its member functions
String s1 = “hello;
Object O1 = s1;
if ( ( (String)O1 ).length() ) …. ; // legal
NOTE: If the actual type of the object does not match the cast type, a runtime exception is raised (ClassCastException)
Example: (Integer)(O1) will raise a runtime exception

23. Apparent vs. Actual type
Apparent type -- the type inferred from declarations
Actual type -- the type received at (object) creation
NOTE: Apparent type is a super-type of the actual type
Statement
Apparent type
Actual type
String s = “abcdef”;
String
Object o = s;
Object
s = o;
Illegal !
s = (String)o;
int [] a = {0, 1, 2};
Int[]
o = a;
int[]
a [2] = 3;
Int

24. Group Activity
Which of the following will compile ? For the ones that will compile, determine the result (or exception thrown)
Object o = “abc”;
Boolean b = new Boolean( o.equals(“a, b, c”) );
char c = o.charAt(1);
Object o2 = b;
String s = o;
String t = (String) o;
String u = (String) o2;
char d = t.charAt(1);

25. Learning Objectives
Differentiate between objects on stack and heap and understand garbage collection
Understand differences between mutable and immutable objects and Java calling semantics
Define apparent types and actual types and identify them for various statements
Identify implicit type conversions in Java and overloading

26. Type overloading
Same function can have multiple definitions based on argument types and/or return value
static int compare(int, float); // defn 1
static int compare(float, float); // defn 2
static int compare(float, int); // defn 3
The compiler “knows” which definition to call depending on the type of the parameters
compare(5.0, 3); // Calls defn 3
compare(5.0, 6.0); // Calls defn 2
compare(3, 5.0); // Calls defn 1

27. Implicit Type Conversions
Often, the compiler will implicitly convert one primitive type to another (widening)
int => float
int => long
But long => int, float=>int NOT possible
So which version of compare do these call ?
compare(3, 5.0); // Definition 1 or Definition 2 ?
compare(5.0, 6); // Definition 2 or Definition 3 ?

28. Matching Rule for Implicit Conversions
“Most specific” method
Find the method that matches the types of the parameters with the least number of type conversions
Example:
compare(3, 5.0); // Calls definition 1
compare(5.0, 6) // Calls definition 3
compare(5.0, 3.0); // Calls definition 2
compare(3, 4); // What about this one ?
NO “most specific method”  compilation error
Avoided by explicit type-casting: compare(3, (float)4 );

29. Group Activity Consider the following method:
void m(Object o, long x, long y); // D1
void m(String s, int x, long y); // D2
void m(Object o, int x, long y); // D3
void m(String s, long x, int y); // D4
Suppose you have the following declarations:
Object o; String v; int a; long b;

30. Group activity (contd…)
Which of the definitions match the call (if a call is illegal, please put an ‘x’ near it).
m(v, a, b);
m(v, a, a);
m(v, b, a);
m(v, b, b);
m(o, b, b);
m(o, a, a);