Chapter-1

Core Java

1.1 INTRODUCTION TO JAVA

Java is a general-purpose Object Oriented programming language developed by Sun

Microsystems of USA in 1991.Originally called Oak by James Gosling, one of the

inventors of Java.

1.1.1 Java features:

 Compiled and Interpreted

 Platform independent and portable

 Object Oriented

 Robust and Secure

 Distributed

 Familiar, Simple and small

 Multithreaded and Interactive

 High Performance

 Dynamic and Extensible

1.1.2 Java Environment:

Java environment include a large number of development tools and hundreds of classes

and methods.
The development tools are part of the system known as Java Development Kit(JDK) and

the classes and methods are part of Java Standard Library(JSL),also known as the

application Programming Interface(API).

Java Development Kit (JDK):

The Java Development Kit comes with a collection of tools that are used for developing

and running Java programs. They include

 appletviewer (for viewing Java applet)

 javac(Java Compiler)

 java(Java Interpreter)

 jdb(Java debugger)

 javadoc(for creating HTML documents)

 javah(for C header file)

Application Programming Interface(API):

The java standard library or API includes hundred of classes and methods grouped into

several functional packages, most common packages are

Language support package(java.lang.*)

Utilities package(java.util.*)

Input/Output package(java.io.*)

Networking package(java.net.*)

Databases package(java.sql.*)
1.1.3 Process of Building & running java application program:
 Text editor

java source code javadoc HTML file

javac

java class file javah header file

java jdb

java program output

 Fig.1.1:Program development process

1.1.4 Types of java program:

Java program can be developed in two ways as follows

 stand alone application

 web applets

Stand alone application can be executed by java interpreter and we applets can be

executed by java enabled web browser for example internet explorer.

Format of Java program:

class classname

public static void main(String args[ ])

System.out.println (“java is better than C++”);

1.1.5 Java Virtual Machine (JVM):

Java compiler produces an intermediate code known as byte code for a machine that does

not exist. This machine is called the java virtual machine(JVM) and it exists only inside

the computer memory.

It is a simulated computer and does all major functions of a real computer.

Process of Compilation:
 java source code java compiler byte code

Virtual machine

Process of converting byte code into machine code:

byte code java interpreter machine code

real machine

The virtual machine code is not machine specific.

1.2 DATA TYPES IN JAVA

Data type specify the size and type of values that can be stored. Every variable in java has

a data type.

Data type can be divided into two types as follows

 primitive data type

 non-primitive data

Primitive data type can be divided into two types as follows

 Numeric

 Non Numeric

Numeric is divided into integer and floating point.

Integer is divided into byte, short, int, long

Floating point is divided into float and double.

Non-numeric can be divided into char(character) and Boolean.

Non-primitive data type can be divided into 3 types as follows

  classes

 interfaces

 arrays

Different types can be described in table as follows:

Table 1.1.Data Type

Data Type Size Minimum value Maximum value

byte 1 byte -128 127

short 2 byte -32,768 32,767

int 4 byte -2,147,483,648 2,147,483,647

long 8 byte

float 4 byte 3.4e-038 3.4e+038

double 8 byte 1.7e-308 1.7e+308

char 2 byte

boolean 1 bit

1.3 VARIABLE

A variable is an identifier that denotes a storage location used to store a data value. A

variable may take different values at different times during the execution of the program.
Variable names may consist of alphabets, digits, underscore (_) and dollar character,

Subject to the following conditions:

 They must not begin with a digit.

 Upper case and lower case are distinct.

 It should not be a keyword.

 White space is not allowed.

 Variable names can be of any length.

1.4 OPERATORS

They are used to manipulate primitive data types. Java operators can be classified as
unary, binary, or ternary—meaning taking one, two, or three arguments, respectively.
A unary operator may appear before (prefix) its argument or after (postfix) its argument.
A binary or ternary operator appears between its arguments.
Java operators fall into eight different categories:
Assignment arithmetic, relational, logical, bitwise,
compound assignment, conditional, and type.
Assignment Operators =
Arithmetic Operators - + * / % ++ --

Relational Operators > < >= <= == !=

Logical Operators && || & | ! ^

Bit wise Operator & | ^ >> >>>

