final year project center in coimbatore

Java workshop

Objectives:Static and instance members,Exceptions,Multithreading,Garbage collection andCollections

Static members

“static” keyword:

• “static” is used to maintain fixed values.• “static” keyword is used to access a member

without the existence of the object. “static” members can be accessed by using the class name directly.

• Instance members should be accessed by the object.

• While declaring a member(may be method or variable), if we are not prefixing a member with “static” keyword, that member is called instance member.

• We can call the static variables as class variables because those members can be shared by all the objects of that class.

• Members of a class are:– Methods and– Variables.

Syntax for static methods: [modifier] static return-type method-

name([parameters]){Logic for the method;}Eg:static int add(int a, int b){return (a+b);}

Syntax for instance methods:[modifier] return-type method-name([parameters]){Logic for instance method;}Eg:double mul(double d1, double d2){return (d1*d2);}

Syntax for class variables:[modifier] static type variable-name[=value];Eg:static int i=25;Syntax for instance variables:[modifier] type variable-name[=value];Eg:int i=25;

• In terms of objects, for every instance member, separate copy will be created.

• For static members, one copy will be created and shared by all the objects.

• In the case of class and instance variables, if we are not performing the initialization, JVM will provide the default values.

Eg:class Demo{int i;static int j;public static void main(String[] args){System.out.println(j);Demo d=new Demo();System.out.println(d.i);System.out.println(d.j);}}

Eg:class Test{int i=10;static int j=20;public static void main(String[] args){System.out.println(j);Test t1=new Test();t1.i=100;t1.j=200;System.out.println(t1.i+”…”+t1.j);Test t2=new Test();System.out.println(t2.i+”…”+t2.j);}}

i=100j=

j =20t1 200

Static variable

Important note:We can access instance members from

instance area only. We can’t access from static area.

Static members are accessible from instance as well as static areas.

Exercise:I. int i=1;II. static int i=2;III. public static void main(String[] args)

{System.out.println(i);}

Which of the above code snippet combinations are possible?

a). I and II, b). I and III, c). II and III

class Member{int i;public static void main(String[] args){System.out.println(i);}}

Eg:class StatMethDemo{public static void add(int i, int j){System.out.println(i+j);}public static void main(String[] args){add(10,20);}}

