Modern Compiler Design

Java Tutorial

1 NFC on Java- suresh

 Object-Oriented Programming

2 NFC on Java- suresh

Partly adapted with permission from Eran Toch, Technion
 Different Programming Paradigms

 Functional/procedural programming:
 program is a list of instructions to the computer

 Object-oriented programming
 program is composed of a collection objects that communicate with
each other

3 NFC on Java- suresh

 Main Concepts
 Object
 Class
 Inheritance
 Encapsulation

4 NFC on Java- suresh

 Objects
 identity – unique identification of an object
 attributes – data/state
 services – methods/operations
 supported by the object
 within objects responsibility to provide these services to other
clients

5 NFC on Java- suresh

 Class
 “type”
 object is an instance of class
 class groups similar objects
 same (structure of) attributes
 same services
 object holds values of its class‟s attributes

6 NFC on Java- suresh

 Inheritance

 Class hierarchy
 Generalization and Specialization
 subclass inherits attributes and services from its superclass
 subclass may add new attributes and services
 subclass may reuse the code in the superclass
 subclasses provide specialized behaviors (overriding and
dynamic binding)
 partially define and implement common behaviors (abstract)

7 NFC on Java- suresh

 Encapsulation
 Separation between internal state of the object and its external
aspects

 How ?
 control access to members of the class
 interface “type”

8 NFC on Java- suresh

 What does it buy us ?
 Modularity
 source code for an object can be written and maintained
independently of the source code for other objects
 easier maintainance and reuse
 Information hiding
 other objects can ignore implementation details
 security (object has control over its internal state)
 but
 shared data need special design patterns (e.g., DB)
 performance overhead
9 NFC on Java- suresh
 mainly for c++ programmer

10 NFC on Java- suresh

Adapted with permission from Avivit Bercovici Boden, Technion
 Why Java ?
 Portable

 Easy to learn

 [ Designed to be used on the Internet ]

11 NFC on Java- suresh

 JVM
 JVM stands for
Java Virtual Machine

 Unlike other languages, Java “executables” are executed on a

CPU that does not exist.

12 NFC on Java- suresh

 Platform Dependent

myprog.c [Link]
gcc machine code
C source code

OS/Hardware

Platform Independent

[Link] [Link]
javac bytecode
Java source code

JVM

OS/Hardware
13 NFC on Java- suresh
 Primitive types

• int 4 bytes
• short 2 bytes
• long 8 bytes
Behaviors is
exactly as in
• byte 1 byte
C++
• float 4 bytes
• double 8 bytes
• char Unicode encoding (2 bytes) Note:
Primitive type
14 • NFC
boolean
on Java- suresh {true,false}
always begin
with lower-case
 Primitive types - cont.

• Constants
37 integer
37.2 float
42F float
0754 integer (octal)
0xfe integer (hexadecimal)

15 NFC on Java- suresh

 Wrappers

Java provides Objects which wrap

primitive types and supply methods.
Example:

Integer n = new Integer(“4”);

int m = [Link]();

16 NFC on Java- suresh

Read more about Integer in JDK Documentation
 Hello World
[Link]
class Hello {
public static void main(String[] args) {
[Link](“Hello World !!!”);
}
}

C:\javac [Link] ( compilation creates [Link] )

C:\java Hello (Execution on the local JVM)

17 NFC on Java- suresh

 More sophisticated
class Kyle {
private boolean kennyIsAlive_;
Default public Kyle() { kennyIsAlive_ = true; }
C’tor public Kyle(Kyle aKyle) {
kennyIsAlive_ = aKyle.kennyIsAlive_;
}
public String theyKilledKenny() {
if (kennyIsAlive_) {
Copy
kennyIsAlive_ = false;
C’tor return “You bastards !!!”;
} else {
return “?”;
}
}
public static void main(String[] args) {
Kyle k = new Kyle();
String s = [Link]();
[Link](“Kyle: “ + s);
}
18 NFC}on Java- suresh
 Results

javac [Link] ( to compile )

java Kyle ( to execute )

Kyle: You bastards !!!