Compound Assignment Operators += -= *= /= %=

<<= >>= >>>=

Conditional Operator ?:

1.5 ARRAYS
An array is a group of homogeneous data items share a common name. The java array

enables the user to store the values of the same type in contiguous memory allocations.

Arrays are always a fixed length abstracted data structure which can not be altered when

required.

The Array class implicitly extends java.lang.Object so an array is an instance of Object.

Advantages of Java Array:

1. An array can hold primitive types data.

2. An array has its size that is known as array length.
3. An array knows only its type that it contains. Array type is checked at the
compile-time.

Disadvantages of Java Array:

1. An array has fixed size.

2. An array holds only one type of data (including primitive types).

Declaring an array:

Declaring an array is the same as declaring a normal variable except that you must put a

set of square brackets after the variable type. Here is an example of how to declare an

array of integers called a.

public class Array

{
public static void main(String[] args)
{
int[] a;
}
}

An array is more complex than a normal variable so we have to assign memory to the

array when we declare it. When you assign memory to an array you also set its size. Here

is an example of how to create an array that has 5 elements.

public class Array
{
public static void main(String[] args)
{
int[] a = new int[5];
}
}

Instead of assigning memory to the array you can assign values to it instead. This is
called initializing the array because it is giving the array initial values.

public class Array

{
public static void main(String[] args)
{
int[] a = {12, 23, 34, 45, 56};
}
}

Using an array:

You can access the values in an array using the number of the element you want to access

between square brackets after the array's name. There is one important thing you must

remember about arrays which is they always start at 0 and not 1. Here is an example of

how to set the values for an array of 5 elements.

public class Array

{
public static void main(String[] args)
{
int[] a = new int[5];
a[0] = 12;
a[1] = 23;
a[2] = 34;
a[3] = 45;
a[4] = 56;
}
}
A much more useful way of using an array is in a loop. Here is an example of how to use

a loop to set all the values of an array to 0 which you will see is much easier than setting

all the values to 0 seperately.

public class Array

{
public static void main(String[] args)
{
int[] a = new int[5];
for (int i = 0; i < 5; i++)
a[i] = 0;
}
}

Sorting an array

Sometimes you will want to sort the elements of an array so that they go from the lowest

value to the highest value or the other way around. To do this we must use the bubble

sort. A bubble sort uses an outer loop to go from the last element of the array to the first

and an inner loop which goes from the first to the last. Each value is compared inside the

inner loop against the value in front of it in the array and if it is greater than that value

then it is swapped. Here is an example.

public class Array

{
public static void main(String[] args)
{
int[] a = {3, 5, 1, 2, 4};
int i, j, temp;
for (i = 4; i >= 0; i--)
for (j = 0; j < i; j++)
if (a[j] > a[j + 1])
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
 }
}

2D arrays:

So far we have been using 1-dimensional or 1D arrays. A 2D array can have values that

go not only down but also across. Here are some pictures that will explain the difference

between the 2 in a better way.

All that you need to do to create and use a 2D array is use 2 square brackets instead of 1.

public class Array

{
public static void main(String[] args)
{
int[][] a = new int[3][3];
a[0][0] = 1;
}
}

1.6 CONTROL STATEMENTS

Java Control statements control the order of execution in a java program, based on data

values and conditional logic. There are three main categories of control flow statements;

Selection statements: if, if-else and switch.

Loop statements: while, do-while and for.

Transfer statements: break, continue, return, try-catch-finally and assert.

We use control statements when we want to change the default sequential order of
execution

1.6.1 Selection Statements

The If Statement
The if statement executes a block of code only if the specified expression is true. If the

value is false, then the if block is skipped and execution continues with the rest of the

program. You can either have a single statement or a block of code within an if statement.

Note that the conditional expression must be a Boolean expression.

The simple if statement has the following syntax:

if (<conditional expression>)
<statement action>

The If-else Statement

The if/else statement is an extension of the if statement. If the statements in the if

statement fails, the statements in the else block are executed. You can either have a single

statement or a block of code within if-else blocks. Note that the conditional expression

must be a Boolean expression.

The if-else statement has the following syntax:

if (<conditional expression>)
<statement action>
else
<statement action>

Switch Case Statement