Eg:class InstMethDemo{public void add(int i, int j) //instance method{System.out.println(i+j);}public static void main(String[] args){add(10,20);}}

Exceptions

Exceptions:

• An abnormal event that disturbs the normal flow of the program is called an exception (or) simply it is an issue.

• Main objective of exception handling is graceful termination of the program.

• Exception handling means providing alternate way when an exception is raised. It doesn’t mean repairing an exception.

Eg:class Test{public static void main(String[] args){System.out.println("Hi");System.out.println(10/0);System.out.println("Bye");}}

When an exception is raised, JVM will provide the details(default mechanism) of the exception as follows:Name of the exception,Description, andStack trace(Location).Eg:

Exception in thread “main” java.lang.ArithmeticException : / by zero

at Test.main(Test.java:6)

Throwable class is the root class for all exception hierarchy. It contains 2 sub-classes:• Exception(programmatic errors which are caused by

users, recoverable)• Error(internal errors, non-recoverable)

• Exceptions are of 2 types:Checked (Checked by the compiler for smooth

execution of the program at run-time)Eg: IOException, FileNotFoundException, etc.Unchecked (Not checked by the compiler)Eg: ArithmeticException, NullPointerException, ArrayIndexOutofBoundsException, etc.

• Object

Exception Error

Throwable

RuntimeException IOException

ArithmeticException

NullPointerException

FileNotFoundException

Unchecked Exceptions

Checked Exceptions

• Exception related keywords:– try (to maintain risky code)– catch (to catch the exceptions)– finally (to maintain clean-up code)– throw (to modify or create own exception

and handover it to the JVM)– throws (for handling checked

exceptions)

Eg:class ExcDemo{

public static void main(String[] args){try{System.out.println(“Hello”);System.out.println(10/0);System.out.println(“Bye”);}catch(ArithmeticException e){System.out.println(e);}finally{System.out.println(“Finally block”);}}

}

• “try” with multiple “catch” blocks combination is also possible. The order of “catch” blocks should be from child exception to parent exception.

Eg:class ExcDemo{public static void main(String[] args){try{System.out.println("Welcome");System.out.println(15/0);System.out.println("Good bye");}

catch(ArithmeticException e) {System.out.println(e);}catch(Exception e){System.out.println(e);}}}

“throw” keyword:• To handover our own created exception object to the

JVM explicitly.Eg:class ThrowDemo{

public static void main(String[] args){throw new ArithmeticException(“Arithmetic exception”);}

}

“throws” keyword:• If there is any chance of occurring checked exception, we need to handle

it manually. This can be done in 2 ways:– Using try-catch (or)– Using “throws” keyword. The purpose of “throws” keyword is to delegate the responsibility of

exception handling to the caller.Eg:class ThrowsDemo{

public static void main(String[] args){Thread.sleep(2000);System.out.println(“Slept happily”);}

}

Customized exceptions: Eg:class LessMarksException extends RuntimeException{

LessMarksException(String s){super(s);}

}class GoodMarksException extends RuntimeException{

GoodMarksException(String s){super(s);}

}

class CustExceptionDemo{

public static void main(String[] args){int marks=Integer.parseInt(args[0]);if(marks<50){throw new LessMarksException("Poor marks");}else if(marks>80){throw new GoodMarksException("Good marks");}else{System.out.println("Average score");}}

}

Multithreading

•

• Performing several activities simultaneously(multitasking).

• Thread based multitasking• Each task is separate independent task of the same

program.• Each task is called a thread.• Applicable at programmatic level.

• Thread is a light weight process.• The main objective of multitasking is to reduce

response time of the system.• Java provides in-built support for

multithreading.

Runnable

Thread

MyThread MyRunnable

• Implementation of multithreading can be done in 2 ways:– By extending Thread class:Eg:

Class MyThread extends Thread{public void run(){for(int i=0;i<4;i++){System.out.println(“child thread”);}}}

Job of the

thread

Defining a thread

Class ThreadDemo{

public static void main(String[] args) // Main thread{MyThread t=new MyThread(); // Instatiation of threadt.start(); // Starting child threadfor(int i=0;i<4;i++){System.out.println(“Main thread”);}}

}

• By implementing Runnable interface:Class MyRunnable implements Runnable{

public void run(){

for(int i=0;i<4;i++){System.out.println(“Child thread”);}

}}

JobDefining

Class ThreadDemo{

public static void main(String[] args){MyRunnable r=new MyRunnable();Thread t=new Thread(r);t.start();for(int i=0;i<4;i++){System.out.println(“Main thread”);}}

}

Target runnable

• The purpose of ThreadScheduler is to get the opportunity for execution when multiple threads are awaiting.

ThreadScheduler

Main threadChild thread

Thread life cycle:

New/ Born

Ready/ Runnable

RunningDead

MyThread t=new MyThread();

t.start()

If ThreadScheduler allocated CPU

If run() completes

Waiting state

wait()

when wait() completes

Thread synchronization:• This can be done by using “synchronized”

keyword.• “synchronized” keyword is applicable for

methods and blocks.• If a method (or) block is declared as

“synchronized”, then at a time only one thread is allowed to execute.

• Advantage of “synchronized” is to avoid data inconsistency problems.

Declaration:[modifier] synchronized return-type method-

name([parameters]){Logic for synchronized method;}Eg:public synchronzied void access(){System.out.println(“Only one thread can be accessed”);}

Eg:class TestSync implements Runnable{int balance;public synchronized void run() //synchronized method{for(int i=0;i<5;i++){increment();System.out.println("Bal is:"+balance);}}public void increment(){int i=balance;balance=i+1;}}

class SyncDemo{public static void main(String[] args){TestSync t=new TestSync();Thread a=new Thread(t);Thread b=new Thread(t);a.start();b.start();}}

Methods for preventing thread from execution: yield() (to cause current thread to pause

and to give chance for remaining threads of same priority)

join() (to make the thread to wait for the completion of other thread)

sleep() (for making a thread to sleep for specified number of milli-seconds)

Program for yield():class MyThread extends Thread{public void run(){for(int i=0;i<5;i++){Thread.yield();System.out.println("child");}}}

class YieldDemo {public static void main(String[] args){MyThread t=new MyThread();t.start();for(int i=0;i<5;i++){System.out.println("main");}}}

Thread interruption:• One thread can interrupt another thread by using interrupt().Eg:class MyThread extends Thread{public void run(){try{for(int i=0;i<20;i++){System.out.println("lazy");}Thread.sleep(5000);}catch(InterruptedException e){System.out.println("got interrupted");}}}

class InterruptDemo{public static void main(String[] args){MyThread t=new MyThread();t.start();t.interrupt();System.out.println("active");}}

Garbage collection

•

• In old languages like C++, the programmer is responsible for the creation and destruction of objects.

• In Java, programmer is only responsible for the creation of objects. Object destruction is not required.

• Sun introduced one assistant which is running in background for the destruction of useless objects which is called garbage collector.

• We can request JVM to run garbage collector in 2 ways:– By System class (using gc())– By Runtime class

• In Runtime object, we can use the following methods:– freeMemory() Returns free memory available

in the heap.– totalMemory() Returns total memory of the

heap– gc() For requesting JVM to run

garbage collector• Before destroying any object, GC always calls finalize()

which is present in Object class. The object which is eligible for GC, the corresponding finalize() will be executed.

• When calling gc(), it may not be impacted immediately.

Eg:class RuntimeDemo{public static void main(String[] args){Runtime r=Runtime.getRuntime();System.out.println(r.totalMemory());System.out.println(r.freeMemory());for(int i=0;i<500;i++){java.lang.String d=new java.lang.String();d=null;}System.out.println(r.freeMemory());r.gc();System.out.println(r.freeMemory());}}

Eg:class Test{public static void main(String[] args){//String s=new String("hello");//s=null;Test t=new Test();t=null;System.gc();System.out.println("End of main");}public void finalize(){System.out.println("Finalize called");}}

For String class finalize()

Collections

•

• Array is indexed collection of fixed number of homogeneous elements. Limitations of arrays are:– Fixed in size,– Can hold only homogeneous data elements.– Underlying data structure not available.

• To overcome the above limitations, we can go for Collection.

• To use the properties of Collection, we need to import a package named with java.utilCollections are growable in nature.Can hold homogeneous and heterogeneous elements.Underlying data structures are available.

Collection hierarchy: Collection

List Set

HashSetArrayList LinkedList SortedSet

Map

HashMap Hashtable

Collection interface:• If we want to represent a group of individual objects

as single entity, then we can use Collection.• Few methods available in Collection interface:– boolean add(Object o);– boolean addAll(Collection c);– boolean remove(Object o);– boolean isEmpty();– int size();

ArrayList class:• Underlying data structure is resizable (or) growable array.• Insertion order is preserved.• Duplicate objects are allowed.• Heterogeneous objects are allowed.• “null” insertion is possible. Best suitable if our frequent operation is retrieval. ArrayList implements RandomAccess interface.Constructors:ArrayList(): Creates empty ArrayList object with default capacity

10. If max. capacity is reached, new capacity =currentcapacity*(3/2)+1

ArrayList(int size): Empty ArrayList object with specified capacity will be created.

ArrayList(Collection c): Creates an equivalent ArrayList object for c.

Eg:import java.util.*;class ALDemo{public static void main(String[] args){ArrayList sampleList=new ArrayList();l.add("A");l.add(10);l.add("A");l.add(null);System.out.println(sampleList);l.remove(2);l.add(1,"B");System.out.println(sampleList);l.add(0);System.out.println(sampleList);}}

HashSet class:• Underlying data structure is Hashtable.• Insertion order is not preserved.• Duplicate objects are not allowed.• Heterogeneous objects are allowed.• “null” insertion is possible, but only once.Best suitable if our frequent operation is

search.HashSet implements Serializable and

Cloneable interfaces.

Eg:import java.util.*;class HSDemo{public static void main(String[] args){HashSet sampleSet=new HashSet();h.add("B");h.add("A");h.add("Z");h.add(null);h.add(10);System.out.println(sampleSet);}}

Hashtable class:• Underlying data structure is Hashtable.• Heterogeneous objects are allowed.• Insertion order is not preserved and it is based

on hashCode.• “null” insertion is not allowed.

Eg:import java.util.*;class HtDemo{public static void main(String[] args){Hashtable h=new Hashtable();h.put(new Temp(5),"A");h.put(new Temp(2),"B");h.put(new Temp(6),"C");h.put(new Temp(15),"D");h.put(new Temp(23),"E");h.put(new Temp(16),"F");System.out.println(h);}}

6=C

5=A, 16=F

15=D

2=B

23=E

0

1

2

3

4

5

6

7

8

9

10

class Temp{int i;Temp(int i){this.i=i;}public String toString(){return i+"";}public int hashCode(){return i;}}

Thank you