ZeroSpace is a part of Woxa Technology where industrial trainer are ready to trained you.Take a demo class and choose your future in the programming field. We offer to learn in latest technology with live project which is demanding. feel free to contact us-: 8471003400

1. Modern Compiler Design
Woxa Technologies pvt ltd
8471003400
woxatechnologies@gmail.com
Java Tutorial

2. 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. Main Concepts
• Object
• Class
• Inheritance
• Encapsulation

4. 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. 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. 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. Encapsulation
• Separation between internal state of the object
and its external aspects
• How ?
▫ control access to members of the class
▫ interface “type”

8. 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. mainly for c++ programmer

10. Why Java ?
• Portable
• Easy to learn
• [ Designed to be used on the Internet ]

11. JVM
• JVM stands for
Java Virtual Machine
• Unlike other languages, Java “executables”
are executed on a CPU that does not exist.

12. OS/Hardware
machine code
C source code
myprog.c
gcc
myprog.exe
Platform Dependent
JVM
bytecode
Java source code
myprog.java
javac
myprog.class
OS/Hardware
Platform Independent

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

14. • Constants
37 integer
37.2 float
42F float
0754 integer (octal)
0xfe integer (hexadecimal)
Primitive types - cont.

15. Wrappers
Java provides Objects which wrap
primitive types and supply methods.
Example:
Integer n = new Integer(“4”);
int m = n.intValue();

16. 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 < arr.length ; i++) {
arr[i] = new Animal();
// now we have a complete array

17. Arrays - Multidimensional
• In C++
Animal arr[2][2]
Is:
• In Java
What is the type of
the object here ?
Animal[][] arr=
new Animal[2][2]

18. Static - [1/4]
• Member data - Same data is used for all the
instances (objects) of some Class.
Class A {
public int y = 0;
public static int x_ = 1;
};
A a = new A();
A b = new A();
System.out.println(b.x_);
a.x_ = 5;
System.out.println(b.x_);
A.x_ = 10;
System.out.println(b.x_);
Assignment performed
on the first access to the
Class.
Only one instance of ‘x’
exists in memory
Output:
1
5
10
a b
y y
A.x_
0 0
1

19. 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_; }
}

20. Static - [2/4] cont.
Usage:
TeaPot tp1 = new TeaPot(Color.RED);
TeaPot tp2 = new TeaPot(Color.GREEN);
System.out.println(“We have “ +
TeaPot.howManyTeaPots()+ “Tea Pots”);

21. 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 = System.getTime() % 100;
seed_ = System.getTime();
while(t-- > 0)
seed_ = getNextNumber(seed_);
}
}
}

22. 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 :
• The String object is a constant. It can’t be changed using
a reference to it.
String s = new String(“Hello”);

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

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

25. Inheritance
Base
Derived
class Base {
Base(){}
Base(int i) {}
protected void foo() {…}
}
class Derived extends Base {
Derived() {}
protected void foo() {…}
Derived(int i) {
super(i);
…
super.foo();
}
}
As opposed to C++, it is possible to inherit only from ONE class.
Pros avoids many potential problems and bugs.
Cons might cause code replication

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

27. Inheritance (2)
• In Java, all methods are virtual :
class Base {
void foo() {
System.out.println(“Base”);
}
}
class Derived extends Base {
void foo() {
System.out.println(“Derived”);
}
}
public class Test {
public static void main(String[] args) {
Base b = new Derived();
b.foo(); // Derived.foo() will be activated
}
}

28. Inheritance (3) - Optional
class classC extends classB {
classC(int arg1, int arg2){
this(arg1);
System.out.println("In classC(int arg1, int arg2)");
}
classC(int arg1){
super(arg1);
System.out.println("In classC(int arg1)");
}
}
class classB extends classA {
classB(int arg1){
super(arg1);
System.out.println("In classB(int arg1)");
}
classB(){
System.out.println("In classB()");
}
}

29. Inheritance (3) - Optional
class classA {
classA(int arg1){
System.out.println("In classA(int arg1)");
}
classA(){
System.out.println("In classA()");
}
}
class classB extends classA {
classB(int arg1, int arg2){
this(arg1);
System.out.println("In classB(int arg1, int arg2)");
}
classB(int arg1){
super(arg1);
System.out.println("In classB(int arg1)");
}
class B() {
System.out.println("In classB()");
}
}

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

31. Interface
• abstract “class”
• Helps defining a “usage contract” between
classes
• All methods are public
• Java’s compensation for removing the
multiple inheritance. You can “inherit” as
many interfaces as you want.
Example*
- The correct term is “to implement”
an interface

32. Interface
interface SouthParkCharacter {
void curse();
}
interface IChef {
void cook(Food food);
}
interface BabyKicker {
void kickTheBaby(Baby);
}
class Chef implements IChef, SouthParkCharacter {
// overridden methods MUST be public
// can you tell why ?
public void curse() { … }
public void cook(Food f) { … }
}
* access rights (Java forbids reducing of access rights)

33. When to use an interface ?
Perfect tool for encapsulating the
classes inner structure. Only the
interface will be exposed

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

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

36. Collection Interfaces
Collection
Set List Queue
SortedSet
Map
Sorted Map

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

38. General Purpose Implementations
Collection
Set List Queue
SortedSet
Map
Sorted Map
HashSet HashMap
List<String> list1 = new ArrayList<String>(c);
ArrayListTreeSet TreeMapLinkedList
List<String> list2 = new LinkedList<String>(c);

39. final
• final member data
Constant member
• final member
function
The method can’t be
overridden.
• final class
‘Base’ is final, thus it
can’t be extended
final class Base {
final int i=5;
final void foo() {
i=10;
//what will the compiler say
about this?
}
}
class Derived extends Base {
// Error
// another foo ...
void foo() {
}
}(String class is final)

40. final
Derived.java:6: 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() {
}
}

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

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

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

44. 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;
}

45. 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;
}
return errorCode;
}

46. 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;
}
}

47. 2: Propagating Errors Up the Call Stack
method1 {
try {
call method2;
} catch (exception) {
doErrorProcessing;
}
}
method2 throws exception {
call method3;
}
method3 throws exception {
call readFile;
}