The switch case statement, also called a case statement is a multi-way branch with

several choices. A switch is easier to implement than a series of if/else statements. The

switch statement begins with a keyword, followed by an expression that equates to a no

long integral value. Following the controlling expression is a code block that contains

zero or more labeled cases. Each label must equate to an integer constant and each must

be unique. When the switch statement executes, it compares the value of the controlling
expression to the values of each case label. The program will select the value of the case

label that equals the value of the controlling expression and branch down that path to the

end of the code block. If none of the case label values match, then none of the codes

within the switch statement code block will be executed. Java includes a default label to

use in cases where there are no matches. We can have a nested switch within a case block

of an outer switch.

Its general form is as follows:

switch (<non-long integral expression>) {

case label1: <statement1>
case label2: <statement2>
...
case labeln: <statementn>
default: <statement>
} // end switch

When executing a switch statement, the program falls through to the next case.

Therefore, if you want to exit in the middle of the switch statement code block, you must

insert a break statement, which causes the program to continue executing after the current

code block.

1.6.2 Iteration Statements

While Statement

The while statement is a looping construct control statement that executes a block of code

while a condition is true. You can either have a single statement or a block of code within

the while loop. The loop will never be executed if the testing expression evaluates to

false. The loop condition must be a boolean expression.

The syntax of the while loop is

while (<loop condition>)

<statements>

Do-while Loop Statement

The do-while loop is similar to the while loop, except that the test is performed at the end

of the loop instead of at the beginning. This ensures that the loop will be executed at least

once. A do-while loop begins with the keyword do, followed by the statements that make

up the body of the loop. Finally, the keyword while and the test expression completes the

do-while loop. When the loop condition becomes false, the loop is terminated and

execution continues with the statement immediately following the loop. You can either

have a single statement or a block of code within the do-while loop.

The syntax of the do-while loop is

do
<loop body>
while (<loop condition>);

Below is an example that creates A Fibonacci sequence controlled by a do-while

loop