19 NFC on Java- suresh

 Arrays
• Array is an object

• Array size is fixed

Animal[] arr; // nothing yet …

arr = new Animal[4]; // only array of pointers

for(int i=0 ; i < [Link] ; i++) {

arr[i] = new Animal();

// now we have a complete array

20 NFC on Java- suresh
 Arrays - Multidimensional
 In C++
Animal arr[2][2]

Is:

• In Java
Animal[][] arr=
new Animal[2][2]

What is the type of

21 NFC on Java- suresh
the object here ?
 Static - [1/4]
 Member data - Same data is used for all the instances
(objects) of some Class.
Assignment performed
Class A {
on the first access to the
public int y = 0;
Class.
public static int x_ = 1;
Only one instance of ‘x’
};
exists in memory
A a = new A();
A b = new A(); a b
[Link](b.x_); Output: 0 0
a.x_ = 5; y y
[Link](b.x_);
A.x_ = 10;
1
[Link](b.x_); 5 1
10 A.x_
22 NFC on Java- suresh
 Static - [2/4]
 Member function
 Static member function can access only static members
 Static member function can be called without an instance.

Class TeaPot {
private static int numOfTP = 0;
private Color myColor_;
public TeaPot(Color c) {
myColor_ = c;
numOfTP++;
}
public static int howManyTeaPots()
{ return numOfTP; }

// error :
public static Color getColor()
{ return myColor_; }
23 NFC on Java- suresh }
 Static - [2/4] cont.

Usage:

TeaPot tp1 = new TeaPot([Link]);

TeaPot tp2 = new TeaPot([Link]);

[Link](“We have “ +
[Link]()+ “Tea Pots”);

24 NFC on Java- suresh

 Static - [3/4]
 Block
 Code that is executed in the first reference to the class.
 Several static blocks can exist in the same class
( Execution order is by the appearance order in the class
definition ).
 Only static members can be accessed.

class RandomGenerator {
private static int seed_;

static {
int t = [Link]() % 100;
seed_ = [Link]();
while(t-- > 0)
seed_ = getNextNumber(seed_);
}
}
}
25 NFC on Java- suresh
 String is an Object

• Constant strings as in C, does not exist

• The function call foo(“Hello”) creates a String object,

containing “Hello”, and passes reference to it to foo.

• There is no point in writing :

String s = new String(“Hello”);

• The String object is a constant. It can’t be changed using

a reference to it.
26 NFC on Java- suresh
 Flow control
Basically, it is exactly like c/c++.

do/while
int i=5; switch
if/else do { char
If(x==4) { // act1 c=[Link]();
// act1 i--; switch(c) {
} else { } while(i!=0); case „a‟:
// act2 case „b‟:
} for // act1
break;
int j;
default:
for(int i=0;i<=9;i++)
// act2
{
}
j+=i;
27 }
NFC on Java- suresh
 Packages

 Java code has hierarchical structure.

 The environment variable CLASSPATH contains the
directory names of the roots.
 Every Object belongs to a package ( „package‟ keyword)
 Object full name contains the name full name of the
package containing it.

28 NFC on Java- suresh

 Access Control
 public member (function/data)
 Can be called/modified from outside.
 protected
 Can be called/modified from derived classes
 private
 Can be called/modified only from the current class
 default ( if no access modifier stated )
 Usually referred to as “Friendly”.
 Can be called/modified/instantiated from the same package.

29 NFC on Java- suresh

Inheritance class Base {
Base(){}
Base(int i) {}
protected void foo() {…}
}
Base
class Derived extends Base {
Derived() {}
protected void foo() {…}
Derived(int i) {
super(i);
Derived …
[Link]();
}
}

As opposed to C++, it is possible to inherit only from ONE class.

Pros avoids many potential problems and bugs.
ConsNFC might cause code replication
on Java- suresh
30
 Polymorphism
 Inheritance creates an “is a” relation:
For example, if B inherits from A, than we say that “B is
also an A”.
Implications are:
 access rights (Java forbids reducing access rights) - derived class
can receive all the messages that the base class can.
 behavior
 precondition and postcondition

