EECE 310: Software Engineering
Lecture 2: Understanding Objects in Java and Types
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
2
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
3
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
4
Objects and Variables
• Local variables– 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)
5
Variables and Objects: Example
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;
Stack
i = 6
j
a
b
s
t = null
1 3 5 7 9
heap
0 0 0
“abcdef”
j = 6
t
6
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 around7
Example of Objects and References
{ Object b = null; {
Object a = new Object();b = a;
} c = b.hashCode();}
8
Reference b is allocated on stackand 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
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
9
1 3 5 7 91 3 5 -1 9
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;
1 3 5 -1 -210
Exception: Immutable objects
• State of immutable object never changes once it is assigned
• Example: String objectString s1 = “abcdef”;String s2 = “ghij”;String s3 = s1;s3 = s1 + s2;String s4 = s3;s4 = s2 + s1;
“abcdef”
“ghij”
“abcdefghij”
“ghijabcdef”
11
Heap
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;
12
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
13
Calling convention: Call-by-value
void foo(int a, int[] b){ a = a + 1; b[0] = 3;}
14
a = 10
b
p = 10
q
0
0
0
heap
stack
a = 11
3
int[] q = new int[3];int p = 10;foo (p, q);// What are p and q’s value ?
Method calls in Java – Example 1public 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 ?// (HINT: It’s not what you expect)
15
Method calls in Java – Example 2public 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 ?
16
Method calls in Java: Example 3
public static void padChars(StringBuffer s, int n) { for (int i = 0; i < n; i++) s.append(‘a’);}
String str = “hello”;padChars(str, 5); // What is the value of str ?
17
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
18
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 pointers19
Type Checking
• Consider the following function: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; String s = “hello”;findAndRemove(b, n); // Is this legal ?findAndRemove(n, b); // What about this ?findAndRemove(s, n); // Ok, what about this ?
20
Type Hierarchy• Consider a type S which is a sub-type of T (say S is
derived from 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
21
Statement Apparent type Actual type
String s = “abcdef”; String String
Object o = s; Object String
s = o; Illegal !
s = (String)o;
String String
int [] a = {0, 1, 2}; Int[] Int[]
o = a; Object int[]
a [2] = 3; Int Int
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
22
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);
23
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
24
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
25
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
26
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 ?
27
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, 3.0); // Calls definition 2• compare(3, 4); // What about this one ?
– NO “most specific method” compilation error • Can be avoided by explicit type-casting in the call such as
compare(3, (float)4 );
28
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
29
Before the next class
• Do exercises 2.1 to 2.7 in textbook for practice– Not graded, but will help in quiz preparation
• Get acquainted with Java– Pick a partner by end of this week (or we’ll pick one)
• Start working on Assignment 1 – Will involve basic Java programming– Due 3 weeks from today on your specific lab session
30