public class Fibonacci {

public static void main(String args[]) {

System.out.println("Printing Limited set of Fibonacci Sequence");
double fib1 = 0;
double fib2 = 1;
double temp = 0;
System.out.println(fib1);
System.out.println(fib2);
do {
temp = fib1 + fib2;
System.out.println(temp);
fib1 = fib2; //Replace 2nd with first number
 fib2 = temp; //Replace temp number with 2nd number
} while (fib2 < 5000);
}

For Loops

The for loop is a looping construct which can execute a set of instructions a specified
number of times. It’s a counter controlled loop.

The syntax of the loop is as follows:

for (<initialization>; <loop condition>; <increment expression>)

<loop body>

The first part of a for statement is a starting initialization, which executes once before the

loop begins. The <initialization> section can also be a comma-separated list of expression

statements. The second part of a for statement is a test expression. As long as the

expression is true, the loop will continue. If this expression is evaluated as false the first

time, the loop will never be executed. The third part of the for statement is the body of

the loop. These are the instructions that are repeated each time the program executes the

loop. The final part of the for statement is an increment expression that automatically

executes after each repetition of the loop body. Typically, this statement changes the

value of the counter, which is then tested to see if the loop should continue.

All the sections in the for-header are optional. Any one of them can be left empty, but the

two semicolons are mandatory. In particular, leaving out the <loop condition> signifies

that the loop condition is true. The (;;) form of for loop is commonly used to construct an

infinite loop.

1.7 CLASSES
A class is nothing but a blueprint or a template for creating different objects which

defines its properties and behaviors. Java class objects exhibit the properties and

behaviors defined by its class. A class can contain fields and methods to describe the

behavior of an object.

A class has the following general syntax:

<class modifiers>class<class name>

<extends clause> <implements clause>{

// Dealing with Classes (Class body)

<field declarations (Static and Non-Static)>

<method declarations (Static and Non-Static)>

<Inner class declarations>

<nested interface declarations>

<constructor declarations>

<Static initializer blocks>

Below is an example showing the Objects and Classes of the Cube class that defines 3

fields namely length, breadth and height. Also the class contains a member function

getVolume().

public class Cube {

int length;
 int breadth;

int height;

public int getVolume() {

return (length * breadth * height);

1.8 METHODS

Methods are nothing but members of a class that provide a service for an object or

perform some business logic. Java fields and member functions names are case sensitive.

Current states of a class's corresponding object are stored in the object's instance

variables. Methods define the operations that can be performed in java programming.

A method has the following general syantax:

return type method-name( arguments )

// code statements

1.9 INHERITANCE:

Java Inheritance defines an is-a relationship between a superclass and its subclasses. This

means that an object of a subclass can be used wherever an object of the superclass can
be used. Class Inheritance in java mechanism is used to build new classes from existing

classes. The inheritance relationship is transitive: if class x extends class y, then a class z,

which extends class x, will also inherit from class y.

The mechanism of deriving a new class from an old class is called inheritance.

The inheritance allows subclasses to inherit all the variables and methods of their parent
classes.

Defining a Sub-class:

A sub-class is defined as follows:

class sub-class-name extends super-class-name

variables declarations;

methods declarations;

The keyword extends signifies that the properties of the super-class-name are extended to
the sub-class-name.

Types of inheritance:

 Single inheritance (only one super-class)

 Multiple inheritance (several super-class)

 Hierarchical inheritance (one super class, many subclasses)

 Multilevel inheritance (derived from a derived class)

Single inheritance:
It is an inheritance in which there is one super-class and one sub-class.

Example:

class room

int length;

int breadth;

room(int x,int y)

length=x;

breadth=y;

int area( )

return (length * breadth);

class bedroom extends room

{

int height;

bedroom(int x,int y,int z)

super(x,y);

height=z;

int volume( )

return( length * breadth * height);

class inhertest

public static void main(String args[ ] )

bedroom room1=new bedroom(14,12,10);

int area1=room1.area( );

int volume1=room1.volume( );

System.out.println(area1);

System.out.println(volume1);

}
Multiple inheritance:

In this type more than one super-class having single sub-class derived.

A B

Hierarchical inheritance:

In this type one super-class is having more than one sub-class.

B C D

Multi-level inheritance:

In this type derived class is derived from a derived class.

C
1.10 EXCEPTION HANDLING

Definition: An exception is an event, which occurs during the execution of a program,

that disrupts the normal flow of the program's instructions.

The purpose of exception handling mechanism is to provide a means to detect and report

an exceptional circumstance so that appropriate action can be taken. The mechanism

suggests incorporation of a separate error handling code that performs the following

tasks.

Find the problem(Hit the exception)

Inform that an error has occurred(Throw the exception)

Receive the error information(catch the exception)

Take corrective actions(Handle the exception)

Diagram and Syntax of exception handling code:

try block
Statement that cause an exception
(Exception object creater)

Throws
exception object

Catch block
Statement that handle the exception
(Exception handler)

Fig.1.2
Syntax:

try

statement; //generates an exception

catch(Exception-type e)

statement; //processes the exception

Example:

class error1

public static void main(String args[ ])

int a = 10 ;

int b = 5 ;

int c =5 ;

int x , y;

try

x = a / (b-c) ; //Exception here

}
catch( ArithmaticException e )

System.out.println(“division by zero “);

y = a / (b+c);

System.out.println( “y = “ + y);

}}

Multiple catch statements :

try

statement ;

catch ( Exception-Type-1 e)

statement ;

catch ( Exception-Type-2 e)

statement ;

catch ( Exception-Type-N e)

statement;
}

Using Finally Statement

try try

{ {

statement ; statement;

} }

finally catch ( )

{ {

statement; statement

} }

catch( )

statement;

finally