31 NFC on Java- suresh

 Inheritance (2)
• In Java, all methods are virtual :
class Base {
void foo() {
[Link](“Base”);
}
}
class Derived extends Base {
void foo() {
[Link](“Derived”);
}
}
public class Test {
public static void main(String[] args) {
Base b = new Derived();
[Link](); // [Link]() will be activated
}
}
32 NFC on Java- suresh
 Inheritance (3) - Optional
class classC extends classB {
classC(int arg1, int arg2){
this(arg1);
[Link]("In classC(int arg1, int arg2)");
}
classC(int arg1){
super(arg1);
[Link]("In classC(int arg1)");
}
}
class classB extends classA {
classB(int arg1){
super(arg1);
[Link]("In classB(int arg1)");
}
classB(){
[Link]("In classB()");
}
}
33 NFC on Java- suresh
 Inheritance (3) - Optional
class classA {
classA(int arg1){
[Link]("In classA(int arg1)");
}
classA(){
[Link]("In classA()");
}
}

class classB extends classA {

classB(int arg1, int arg2){
this(arg1);
[Link]("In classB(int arg1, int arg2)");
}
classB(int arg1){
super(arg1);
[Link]("In classB(int arg1)");
}

class B() {
[Link]("In classB()");
}
34 } NFC on Java- suresh
 Abstract
 abstract member function, means that the function does not
have an implementation.
 abstract class, is class that can not be instantiated.
[Link]: class AbstractTest is an abstract class.
It can't be instantiated.
new AbstractTest();
^
1 error

NOTE:
An abstract class is not required to have an abstract method in it.
But any class that has an abstract method in it or that does
not provide an implementation for any abstract methods declared
in its superclasses must be declared as an abstract class.
35 NFC on Java- suresh
Example
 Abstract - Example
package [Link];
public abstract class Shape {
public abstract void draw();
public void move(int x, int y) {
setColor(BackGroundColor);
draw();
setCenter(x,y);
setColor(ForeGroundColor);
draw();
}
}

package [Link];
public class Circle extends Shape {
public void draw() {
// draw the circle ...
}
}
36 NFC on Java- suresh
 Interface
Interfaces are useful for the following:
 Capturing similarities among unrelated classes without
artificially forcing a class relationship.
 Declaring methods that one or more classes are expected to
implement.
 Revealing an object's programming interface without
revealing its class.

37 NFC on Java- suresh

 Interface
 abstract “class”

 Helps defining a “usage contract” between classes

 All methods are public

 Java‟s compensation for removing the multiple

[Link] can “inherit” as many interfaces as you
want.

*
38
- The correct term is “to implement”
NFC on Java- suresh
Example
an interface
 Interface
interface IChef {
void cook(Food food);
}

interface BabyKicker { interface SouthParkCharacter {

void kickTheBaby(Baby); void curse();
} }

class Chef implements IChef, SouthParkCharacter {

// overridden methods MUST be public
// can you tell why ?
public void curse() { … }
public void cook(Food f) { … }
}

39 * access
NFC rights
on Java- suresh(Java forbids reducing of access rights)
 When to use an interface ?

Perfect tool for encapsulating the

classes inner structure. Only the
interface will be exposed

40 NFC on Java- suresh

 Collections
 Collection/container
 object that groups multiple elements
 used to store, retrieve, manipulate, communicate aggregate data
 Iterator - object used for traversing a collection and selectively
remove elements

 Generics – implementation is parametric in the type of elements

41 NFC on Java- suresh

 Java Collection Framework
 Goal: Implement reusable data-structures and functionality

 Collection interfaces - manipulate collections independently of

representation details
 Collection implementations - reusable data structures
List<String> list = new ArrayList<String>(c);
 Algorithms - reusable functionality
 computations on objects that implement collection interfaces
 e.g., searching, sorting
 polymorphic: the same method can be used on many different
implementations of the appropriate collection interface

42 NFC on Java- suresh

 Collection Interfaces

Collection Map

Set List Queue Sorted Map

SortedSet