{
 statements;

Throwing our own Exceptions

This can be done using keyword throw as follows:

throw new Throwable_subclass ;

Example :

import java.import.Exception;

class MyException extends Exception

MyEcxeption(String message)

super(message) ;

class TestMyException

public static void main(String args[])

int x=5,y=1000;

try

float z =(float) x / (float) y;

 if(z<0.01)

throw new MyException (“Number is too small”);

catch (MyException e)

System.out.println(“Caught my exception”);

System.out.println(e.getMessage());

finally

System.out.println(“I am always here”);

1.11 MULTITHREADING

Multithreading is a conceptual programming paradigm where a program ( process ) is

divided into two or more subprograms ( processes ), which can be implemented

concurrently. For example, one subprogram can display an animation on the screen while

another may build the next animation to be displayed. This is something similar to
dividing a task into subtasks and assigning them to different people for execution

independently and simultaneously.

class ABC Beginning

{

Single-Threaded
body of execution

End
}

Fig.1.3. Single-Threaded Program

Once initiated by the main thread, the threads A,B and C run concurrently and share the

resources jointly. It is like people living in joint families and sharing certain resources

among all of them. The ability of a language to support multithreads is referred to as

concurrency. Since threads in Java are subprograms of a main application program and
share the same memory space, they are known as lightweight threads or lightweight

processes.

Main Thread

Main Method
module

Start Start
Start

Thread A Thread B Thread C

Fig.1.4. Multi-Threaded Program

Thread States

Threads can be in one of four states:

● New

● Runnable

● Blocked

● Dead

Each of these states is explained in the sections that follow.

New Threads

When you create a thread with the new operatorfor example, new THRead(r)the thread is

not yet running.

This means that it is in the new state. When a thread is in the new state, the program has

not started

executing code inside of it. A certain amount of bookkeeping needs to be done before a
thread can run.

Runnable Threads

Once you invoke the start method, the thread is runnable. A runnable thread may or may

not actually be

running. It is up to the operating system to give the thread time to run. (The Java

specification does not

call this a separate state, though. A running thread is still in the runnable state.)

Blocked Threads

A thread enters the blocked state when one of the following actions occurs:
● The thread goes to sleep by calling the sleep method.

● The thread calls an operation that is blocking on input/output, that is, an operation that

will not

return to its caller until input and output operations are complete.

● The thread tries to acquire a lock that is currently held by another thread.

Fig 1.5.Life cycle of Thread

A thread moves out of the blocked state and back into the runnable state by one of the

following pathways.

Dead Threads
A thread is dead for one of two reasons:

● It dies a natural death because the run method exits normally.

● It dies abruptly because an uncaught exception terminates the run method.

In particular, you can kill a thread by invoking its stop method. That method throws a

ThreadDeath error

object that kills the thread. However, the stop method is deprecated, and you should not

call it in your own

Declaring a thread:

The thread class can be extended as follows:

class mythread extends Thread

…………..

………….

Implementing the run( ) method

public void run( )

………….

……………

Starting a new thread:

Mythread athread = new Mythread( );

athread.start( )
Example:

class A extends Thread

public void run( )

for ( int i=1 ; i< =5 ;I++)

System.out.println(“from thread A” + i);

System.out.println(:Exit from A”);

}}

class B extends Thread

public void run( )

for ( int i=1 ; i< =5 ;I++)

System.out.println(“from thread B” + i);

System.out.println(:Exit from B”);

}}

class C extends Thread

{
public void run( )

for ( int i=1 ; i< =5 ;I++)

System.out.println(“from thread C” + i);

System.out.println(:Exit from C”);

}}

class threadtest

public static void main(String args[ ])

new A( ).start( );

new B( ).start( );

new C( ).start( );

}}

1.12 COLLECTIONS:

Collection classes and interfaces provides mechanism to deal with collection of

objects.All collections classes imports java.util.* package.

The different concrete collection classes in java are as follows:

ArrayList:

It is an indexed sequence that grows and shrinks dynamically.

LinkedList:

An ordered sequence that allows efficient insertions and removal at any position.

HashSet:

It is an unordered collection that rejects duplicates.

TreeSet:

It is a sorted set.

HashMap:

It is a data structure that stores Key/value associations.

TreeMap:

It is a map in which keys are sorted.

Example to implement ArrayList:

Import java.util.*;

Public class arraylistdemo

Public static void main(String args[ ] )

ArrayList<Integer> a1 = new ArrayList<Integer> ( ) ;

a1.add(10 );

a1.add( 20);

a1.add( 30);

a1.add( 40);
System.out.println(“Array list %s ; size:%d” a1.tostring( ) , a1.size( ) );

a1.remove(new Integer(30) );

a1.remove(0);

System.out.println(“Array list %s ; size:%d” a1.tostring( ) , a1.size( ) );

1.13 I/O STREAMS

A stream in java is a path along which data flows.It has a source and a destination.

Input Stream reads the data from source and pass the data to program.

Output Stream writes the data from program to destination.

Java Stream Classes:

Java stream classes is divided into two types

1. Byte Stream classes

2. Character stream classes

Byte stream classes:

Byte stream classes have been designed to provide functional features for creating and

manipulating streams and files for reading and writing bytes.

Byte stream classes is divided into two types

1. InputStream classes

2. OutputStream classes
Different InputStream classes are

FileInputStream

DataInputStream

ObjectInputStream

BufferedInputStream

Different output Streams classes are

FileOutputStream

DataOutputStream

ObjectOutputStream

BufferedoutputStream

Character stream classes is divided into two types

1. Reader classes

2. Writer classes

Program to display contents of a file:

Import java.io*;

Public class typefile

Public static void main(String args[ ] ) throws IOException

int i ;

FileInputStream fin;

Try

{
Fin =new FileInputStream(args[ 0] );

Catch( FileNotFoundException e )

System.out.println(“file not found”);

Return;

Catch(ArrayIndexOutOfBoundException e)

System.out.println(“java filename”);

Return;

While(I =fin.read( ) ) ! = -1)

System.out.print( (char)i);

Fin.close( );

1.14 ABSTRACT WINDOWS TOOLKIT

Abstract windows toolkit contains all the classes for creating user interfaces and for

painting graphics and images.

A user interface object such as button or a scrollbar is called in AWT terminology , a

component.
Component class is the root of all AWT components.

The different component classes are

Button

Label

TextField

Checkbox

Combobox

GridLayout

TextArea

Scrolbar

Program to describe Label , TextField and Button:

Import java.awt.*;

Import java.awt.event.*;

Import java.applet.*;

/* <Applet code = “temp.class” width=200 height=200> */

Public class temp extends Applet implements ActionListener

TextField tc,tf;

Button cal;

Public void init( )

Label lc = new Label( “ enter celcius “ Label.LEFT);

Label lf = new Label( “ Farhenhit is “ Label.LEFT);

tc= new TextField(5);

tf=new TextField(5);

tc.setText(“0”);

tf.setText(“0”);

cal=new Button(“calculate”);

add(lc);

add(tc);

add(lf);

add(tf);

add(cal);

cal.addActionListener(this);

Public void actionPerformed(ActionEvent ae)

If(ae.getSource( ) = = cal)

Double cel=Double.parseDouble(tc.getText( ) );

Tf.setText( String.valueOf(9.0/5/0*cel+32.0) );

}
1.15 APPLET PROGRAMMING

Applets are small java programs that are primarily used in internet programming. They

can be transported over the internet from one computer to another and run using the

Applet viewer or any web browser that supports Java.

Applet does not contain main() method.

Format of Applet program:

Import java.awt.*;

Import java.applet.*;

Public class appletclassname extends Applet

………………..

………………..

Public void paint(Graphics g)

………………..//Appletsoperations code
…………………

Applet Life cycle:

The different states of applet life cycles are

Born state or initialization state

Running state

Idle state

Dead state

Initialization state:

Applet enters initialization state when it is first loaded

Init( ) function is used.

Syntax

Public void init( )

…………//Action

……………..

Running State:

Applet enters running state when the system calls the start method.

Syntax

Public void start( )

{
…………………….//Action

…………………….

Idle or stopped state:

An applet becomes idle when it is stopped from running.

Syntax

Public void stop( )

……………….//action

……………….

Dead state:

An applet is said to be dead when it is removed from memory.

Syntax

Public void destroy( )

………………//Action

……………….

}
1.16.QUESTIONS AND SOLUTIONS FROM PREVIOUS UNIVERSITY EXAMS

Q1.What is multithreading? Explain the life cycle of a thread.

SOLUTION:

Multithreading is a conceptual programming paradigm where a program ( process ) is

divided into two or more subprograms ( processes ), which can be implemented

concurrently. For example, one subprogram can display an animation on the screen while

another may build the next animation to be displayed. This is something similar to

dividing a task into subtasks and assigning them to different people for execution

independently and simultaneously.

class ABC
{ Beginning

Single-Threaded
body of execution

End

}
 Single-Threaded Program