43 NFC on Java- suresh

 Collection Interface
 Basic Operations
 int size();
 boolean isEmpty();
 boolean contains(Object element);
 boolean add(E element);
 boolean remove(Object element);
 Iterator iterator();
 Bulk Operations
 boolean containsAll(Collection<?> c);
 boolean addAll(Collection<? extends E> c);
 boolean removeAll(Collection<?> c);
 boolean retainAll(Collection<?> c);
 void clear();
 Array Operations
 Object[] toArray(); <T> T[] toArray(T[] a); }
44 NFC on Java- suresh
 General Purpose Implementations

Collection Map

Set List Queue Sorted Map

SortedSet

HashSet TreeSet ArrayList LinkedList TreeMap HashMap

List<String> list1 = new ArrayList<String>(c);

45 NFC onList<String>
Java- suresh list2 = new LinkedList<String>(c);
 final

 final member data

final class Base {
Constant member final int i=5;
final void foo() {
i=10;
 final member function //what will the compiler say
about this?
The method can‟t be }
overridden. }

class Derived extends Base {

 final class // Error
// another foo ...
„Base‟ is final, thus it can‟t be void foo() {
extended
}
46 NFC on Java- suresh
(String class is final) }
 final
[Link]: Can't subclass final classes: class Base
class class Derived extends Base {
^
1 error
final class Base {
final int i=5;
final void foo() {
i=10;
}
}

class Derived extends Base {

// Error
// another foo ...
void foo() {

}
47 NFC on Java- suresh }
 IO - Introduction
 Definition
 Stream is a flow of data
 characters read from a file
 bytes written to the network
 …

 Philosophy
 All streams in the world are basically the same.
 Streams can be divided (as the name “IO” suggests) to Input and Output
streams.

 Implementation
 Incoming flow of data (characters) implements “Reader” (InputStream for bytes)
 Outgoing flow of data (characters) implements “Writer” (OutputStream for bytes –eg.
Images, sounds etc.)

48 NFC on Java- suresh

 Exception - What is it and why do I care?
Definition: An exception is an event that occurs during the
execution of a program that disrupts the normal flow of
instructions.

• Exception is an Object
• Exception class must be descendent of Throwable.

49 NFC on Java- suresh

 Exception - What is it and why do I
care?(2)
By using exceptions to manage errors, Java
programs have the following advantages over
traditional error management techniques:

1: Separating Error Handling Code from "Regular"

Code
2: Propagating Errors Up the Call Stack
3: Grouping Error Types and Error Differentiation

50 NFC on Java- suresh

1: Separating Error Handling Code from "Regular" Code (1)

readFile {
open the file;
determine its size;
allocate that much memory;
read the file into memory;
close the file;
}

51 NFC on Java- suresh

 1: Separating Error Handling Code from "Regular" Code (2)
errorCodeType readFile {
initialize errorCode = 0;
open the file;
if (theFileIsOpen) {
determine the length of the file;
if (gotTheFileLength) {
allocate that much memory;
if (gotEnoughMemory) {
read the file into memory;
if (readFailed) {
errorCode = -1;
}
} else {
errorCode = -2;
}
} else {
errorCode = -3;
}
close the file;
if (theFileDidntClose && errorCode == 0) {
errorCode = -4;
} else {
errorCode = errorCode and -4;
}
} else {
errorCode = -5;
}
NFC on Java- suresh
52
return errorCode;
}
 1: Separating Error Handling Code from "Regular" Code (3)

readFile {
try {
open the file;
determine its size;
allocate that much memory;
read the file into memory;
close the file;
} catch (fileOpenFailed) {
doSomething;
} catch (sizeDeterminationFailed) {
doSomething;
} catch (memoryAllocationFailed) {
doSomething;
} catch (readFailed) {
doSomething;
} catch (fileCloseFailed) {
doSomething;
}
53 NFC on Java- suresh
}
 2: Propagating Errors Up the Call Stack

method1 {
try {
call method2;
} catch (exception) {
doErrorProcessing;
}
}
method2 throws exception {
call method3;
}
method3 throws exception {
call readFile;
}
54 NFC on Java- suresh