Once initiated by the main thread, the threads A,B and C run concurrently and share the

resources jointly. It is like people living in joint families and sharing certain resources

among all of them. The ability of a language to support multithreads is referred to as

concurrency. Since threads in Java are subprograms of a main application program and

share the same memory space, they are known as lightweight threads or lightweight

processes.

Main Thread

Main Method
module

Start Start
Start

Thread A Thread B Thread C

Multi-Threaded Program

Life cycle of a Thread :

Life cycle of a Thread can have four states:

● New

● Runnable

● Blocked

● Dead

Diagram for Life cycle of a thread:

New state of Thread:

When you create a thread with the new operator for example, new Thread( ) the thread is

not yet running. This means that it is in the new state. When a thread is in the new state,

the program has not started executing code inside of it. A certain amount of bookkeeping

needs to be done before a thread can run.

Runnable state of a Thread:

Once you invoke the start method, the thread is runnable. A runnable thread may or may

not actually be running. It is up to the operating system to give the thread time to run.

Blocked state of a Thread

A thread enters the blocked state when one of the following actions occurs:

● The thread goes to sleep by calling the sleep method.

● The thread calls an operation that is blocking on input/output, that is, an operation that

will not return to its caller until input and output operations are complete.

● The thread tries to acquire a lock that is currently held by another thread. We discuss

locks on page.

A thread moves out of the blocked state and back into the runnable state by one of the
following pathways.

Dead state of a Thread:

A thread is dead for one of two reasons:

● It dies a natural death because the run method exits normally.

● It dies abruptly because an uncaught exception terminates the run method.

In particular, you can kill a thread by invoking its stop method. That method throws a

ThreadDeath error object that kills the thread.

Q2.Write a program to create a user defined Exception called “No Match xception”
that throws an arbitrary message when a string is not equal to “INDIA”.

SOLUTION:

import java.import.Exception;

class NoMatchException extends Exception

NoMatchException(String message)

super(message) ;

class TestNoMatchException

public static void main(String args[])

String m;

Scanner s=new Scanner(System.in);

System.out.println(“enter a string”);

m=s.next( );

try

If(m!=”INDIA”)

{
 throw new NoMatchException (“String is not india”);

catch (NoMatchException e)

System.out.println(“Caught NoMatchException”);

System.out.println(e.getMessage());

} } }

Q3.What are applets ? Explain their usage. How are they different from java

programs.

SOLUTION:

Applets are small java programs that are primarily used in internet programming. They

can be transported over the internet from one computer to another and run using the

Applet viewer or any web browser that supports Java. Applet does not contain main()

method.

Usage of Applet:

Applets
---Javacanapplets
be usedare
for small
internetjava
programming.----Java programs are programs
program used in internet used for applications
It can be used to extend the capabilities of html web-pages.
programming by embedding development.
inside html
Difference documents.
between java applet and Java programs:

---Java applets are embedded --Java programs cannot

inside html document and embedded inside html document.
enhance capabilities of html
webpages

--Java applets cannot have main() --Java programs must have main
method. () method.

--Java applets can only be ---Java programs can be

executed in web browser or executed by java interpreter.
appletviewer.
Q.4. What is an interface ? Explain with a suitable example. How multiple

Inheritance is implemented in java.

SOLUTION:

Interface is a class which consists of constant variables and undefined methods. Interface
can be treated as templates used by different classes by inherit the interface. Interface
cant create any objects. It is only used by other classes those inherit it. Interface can be
used to implement multiple inheritances.
Syntax of Interface:

Interface interface-name
{
//Final or constant variables;
//Undefined methods;
}
Example of Interface:
Interface product
{
Final int productno;
Public void getdescription( );
}
Using interface for multiple inheritance:
Interface is used to implement multiple inheritances by inheriting a class from multiple
interfaces as below.
Interface A Interface B

Class C

Example of interface to implement multiple inheritance:

Interface A
{
Final Int a;
Void getdata();
}
Interface B
{
Final int b;
Void putdata();
}
Class C implements A , B
{
Int c;
Void getdata()
{
a=4;
System.out.println(a);
}
Void putdata()
{
b=5;
System.out.println(b);
}}
Class test
{
Public static void main(String args[]) {
test t1;
t1.getdata();
t1.putdata(); } }
Q.5. Why is java more suitable as compared to other language.

SOLUTION:

Java is more suitable as compared to other languages because of the following features

 Platform independent and portable

 Object Oriented

 Robust and Secure

 Distributed

 Familiar, Simple and small

 Multithreaded and Interactive

 High Performance

 Dynamic and Extensible

 Compiled and Interpreted

Platform independent and Portable

Java is platform independent because of byte code which can be interpreted by any

system. Because of platform independent java is portable.

Object Oriented:
Java is purely object oriented programming language.Data hiding,

encapsulation,polymorphism,inheritance properties are present.

Robust and Secure:

Java is robust because Java works as usual when any extension is made in java.Java is

secure because of its byte code and case sensitiveness.

Familiar, Simple and small

Java is easy to understandable ,small and familier.

Multithreaded and Interactive:

Java support multithreading because in java different parts of a program can execute

concurrently.

Dynamic and Extensible

Java works dynamically and can be easily extensible.

Q.6. What do you mean by byte code .Explain its working..

SOLUTION:

Byte code is a code formed by compiler in java having .class extension

Java bytecode is the form of instructions that the Java virtual machine executes. Each
byte code opcode is one byte in length, although some require parameters, resulting in
some multi-byte instructions.

To understand the details of the bytecode, we need to discuss how a Java Virtual Machine
(JVM) works regarding the execution of the bytecode.

A JVM is a stack-based machine. Each thread has a JVM stack which stores frames. A
frame is created each time a method is invoked, and consists of an operand stack, an array
of local variables, and a reference to the runtime constant pool of the class of the current
method. Conceptually, it might look like this:

Figure . A frame

The array of local variables, also called the local variable table, contains the parameters
of the method and is also used to hold the values of the local variables. The parameters
are stored first, beginning at index 0. If the frame is for a constructor or an instance
method, the reference is stored at location 0. Then location 1 contains the first formal
parameter, location 2 the second, and so on. For a static method, the first formal method
parameter is stored in location 0, the second in location 1, and so on.
Q.7.How is platform independent feature of java implemented. Explain role of main
( ) method in execution of java program.

SOLUTION:

Java is platform independent because of its byte code creation by compiler that is handled
by Java Virtual Machine.

Byte code is of .class extension and that can be executed by any platform by their own
interpreter.

Diagram for platform independence:

Java Source file(.java file)

Byte code (.class file)

Windows system Unix system Solaris system

(having JVM) (having JVM) (having JVM)

Windows Unix interpreter Solaris interpreter

interpreter

Exe file Exe file Exe file

Role of main() method:

Main( ) method is a static method that can automatically called without use of any objects
creation.

Main () method is the first method executed by CPU after that any methods are executed.
All objects are created inside the main( ) method and methods are called inside main( )
method.

Without main ( ) method no program is created in java application.

Q.7.Why exceptional errors occurs during execution of program. Discuss usage of

finally block.

SOLUTION:

Exceptional errors occurs during execution of program because in the time of program
execution some unusual condition occurs and disrupts the normal flow of execution.

such as a number division by zero, file not found , array index out of bound , arithmetic
exception etc.

An exception is an event, which occurs during the execution of a program, that disrupts

the normal flow of the program's instructions.

The purpose of exception handling mechanism is to provide a means to detect and report

an exceptional circumstance so that appropriate action can be taken. The mechanism

suggests incorporation of a separate error handling code that performs the following

tasks.

Find the problem(Hit the exception)

Inform that an error has occurred(Throw the exception)

Receive the error information(catch the exception)

Take corrective actions(Handle the exception)

Diagram and Syntax of exception handling code:

try block
Statement that cause an exception
(Exception object creater)

Throws
exception object

Catch block
Statement that handle the exception
(Exception handler)

Usage of finally block.

Finally is a keyword used in exception handling mechanism? Finally is

Written after try and catch statement .The statements written inside finally is must
execute whether there is exception found or not.
Syntax of Finally Statement

try try
{ {
statement ; statement;
} }
finally catch ( )
{ {
statement; statement }
Finally {
} Statement