JAV

A
 What is java?

• Developed by Sun Microsystems (James Gosling)

• A general-purpose object-oriented language

• Based on C/C++

• Designed for easy Web/Internet applications

• Widespread acceptance
 Java Features (1)
• Simple
– fixes some clumsy features of C++
– no pointers
– automatic garbage collection
– rich pre-defined class library http://java.sun.com/j2se/1.4.2/docs/api/
• Object oriented
– focus on the data (objects) and methods manipulating the data
– all functions are associated with objects
– almost all datatypes are objects (files, strings, etc.)
– potentially better code organization and reuse
 Java Features (2)
• Interpreted
– java compiler generate byte-codes, not native machine code
– the compiled byte-codes are platform-independent
– java bytecodes are translated on the fly to machine readable
instructions in runtime (Java Virtual Machine)
• Portable
– same application runs on all platforms
– the sizes of the primitive data types are always the same
– the libraries define portable interfaces
 Java Features (3)
• Reliable
– extensive compile-time and runtime error checking
– no pointers but real arrays. Memory corruptions or unauthorized
memory accesses are impossible
– automatic garbage collection tracks objects usage over time

• Secure
– usage in networked environments requires more security
– memory allocation model is a major defense
– access restrictions are forced (private, public)
 Java Features (4)
• Multithreaded
– multiple concurrent threads of executions can run simultaneously
– utilizes a sophisticated set of synchronization primitives (based
on monitors and condition variables paradigm) to achieve this
• Dynamic
– java is designed to adapt to evolving environment
– libraries can freely add new methods and instance variables
without any effect on their clients
– interfaces promote flexibility and reusability in code by specifying
a set of methods an object can perform, but leaves open how
these methods should be implemented
– can check the class type in runtime
 Java Disadvantages

• Slower than compiled language such as C

– an experiment in 1999 showed that Java was 3 or 4 times slower
than C or C++
title of the article: “Comparing Java vs. C/C++ Efficiency Issues to
Interpersonal Issues” (Lutz Prechelt)
– adequate for all but the most time-intensive programs
 Getting Started: (1)
(1) Create the source file:
– open a text editor, type in the code which defines a class
(HelloWorldApp) and then save it in a file (HelloWorldApp.java)
– file and class name are case sensitive and must be matched
exactly (except the .java part)
Example Code: HelloWorldApp.java
/**
* The HelloWorldApp class implements an application
* that displays "Hello World!" to the standard output
*/
public class HelloWorldApp {
public static void main(String[] args) {
// Display "Hello World!"
System.out.println("Hello World!");
}
}

★ Java is CASE SENSITIVE!

 Getting Started: (2)
(2) Compile the program:
– compile HelloWorldApp.java by using the following command:

javac HelloWorldApp.java
it generates a file named HelloWorldApp.class

☹ ‘javac’ is not recognized as an internal or

external command, operable program or hatch file.
javac: Command not found
if you see one of these errors, you have two choices:
1) specify the full path in which the javac program locates every
time. For example:
C:\j2sdk1.4.2_09\bin\javac HelloWorldApp.java
2) set the PATH environment variable
 Getting Started: (3)

(3) Run the program:

– run the code through:
java HelloWorldApp
– Note that the command is java, not javac, and you refer to
HelloWorldApp, not HelloWorldApp.java or
HelloWorldApp.class

☹ Exception in thread "main" java.lang.NoClassDefFoundError:

HelloWorldApp
if you see this error, you may need to set the environment variable
CLASSPATH.
 Language basics (1)
• Data types
– 8 primitive types:
• boolean, byte, short, int, long, float, double, char
– Class types, either provided by Java, or made by programmers
• String, Integer, Array, Frame, Object, Person, Animal, …
– Array types
• Variables
– dataType identifier [ = Expression]:
– Example variable declarations and initializations:

int x; x=5; int[] intArray;

boolean b = true; intArray = new int[2];
Frame win = new intArray[0] = 12;
Frame(); intArray[1] = 6;
String x = “how are Person pArray = new Person[10];
you?”;
 Java Data Types

• Java has two kinds of types:

– fundamental, primitive or simple
– derived or composite
• No variable can be used until it is
defined.
• Java is a strongly typed language.
Java Primitive Data Types
Data Types, Default Values
• No variable can have
an undefined value.
– Instance or class variables
are implicitly initialized to a
standard default value.
– Local variables are not
implicitly initialized to a
default value and must be
explicitly initialized.
 Rules for naming an identifier
• An identifier can be up to 255 characters long.
• It must start with a letter, an underscore, or a
dollar sign.
• Use letters, dollar signs, underscores, or
digits for subsequent characters.
• It is generally better if you stick to letters,
digits, and underscore characters.
• Java is a case-sensitive language
• Do not use Java keywords
Valid Identifier Names
Java Keywords
 Naming Guidelines
• Start variable names with a lowercase
letter.
• Capitalize the first letter of all words after
the first word. (I.E. salesTaxAmount )
• Capitalize all letters in constants.
• Try to use meaningful names that are easy
to remember when coding.
Arithmetic operators
Precedence of Arithmetic operators
 Mathematical Functions
• Java provides a range of methods that support
such functions as part of the standard library in
the package java.lang, all these are available in
your program automatically.
• The methods that support various additional math
functions are implemented in the class Math.
• To reference a particular function you need to
write Math and a period in front of the function
name. To use sqrt(), which calculates the square
root of whatever you place between the
parentheses, you would write:
Math.sqrt(aNumber)
• Sun Documentation: Math class
Other assignment operators
 Integer Variables

Declaring and Initializing:

int myNumber = 12345;
byte luckyNumber = 7;
short smallNumber = 1234;
long bigOne = 999999999L;
long big = 999999999L, largeNum = 100000000L;
long xCoord=0L, yCoord=0L;
 Decimal Constants
• A decimal constant must not begin with a
0. An octal constant begins with a 0 and a
hexadecimal constant begins with 0x or
0X.
• The java.math package has a
BigInteger class for arbitrary-precision
integer arithmetic.
 Floating-point types
• The floating-point types are float (32
bits) and double (64 bits).
• A floating-point constant such as 3.14 is
of type double, whereas 3.14F and
3.14f are of type float.
 Floating point Variables
As with integer calculations, floating point
calculations in Java will produce the same
results on any computer. Declaring and
Initializing:
• double sunDistance = 1.496E8;
• float hisWeight = 185.2F;
 boolean Variables
• Recall that boolean expressions evaluate either
true of false.
• You can use boolean variables to store the
result of evaluating a boolean expression
boolean midDay =(hour == 12);
• Unlike C++ you can not assign a numeric value
to boolean data, although you can use the
values of true & false.
boolean flag = false;
 Data type char

• char variables can store any character in the

Unicode character set
● This includes any keyboard character in addition
to many others.
• You must enclose char values in single
quotes
● E.g. ‘b’, ‘1’, ‘#’
● E.g. char letter = ‘a’;
• Some special Unicode characters are known
as escape sequences
● E.g. ‘\n’ is the new-line character
Escape sequences
Escape sequences examples
String objects
 Relational operators
• Standard relational operators for comparing
values, return in true or false:
> greater than
< less than
>= greater than or equal to
<= less than or equal to
== equals
!= and not equals
• The equality operator should be used with
caution on floating-point values and object
references.
Equality & Relational Operators
 Logical Operators
• Java has the standard logical operators:
&& and
|| inclusive-or
! not
• Evaluation of a logical-and expression
terminates with a value of false at the first
false subexpression.
• Evaluation of a logical-or expression terminates
with a value of true at the first true
subexpression.
 Logical Operators
• Logical expressions evaluate left to right.
• The bit operators & and |behave as
logical operators if their operands are
booleans instead of integers.
 The Logical Operators
Symbol Long name

• There are five in Java. logical AND

&
Because they
compare or combine &&
conditional AND

boolean expressions,
logical OR
they are also called |

Boolean Operators. ||
condition OR

• Operator results are logical negation

! (NOT)
Boolean.
Logical Operators
 op= Operators

+= shortcut addition, given X= 4

X += 5; // X equals 9
-= shortcut subtraction, given X= 4
X -= 2; // X equals 2
*= shortcut multiplication, X=4
X *- 3; // X equals 12
/= shortcut division, X=4
X /= 2; // X equals 2
 instanceof operator
• This operator tests whether an object
instantiates a class. Illustrated by this
code segment
Date d = new Date();
if ( d instanceof Object ) // false
...
else if ( d instanceof Date ) // true
...
 Program Comments

• Java supports 3 ways of including comments:

line comments, block comments and
documentation comments.
– // line comment, rest of line ignored by compiler
– /* .. */ block comments, all text between /* and */
ignored by compiler.
– /**
* This is a documentation comment.
*/
 Program Comments
• Documentation Comments
/**
* This is a documentation comment.
*/
– Any asterisks at the beginning of each line in a
documentation comment are ignored, as are any
spaces
preceding the first *.
– A documentation comment can also include HTML
tags, as well as special tags beginning with @ that
are used to document methods and classes in a
standard form. The @ is followed by a keyword that
defines the purpose of the tag.
Classes and Objects in Java

Basics of Classes in Java

 Contents
• Introduce to classes and objects in Java.

• Understand how some of the OO concepts

learnt so far are supported in Java.

• Understand important features in Java

classes.
 Introduction
• Java is a true OO language and therefore the underlying
structure of all Java programs is classes.
• Anything we wish to represent in Java must be
encapsulated in a class that defines the “state” and
“behaviour” of the basic program components known as
objects.
• Classes create objects and objects use methods to
communicate between them. They provide a convenient
method for packaging a group of logically related data
items and functions that work on them.
• A class essentially serves as a template for an object
and behaves like a basic data type “int”. It is therefore
important to understand how the fields and methods are
defined in a class and how they are used to build a Java
program that incorporates the basic OO concepts such
as encapsulation, inheritance, and polymorphism.
 Classes
• A class is a collection of fields (data) and
methods (procedure or function) that
operate on that data.

Circle

centre
radius
circumference()
area()
 Classes
• A class is a collection of fields (data) and methods
(procedure or function) that operate on that data.
• The basic syntax for a class definition:
class ClassName [extends
SuperClassName]
{
[fields declaration]
[methods declaration]
• Bare bone class
} – no fields, no methods

public class Circle {

// my circle class
}
 Adding Fields: Class Circle with
fields
• Add fields
public class Circle {
public double x, y; // centre coordinate
public double r; // radius of the circle

• The fields (data) are also called the

instance varaibles.
 Adding Methods
• A class with only data fields has no life. Objects
created by such a class cannot respond to any
messages.
• Methods are declared inside the body of the
class but immediately after the declaration of
data fields.
• The general form of a method declaration is:

type MethodName
(parameter-list)
{
Method-body;
}
Adding Methods to Class Circle
public class Circle {

public double x, y; // centre of the circle

public double r; // radius of circle

//Methods to return circumference and area

public double circumference() {
return 2*3.14*r;
}
public double area() {
return 3.14 * r * r; Method
Body
}
}
 Data Abstraction
• Declare the Circle class, have created a
new data type – Data Abstraction

• Can define variables (objects) of that type:

Circle aCircle;
Circle bCircle;
 Class of Circle cont.
• aCircle, bCircle simply refers to a Circle
object, not an object itself.

aCircle bCircle

null null

Points to nothing (Null Reference) Points to nothing (Null Reference)

 Creating objects of a class
• Objects are created dynamically using the
new keyword.
• aCircle and bCircle refer to Circle objects

aCircle = new Circle() ; bCircle = new Circle() ;

 Creating objects of a class
aCircle = new Circle();
bCircle = new Circle() ;

bCircle = aCircle;
 Creating objects of a class
aCircle = new Circle();
bCircle = new Circle() ;

bCircle = aCircle;

Before Before
Assignment Assignment
aCircl bCircl aCircl bCircl
e e e e

P Q P Q
 Automatic garbage collection
• The object Q does not have a
reference and cannot be used in future.

• The object becomes a candidate for

automatic garbage collection.

• Java automatically collects garbage

periodically and releases the memory
used to be used in the future.
 Accessing Object/Circle Data
• Similar to C syntax for accessing data
defined in a structure.

ObjectName.VariableName
ObjectName.MethodName(parameter-list)

Circle aCircle = new Circle();

aCircle.x = 2.0 // initialize center and radius

aCircle.y = 2.0
aCircle.r = 1.0
 Executing Methods in
Object/Circle
• Using Object Methods:
sent ‘message’ to aCircle

Circle aCircle = new Circle();

double area;
aCircle.r = 1.0;
area = aCircle.area();
 Using Circle Class
// Circle.java: Contains both Circle class and its user class
//Add Circle class code here
class MyMain
{
public static void main(String args[])
{
Circle aCircle; // creating reference
aCircle = new Circle(); // creating object
aCircle.x = 10; // assigning value to data field
aCircle.y = 20;
aCircle.r = 5;
double area = aCircle.area(); // invoking method
double circumf = aCircle.circumference();
System.out.println("Radius="+aCircle.r+" Area="+area);
System.out.println("Radius="+aCircle.r+" Circumference ="+circumf);
}
}
[raj@mundroo]%: java MyMain
Radius=5.0 Area=78.5
Radius=5.0 Circumference
=31.400000000000002
 Summary
• Classes, objects, and methods are the basic
components used in Java programming.
• We have discussed:
– How to define a class
– How to create objects
– How to add data fields and methods to classes
– How to access data fields and methods to classes
Constructor:

A constructor initializes an object immediately upon creation. It has the same

name as the class in which it resides and is syntactically similar to a method.
Once defined, the constructor is automatically called immediately after the
object is created, before the new operator completes. Constructors look a
little strange because they have no return type, not even void. This is
because the implicit return type of a class’ constructor is the class type itself.
It is the constructor’s job to initialize the internal state of an object so that the
code creating an instance will have a fully initialized, usable object immediately.
Syntax:
class classname
{
Type instance variable;
Classname(parameterlist)
//constructor
{
// definition
}
Type methodname (parameterlist)
{
// definition
}
}
Ex: Class Rectangle
{
Int x,y;
Rectangle( )
{ Val obj

X=23;
Y=94; obj
}
}
class Val
{
Public static void main(String args[ ])
{
Rectangle obj=new Rectangle( );
}
}
Polymorphism:

It is the dynamic feature of oops. it is nothing but ability to take more

forms. It is combination of two words known as poly and morphs that
means many forms

Method overloading:

A class can contain any number of methods. Methods can take parameters as
input for data manipulation. These parameters are called type signature. Java
permits many methods to have same name, but with different type of signature is
known as method overloading.
Note:
Overloading methods exhibit the concept of polymorphism.
Nested Classes :

The Java programming language allows you to define a class within another
class. Such a class is called a nested class and is illustrated here:
Syntax:
class OuterClass {
...
class NestedClass {
...
}
}

Terminology: Nested classes are divided into two categories: static and

non-static. Nested classes that are declared static are simply called static

nested classes. Non-static nested classes are called inner classes.

Static nested class
As with class methods and variables, a static nested class is associated with

its outer class. And like static class methods, a static nested class cannot

refer directly to instance variables or methods defined in its enclosing class

— it can use them only through an object reference.

Syntax:

class OuterClass
{
...
static class StaticNestedClass
{ ... }
class InnerClass
{ ... }
}
Static nested classes are accessed using the enclosing class name:

OuterClass.StaticNestedClass

For example, to create an object for the static nested class, use this syntax:

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

Inner Classes :
As with instance methods and variables, an inner class is associated with

an instance of its enclosing class and has direct access to that object's

methods and fields. Also, because an inner class is associated with an

instance, it cannot define any static members itself.

Objects that are instances of an inner class exist within an

instance of the outer class. Consider the following classes:

class OuterClass {
….
class InnerClass {
….
}
}
An instance of InnerClass can exist only within an instance of OuterClass and has

direct access to the methods and fields of its enclosing instance. The next figure

illustrates this idea.

Syntax to create object:

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

Why Use Nested Classes?

There are several compelling reasons for using nested classes, among them:

✔It is a way of logically grouping classes that are only used in one place.

✔It increases encapsulation.

✔Nested classes can lead to more readable and maintainable code.

Logical grouping of classes— If a class is useful to only one other class, then it

is logical to embed it in that class and keep the two together. Nesting such "helper

classes" makes their package more streamlined.

Increased encapsulation— Consider two top-level classes, A and B, where B

needs access to members of A that would otherwise be declared private. By

hiding class B within class A, A's members can be declared private and B can

access them. In addition, B itself can be hidden from the outside world.

More readable, maintainable code— Nesting small classes within top-level

classes places the code closer to where it is used

Access specifiers:

Accessing a variable means getting charge on the value of the variable.

As the sometimes needs to be more confidential, the access to data must
be controlled. Access control is the process of preventing misuse of data
which is confidential.
java provides three keywords called access specifiers to control
access of data, thy are private, public and protected. These private, public
and protected keywords are called access specifiers because they determine
the level of accessibility towards that variable.

✔ Private
✔ Public
✔ protected
Private:

If the access modifier is private, then that variable can be accessed only
with in that class.

Public:

If public is the access modifier then that variable can be accessed by

any class, any package globally.

Protected:

If protected is the access modifier then that variable is allowed to be

accessed not only by the classes and the subclasses of same package
but also by the sub classes of different package.
Friendly or default:

when no access specifier is specified, the member defaults to the limited

version of public known as friendly. The difference between the public access

and friendly access is that public modifier makes fields visible in all class

regardless of their package while the friendly access makes fields visible only

in the same package but not in other packages

The Garbage Collector:

Some object-oriented languages require that you keep track of all the objects

you create and that you explicitly destroy them when they are no longer needed.

Managing memory explicitly is tedious and error-prone. The Java platform

allows you to create as many objects as you want (limited, of course, by what

your system can handle), and you don't have to worry about destroying them.

The Java runtime environment deletes objects when it determines that they are

no longer being used. This process is called garbage collection.

 The finalize( ) Method:

Sometimes an object will need to perform some action when it is destroyed. For

example, if an object is holding some non-Java resource such as a file handle or

window character font, then you might want to make sure these resources are freed

before an object is destroyed. To handle such situations, Java provides a mechanism

called finalization. By using finalization, you can define specific actions that will occur

when an object is just about to be reclaimed by the garbage collector.

To add a finalizer to a class, you simply define the finalize( ) method. The Java run

time calls that method whenever it is about to recycle an object of that class
 Inside the finalize( ) method you will specify those actions that must be

performed before an object is destroyed. The garbage collector runs

periodically, checking for objects that are no longer referenced by any running

state or indirectly through other referenced objects. Right before an asset is

freed, the Java run time calls the finalize( ) method on the object.

The finalize( ) method has this general form:

protected void finalize( )

// finalization code here

}
Inheritance:

Reusability is yet another important feature of OOP. It is always nice if

we would reuse something that already exits rather than trying to
create the same all over again. It would not only save the time and
money but also reduces frustration and increase reliability. For
instance, the reuse of a class that has already been tested, debugged
and used many times can save us the effort of developing and testing
the same again.
once the class has written and tested, it can be adapted
by other programmer to suit their requirements. This is basically done
by creating new class, reusing the properties of the exiting class ones.
The mechanism of deriving a new class form an old one is called
inheritance.
 A Super class

Sub class
B

Fig: Single inheritance

 A

Fig: Multilevel inheritance

A B

Fig: Multiple inheritance

 A

B C D

Fig: hierarchical inheritance

 A

B D

Fig: hybrid inheritance

// A simple example of inheritance.

// Create a superclass.

class A
{

int i, j;

void showij()
{

System.out.println("i and j: " + i + " " + j);

}
// Create a subclass by extending class A.

class B extends A
{

int k;

void showk()
{

System.out.println("k: " + k);

void sum()
{
System.out.println("i+j+k: " + (i+j+k));
}

}
 class SimpleInheritance
{

public static void main(String args[ ])

{

A superOb = new A();

B subOb = new B();

// The superclass may be used by itself.

superOb.i = 10;
superOb.j = 20;

System.out.println("Contents of superOb: ");

superOb.showij();
System.out.println();
/* The subclass has access to all public members of
its superclass. */

subOb.i = 7;
subOb.j = 8;
subOb.k = 9;

System.out.println("Contents of subOb: ");

subOb.showij();
subOb.showk();
System.out.println();

System.out.println("Sum of i, j and k in subOb:");

subOb.sum();
}
}
The output from this program is shown
here:

Contents of superOb:
i and j: 10 20
Contents of subOb:
i and j: 7 8
k: 9
Sum of i, j and k in subOb:
i+j+k: 24
 The this Keyword:

Sometimes a method will need to refer to the object that invoked it. To allow this, Java

defines the this keyword. this can be used inside any method to refer to the current object.

That is, this is always a reference to the object on which the method was invoked. You

can use this anywhere a reference to an object of the current class’ type is permitted.
class A
{

int a,b;
A(int a, int b)
{
this.a=a;
this.b=b;
}

void display()
{

System.out.println("the value of a= "+a);

System.out.println("the value of b= "+b);

}
}
class prog12
{
public static void main(String args[ ])

{
A obj=new A(5,6);
obj.display();
}
}

Output:

the value of a= 5
the value of b= 6
 Super:

super acts somewhat like this, except that it always refers to

the superclass of the subclass in which it is used. This usage has the following

general form:
super.member

Here, member can be either a method or an instance variable.

super is most applicable to situations in which member names

of a subclass hide members by the same name in the superclass. Consider this simpleclass hierarchy:
// Using super to overcome name hiding.
class A
{

int i;

// Create a subclass by extending class A.

class B extends A
{

int i; // this i hides the i in A

B(int a, int b) {

super.i = a; // i in A

i = b; // i in B

}
 void show()
{

System.out.println("i in superclass: " + super.i);

System.out.println("i in subclass: " + i);

}
}
class UseSuper
{

public static void main(String args[ ])

{
B subOb = new B(1, 2);

subOb.show();

}
}
This program displays the following:

i in superclass: 1
i in subclass: 2
 When Constructors Are Called:

When a class hierarchy is created, in what order are the constructors for the classes that

make up the hierarchy called? For example, given a subclass called B and a superclass

called A, is A’s constructor called before B’s, or vice versa? The answer is that in a class

hierarchy, constructors are called in order of derivation, from superclass to subclass.

Further, since super( ) must be the first statement executed in a subclass’ constructor,

this order is the same whether or not super( ) is used. If super( ) is not used, then the

default or parameterless constructor of each superclass will be executed. The following

program illustrates when constructors are executed:

// Demonstrate when constructors are called.

// Create a super class.

class A {

A()
{
System.out.println("Inside A's constructor.");
}

// Create a subclass by extending class A.

class B extends A {

B() {
System.out.println("Inside B's constructor.");
}

}
// Create another subclass by extending B.

class C extends B
{

C() {

System.out.println("Inside C's constructor.");

}

class CallingCons
{
public static void main(String args[ ])
{

C c = new C();
}
}
The output from this program is shown here:

Inside A’s constructor

Inside B’s constructor
Inside C’s constructor
Method Overriding:

In a class hierarchy, when a method in a subclass has the same name and type

signature as a method in its superclass, then the method in the subclass is said to

override the method in the superclass. When an overridden method is called from

within a subclass, it will always refer to the version of that method defined by the

subclass. The version of the method defined by the superclass will be hidden.

Consider the following:

// Method overriding.

class A
{
int i, j;

A(int a, int b)
{
i = a;
j = b;
}

// display i and j
void show()
{
System.out.println("i and j: " + i + " " + j);
}

class B extends A {
 int k;

B(int a, int b, int c) {

super(a, b);
k = c;

}
// display k – this overrides show() in A

void show() {
System.out.println("k: " + k);
}

}
 class Override {

public static void main(String args[ ])

{
B subOb = new B(1, 2, 3);

subOb.show(); // this calls show() in B

The output produced by this program is shown here:

k: 3
// Using run-time polymorphism.

class Figure
{

double dim1;
double dim2;

Figure(double a, double b)
{

dim1 = a;
dim2 = b;

}
double area()
{
System.out.println("Area for Figure is undefined.");
return 0;
}
}
 class Rectangle extends Figure
{
Rectangle(double a, double b)
{
super(a, b);
}

// override area for rectangle

double area()
{

System.out.println("Inside Area for Rectangle.");

return dim1 * dim2;

}

class Triangle extends Figure

{
 Triangle(double a, double b)
{
super(a, b);
}

// override area for right triangle

double area()
{
System.out.println("Inside Area for Triangle.");
return dim1 * dim2 / 2;
}

}
class FindAreas
{
public static void main(String args[])
{
Figure f = new Figure(10, 10);
Rectangle r = new Rectangle(9, 5);
Triangle t = new Triangle(10, 8);
Figure figref;
figref = r;

System.out.println("Area is " + figref.area());

figref = t;

System.out.println("Area is " + figref.area());

figref = f;

System.out.println("Area is " + figref.area());

}
}
The output from the program is shown here:

Inside Area for Rectangle.

Area is 45
Inside Area for Triangle.
Area is 40
Area for Figure is undefined.
Area is 0
Final class:

Inheritance allows creation of sub classes. However, if need arises,

inheritance can be prevented by declaring a class final . A class declared
as final cannot have subclasses

Final method:

Methods in a class can be prevented from over riding methods in

sub classes. Like final classes, methods can be declared with the
modifier final. Methods declared as final cannot have overriding
methods in the sub classes.
Final variables:

Variables can also be declared as final. Final variables are constant. You
cannot assign any new value to them once you have declared them as
final. Final variables must be assigned values while declaring them to be
final. The general form of declaring final variable is :

Final type VariableName = value;

By convection, final variables are declared with uppercase letters.

EX:
Final int PASS_MARK = 40;
Static Method:

We have so far seen that methods are called on the objects. That is,
methods are called in relation to an instance of a class. Java provides
a mechanism, in which methods can be called without an instance of a
class. Such method are called static methods.

Syntax:
Classname.static_method;
Static class example:

class Statclass
{

static void add(int a, int b)

{
int sum=a+b;
System.out.println("sum of two numbers="+sum);
}

}
class staticdemo
{

public static void main(String a[])

{
Statclass.add(5,4);
}

}
output:

Sum of two numbers=9

Static Variables:

Instance variables of java can also be declared as static. When a variable

is declared as static, it becomes a class variable rather than an object
variable. Static variable can accessed by any part of the program. Even if
any instance is created, the static variable retain the last modified value.
In effect it becomes a global variable
Static Variables example:

class statvar
{
static int i=0,j=0;
void printval()
{
System.out.println(" i = "+i);

System.out.println(" j = "+j);
}

}
class statvardemo
{
public static void main(String a[])
{
statvar obj=new statvar();
System.out.println(" the value of variables in the first object ");

obj.printval();

obj.i=10;
obj.j=20;

System.out.println("value of variables in the second object ");

statvar obj1=new statvar();

obj1.printval();

}
}
Output:

the value of variables in the first object

i=0
j=0
value of variables in the second object
i = 10
j = 20
 Abstract Classes:

There are situations in which you will want to define a super class that declares the

structure of a given abstraction without providing a complete

implementation of every method. That is, sometimes you will want to create a

Super class that only defines a generalized form that will be shared by all of its

subclasses, leaving it to each subclass to fill in the details. Such a class

determines the nature of the methods that the subclasses must implement.

To declare an abstract method, use this general form:

abstract type name(parameter-list);

Any class that contains one or more abstract methods must also be declared

abstract. To declare a class abstract, you simply use the abstract keyword in front of

the class keyword at the beginning of the class declaration. There can be no

objects of an abstract class. That is, an abstract class cannot be directly

instantiated with the new operator. Such objects would be useless, because an

abstract class is not fully defined Also, you cannot declare abstract constructors,

or abstract static methods. Any sub class of an abstract class must either implement

all of the abstract methods in the super class or be itself declared abstract.
Example:
abstract class A
{
abstract void callme();

void callmetoo()
{

System.out.println("This is a concrete method.");

}
class B extends A
{
void callme()
{
System.out.println( "B's implementation of callme.");
}
}

class AbstractDemo
{
public static void main(String args[ ])
{

B b = new B();
b.callme();
b.callmetoo();

}
Interfaces :

An interface is very much like a class with constant values and method
declarations

The interface is public or default

The methods in an interface are directly are only declared but not
implemented
Implicitly all the methods in an interface are abstract

Implicitly all the interface variables are final and static means , in interface we
can assign a value and that value cannot change in the interface and their
implementation classes.
 All the methods and variables are implictly public with their interface itself
is declared as public.

In all interface methods we are must implemented their implemented sub

class

Interface is act like as fully abstract class we cannot create object of the
interface

Implementing interface :

• Once the interface is defined one or more classes can implement it.

• The method that implement interface must be declared as public.

• We can use implement key word to implement interface.

Syntax:

Modifier interface interface_name

{
Type var1;
Type var2;
Modifier return_type methodname( type signature)

Modifier return_type methodname( type signature)

}
Example:

interface x {
int x=10;
void display();
}
class y implements x
{
public void display()
{
System.out.println(x*x);
}

}
class iprog
{
public static void main(String args[])
{
y obj=new y() ;
obj.display();
}
}
If the class implements two interfaces that declares same method, then the
same method will be used by the client either interface

Ex:
interface i1{
Void fun();
}
interface i2{
Void fun();
}

class implements i1,i2

{
public void fun()
{
….
}
}
•Java does not support multiple inheritance, java does not have more than one

base class.

•Java indirectly supports the multi inheritance through interface.

Extends interface:
An interface can extend another interface using keyword extends like class.
Ex:
interface i1
{
Void fun1();
}

interface i2 extends i1
{
Void fun2();
}
Packages:

Java allows you to group classes in a collection called a package. Packages are

convenient for organizing your work and for separating your work from code libraries

provided by others.
The standard Java library is distributed over a number of packages,including

java.lang, java.util, java.net, and so on.

The main reason for using packages is to guarantee the uniqueness of class names

Suppose two programmers come up with the bright idea of supplying an

Employee class.
As long as both of them place their class into different packages, then there is no

conflict. In fact, to absolutely guarantee a unique package name

Using packages:

A class can use all classes from its own package and all public classes from other

packages. You can access the public classes in another package in two ways.

The first is simply to add the full package name in front of every class name.

For example:

java.util.Date today = new java.util.Date();

You can import a specific class or the whole package.

For example, you can import all classes in the java.util package with the statement:

import java.util.*;

Then you can use

Date today = new Date();

without a package prefix. You can also import a specific class inside a package.

import java.util.Date;
User defined packages:

The steps involved in user defined packages.

1.Identify the hierarchy in which we would like to place the .class file
Ex: D:\ javaprog >

2.Create a directory which has the same name as that of the package name
Ex: D:\ javaprog \pack>

3.Include the package statement along with the package name in the package
Ex: Package pack;

4.Save the file with public class name along with java extension
Ex: A.java

5.Compile the file to generate the .class file in the same directory.
Example:
D:\ javaprog> md mypack
D:\ javaprog> cd mypack
D:\ javaprog\mypack> edit A.java
package mypack;
public class A
{
public void funa()
{
System.out.println(“I AM IN CLASS A”);
}
}
D:\javaprog\mypack>javac A.java
D:\ javaprog\mypack> edit B.java
package mypack;
public class B
{
public void funb()
{
System.out.println(“I AM IN CLASS B”);
}
}

D:\javaprog\mypack>javac B.java
D:\ javaprog\mypack> edit C.java
package mypack;
public class C
{
public void func()
{
System.out.println(“I AM IN CLASS C”);
}
}
class trial
{
Public static void main (String args[ ])
{
C objec = new C();
objec.func();
}}
D:\ javaprog\mypack> javac C.java
D:\ javaprog\mypack>cd..
D:\ javaprog>edit pack.java
import mypack.*;
public class pack
{
public static void main()
{
A obj=new A();
obj.funa();

B obj1=new B();
obj1.funb();

}
}
D:\ javaprog> javac pack.java
D:\javaprog> java pack.trial //having main method in package “pack”
Output:
I AM IN CLASS C

D:\ javaprog> java pack //executing pack.java file

Output:
I AM IN CLASS A
I AM IN CLASS B
Classpath:

✔If the importing package is not in the sub directory then we have to set the
class path.

✔The class path is an environmental variable set in the operating system

which contains a collection of sub directories where each sub directory
contains a collection of class files.

✔Once the class pat is set we are able to access classes in the sub
directory from any location in the system.
Example:

D:\softek\javaprog\userpackages\pack>

If the package is in the directory user packages, we have written

java files in softek directory then we have to set class path to
access that package.

D:\softek> set classpath= D:\softek\javaprog\userpackages;

Hierarchy of packages:

In the package hierarchy is denoted by ‘ . ’ (dot) of every level

pack1.pack2.pack3 means that pack3 is in pack2 and pack 2 is in pack1.
So we can create sub packages with another package, to access the sub
package we have specify the entire path.
Exception handling:

Errors :
1. Syntax (occur at compile time)
2. Logical (errors occur at runtime)

Compile time error: the error occur at compilation of a program.

Runtime error: the error occur at execution of the program

Exception handling:

the process of handling exception is called exception

handling. when an error occur in a java method, the method creates an

object of type and gives it to the runtime system

 Java exception handling is managed via five keywords: try, catch, throw, throws,

and finally. Briefly, here is how they work. Program statements that you want to

monitor for exceptions are contained within a try block. If an exception occurs within

the try block, it is thrown. Your code can catch this exception (using catch) and handle

it in some rational manner. System-generated exceptions are automatically thrown by

the Java run-time system. To manually throw an exception, use the keyword throw.

Any exception that is thrown out of a method must be specified as such by a throws

clause. Any code that absolutely must be executed before a method returns is put in

a finally block.
This is the general form of an exception-handling block:

try {

// block of code to monitor for errors

catch (ExceptionType1 exOb) {

// exception handler for ExceptionType1

catch (ExceptionType2 exOb) {

// exception handler for ExceptionType2

}
 finally {

// block of code to be executed before try block ends

Using try and catch:

To guard against and handle a run-time error, simply enclose the code that you

want to monitor inside a try block. Immediately following the try block, include a catch

clause that specifies the exception type that you wish to catch
Example:
class Exc2 {

public static void main(String args[ ]) {

int d, a;
try { // monitor a block of code.
d = 0;
a = 42 / d;
System.out.println("This will not be printed.");

}
catch (ArithmeticException e) {
// catch divide-by-zero error
System.out.println("Division by zero.");

System.out.println("After catch statement.");

}
}
Output:

Division by zero.
After catch statement.
 Multiple catch Clauses:

In some cases, more than one exception could be raised by a single piece of code. To

handle this type of situation, you can specify two or more catch clauses, each catching

a different type of exception. When an exception is thrown, each catch statement is

inspected in order, and the first one whose type matches that of the exception is

executed. After one catch statement executes, the others are bypassed, and execution

continues after the try/catch block

Example:
class MultiCatch {

public static void main(String args[]) {

try {

int a = args.length;
System.out.println("a = " + a);
int b = 42 / a;
int c[ ] = { 1 };
c[42] = 99;
}
catch(ArithmeticException e) {

System.out.println("Divide by 0: " + e);

}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Array index oob: " + e);
}

System.out.println("After try/catch blocks.");

}
}
output:
C:\>java MultiCatch

a=0
Divide by 0: java.lang.ArithmeticException: / by zero
After try/catch blocks.

C:\>java MultiCatch TestArg

a=1
Array index oob:
java.lang.ArrayIndexOutOfBoundsException
After try/catch blocks.
 Nested try Statements:

The try statement can be nested. That is, a try statement can be inside the block of

another try. Each time a try statement is entered, the context of that exception is

pushed on the stack. If an inner try statement does not have a catch handler for a

particular exception, the stack is unwound and the next try statement’s catch handlers

are inspected for a match. This continues until one of the catch statements succeeds, or

until all of the nested try statements are exhausted. If no catch statement matches, then

the Java run-time system will handle the exception

example:

class NestTry {

public static void main(String args[ ]) {

try {

int a = args.length;

/* If no command-line args are present,

the following statement will generate
a divide-by-zero exception. */

int b = 42 / a;

System.out.println("a = " + a);

 try { // nested try block

/* If one command-line arg is used,

then a divide-by-zero exception
will be generated by the following code. */

if(a==1) a = a/(a-a);

// division by zero

/* If two command-line args are used,

then generate an out-of-bounds exception. */
 if(a==2) {

int c[ ] = { 1 };

c[42] = 99; // generate an out-of-bounds exception

}
}
catch(ArrayIndexOutOfBoundsException e) {

System.out.println("Array index out-of-bounds: " + e);

}
}
catch(ArithmeticException e) {
System.out.println("Divide by 0: " + e);
}
}
}
 C:\>java NestTry

Divide by 0: java.lang.ArithmeticException: / by zero

C:\>java NestTry One

a=1
Divide by 0: java.lang.ArithmeticException: / by zero

C:\>java NestTry One Two

a=2
Array index out-of-bounds:
java.lang.ArrayIndexOutOfBoundsException
Throw:
So far, you have only been catching exceptions that are thrown by the Java run-time

system. However, it is possible for your program to throw an exception explicitly,

using the throw statement. The general form of throw is shown here:

throw ThrowableInstance;

Here, ThrowableInstance must be an object of type Throwable or a

subclass of Throwable.
Example:

class ThrowDemo {
static void demoproc() {
try {
throw new NullPointerException("demo");
}
catch(NullPointerException e) {
System.out.println("Caught inside demoproc.");
throw e; // rethrow the exception
}
}
public static void main(String args[]) {
try {
demoproc();
}
catch(NullPointerException e) {
System.out.println("Recaught: " + e);
}
}
}
Output:

Caught inside demoproc.

Recaught: java.lang.NullPointerException: demo

 throws:

If a method is capable of causing an exception that it does not handle, it must specify

this behavior so that callers of the method can guard themselves against that exception.

You do this by including a throws clause in the method’s declaration. A throws clause

lists the types of exceptions that a method might throw. This is necessary for all

exceptions, except those of type Error or RuntimeException, or any of their subclasses.

All other exceptions that a method can throw must be declared in the throws clause. If

they are not, a compile-time error will result.

This is the general form of a method declaration that includes a throws clause:

type method-name(parameter-list) throws exception-list

// body of method

}
Example:

class ThrowsDemo {

static void throwOne() throws IllegalAccessException

{
System.out.println("Inside throwOne.");
throw new IllegalAccessException("demo");
}

public static void main(String args[]) {

try {
throwOne();
}
catch (IllegalAccessException e) {
System.out.println("Caught " + e);
}

}
}
output:

inside throwOne
caught java.lang.IllegalAccessException: demo
Finally:

In try and catch block all statements are executed, if no such exceptions occurs.

When an exception occurs, the statements placed in between the point of

occurring Of the exception and end of the blocked will be skipped and the

control looks for matching a catch block. In certain problems, it is essential to

execute certain statements, such statements are placed in finally block.

Example:
class FinallyDemo {
// Through an exception out of the method.
static void procA() {
try {
System.out.println("inside procA");
throw new RuntimeException("demo");
}
finally {
System.out.println("procA's finally");
}
}
 // Return from within a try block.
static void procB() {
try {
System.out.println("inside procB");
return;
}
finally

{
System.out.println("procB's finally");
}

// Execute a try block normally.

static void procC() {
try {
System.out.println("inside procC");
} finally {
System.out.println("procC's finally");
}
}
 public static void main(String args[]) {
try {
procA();
} catch (Exception e) {
System.out.println("Exception caught");
}
procB();
procC();
}
}

Output:

inside procA
procA's finally
Exception caught
inside procB
procB's finally
inside procC
procC's finally
Multi Threading:
A multithreaded program contains two or more parts that can run concurrently.

Each part of such a program is called a thread, and each thread defines a

separate path of execution. Thus, multithreading is a specialized form of

multitasking
 Multi Threading:

You are almost certainly acquainted with multitasking, because it is supported

by virtually all modern operating systems. However, there are two distinct types

of multitasking: process-based and thread-based. It is important to understand the

difference between the two. For most readers, process-based multitasking is the more

familiar form. A process is, in essence, a program that is executing. Thus, process-based

multitasking is the feature that allows your computer to run two or more programs

concurrently.

For example, process-based multitasking enables you to run the Java

compiler at the same time that you are using a text editor. In process-based multitasking,

a program is the smallest unit of code that can be dispatched by the scheduler.
 In a thread-based multitasking environment, the thread is the smallest unit of

dispatchable code. This means that a single program can perform two or more tasks

simultaneously. For instance, a text editor can format text at the same time that it is

printing, as long as these two actions are being performed by two separate threads.

Thus, process-based multitasking deals with the “big picture,” and thread-based

multitasking handles the details.

 Multithreading enables you to write very efficient programs that make maximum

use of the CPU, because idle time can be kept to a minimum. This is especially

important for the interactive, networked environment in which Java operates, because

idle time is common. For example, the transmission rate of data over a network is

much slower than the rate at which the computer can process it. Even local file system

resources are read and written at a much slower pace than they can be processed by the

CPU. And, of course, user input is much slower than the computer. In a traditional,

single-threaded environment, your program has to wait for each of these tasks to finish

before it can proceed to the next one—even though the CPU is sitting idle most of the

time. Multithreading lets you gain access to this idle time and put it to good use
 The Java Thread Model:

The Java run-time system depends on threads for many things, and all the class libraries

are designed with multithreading in mind. In fact, Java uses threads to enable the

entire environment to be asynchronous. This helps reduce inefficiency by preventing

the waste of CPU cycles.

What Is a Thread?:

A thread executes a series of instructions. Every line of code that is executed is

done so by a thread. Some threads can run for the entire life of the applet,

while others are alive for only a few milliseconds. A thread also creates a new

thread or kills an existing one. Threads run in methods or constructors. The

methods and constructors themselves are lifeless. The threads go into the

methods and follow their instructions. Methods and constructors reside in the

computer's memory
 Threads – Thread States
• State diagram
new start
runnabl notify, notifyAll,
new
e IO complete,
sleep expired,
yield,
scheduler join complete
time
slice
running blocked
IO, sleep,
terminate wait, join

dead
 Threads exist in several states. A thread can be running.It can be ready to run as

soon as it gets CPU time. A running thread can be suspended, which temporarily

suspends its activity. A suspended thread can then be resumed, allowing it to pick up

where it left off. A thread can be blocked when waiting for a resource. At any time, a

thread can be terminated, which halts its execution immediately. Once terminated, a

thread cannot be resumed

 The Thread Class and the Runnable Interface:

Java’s multithreading system is built upon the Thread class, its methods, and its

companion interface, Runnable. Thread encapsulates a thread of execution. Since

you can’t directly refer to the ethereal state of a running thread, you will deal with it

through its proxy, the Thread instance that spawned it. To create a new thread, your

program will either extend Thread or implement the Runnable interface. The Thread

class defines several methods that help manage threads. The ones that will be used in

this chapter are shown here:

 Method Meaning

getName Obtain a thread’s name.

getPriority Obtain a thread’s priority.

isAlive Determine if a thread is still running.

join Wait for a thread to terminate.

run Entry point for the thread.

sleep Suspend a thread for a period of time.

start Start a thread by calling its run method

 Creating a Thread:

In the most general sense, you create a thread by instantiating an object of type Thread.

Java defines two ways in which this can be accomplished:

You can implement the Runnable interface.

You can extend the Thread class, itself.

Implementing Runnable:
class NewThread implements Runnable
{
Thread t;
NewThread()
{
// Create a new, second thread

t = new Thread(this, "Demo Thread");

System.out.println("Child thread: " + t);

t.start(); // Start the thread

}

// This is the entry point for the second thread.

public void run() {

try {
 for(int i = 5; i > 0; i--)
{
System.out.println("Child Thread: " + i);

Thread.sleep(500);

}
}
catch (InterruptedException e)

System.out.println("Child interrupted.");

}
System.out.println("Exiting child thread.");

}
}
 class ThreadDemo
{
public static void main(String args[ ])
{

new NewThread(); // create a new thread

try
{

for(int i = 5; i > 0; i--)

{

System.out.println("Main Thread: " + i);

Thread.sleep(1000);
}
}
 catch (InterruptedException e)

System.out.println("Main thread interrupted.");

System.out.println("Main thread exiting.");

}
}

Inside NewThread ’s constructor, a new Thread object is created by the

following statement:

t = new Thread(this, "Demo Thread");

 Passing this as the first argument indicates that you want the new thread to call the

run( ) method on this object. Next, start( ) is called, which starts the thread of execution

beginning at the run( ) method. This causes the child thread’s for loop to begin. After

calling start( ) , NewThread ’s constructor returns to main( ) . When the main thread

resumes, it enters its for loop.

 Both threads continue running, sharing the CPU, until

their loops finish. The output produced by this program is as follows:

Child thread: Thread[Demo Thread,5,main]

Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Exiting child thread.
Main Thread: 2
Main Thread: 1
Main thread exiting
 Extending Thread:

The second way to create a thread is to create a new class that extends Thread ,

and then to create an instance of that class. The extending class must override the

run( ) method, which is the entry point for the new thread. It must also call start( )

to begin execution of the new thread. Here is the preceding program rewritten to

extend Thread :
// Create a second thread by extending Thread

class NewThread extends Thread

{
NewThread()
{

// Create a new, second thread

super("Demo Thread");

System.out.println("Child thread: " + this);

start(); // Start the thread

}
// This is the entry point for the second thread.

public void run()

{
try {

for(int i = 5; i > 0; i--)

{
System.out.println("Child Thread: " + i);

Thread.sleep(500);

} catch (InterruptedException e)
{
System.out.println("Child interrupted.");
}

System.out.println("Exiting child thread.");

}
}
 class ExtendThread
{
public static void main(String args[])
{

new NewThread();

// create a new thread

try
{
for(int i = 5; i > 0; i--)
{
System.out.println("Main Thread: " + i);

Thread.sleep(1000);

}
}
 } catch (InterruptedException e)
{
System.out.println("Main thread interrupted.");
}
System.out.println("Main thread exiting.");
}
}

This program generates the same output as the preceding version. As you can

see, thechild thread is created by instantiating an object of NewThread , which is

derived fromThread . Notice the call to super( ) inside NewThread . This invokes

the following form of the Thread constructor: public Thread(String threadName )

Here, threadName specifies the name of the thread

Creating Multiple Threads:
// Create multiple threads.

class NewThread implements Runnable

{
String name; // name of thread

Thread t;

NewThread(String threadname)
{
name = threadname;

t = new Thread(this, name);

System.out.println("New thread: " + t);

t.start(); // Start the thread

}
// This is the entry point for thread.

public void run()

{

try {

for(int i = 5; i > 0; i--)

{
System.out.println(name + ": " + i);

Thread.sleep(1000);
}
}
 catch (InterruptedException e)
{
System.out.println(name + "Interrupted");

}
System.out.println(name + " exiting.");

}
}

class MultiThreadDemo {
public static void main(String args[])
{
new NewThread("One"); // start threads
new NewThread("Two");
new NewThread("Three");

try {
// wait for other threads to end
Thread.sleep(10000);
}
 catch (InterruptedException e)
{
System.out.println("Main thread Interrupted");

System.out.println("Main thread exiting.");

}
The output from this program is shown here:
New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
New thread: Thread[Three,5,main]
One: 5
Two: 5
Three: 5
One: 4
Two: 4
Three: 4
One: 3
Three: 3
Two: 3
 One: 2
Three: 2
Two: 2
One: 1
Three: 1
Two: 1
One exiting.
Two exiting.
Three exiting.
Main thread exiting.

As you can see, once started, all three child threads share the CPU. Notice the call to

sleep(10000) in main( ) . This causes the main thread to sleep for ten seconds and

ensures that it will finish last.

 Using isAlive( ) and join( ):

Two ways exist to determine whether a thread has finished. First, you can call
isAlive( ) on the thread. This method is defined by Thread , and its general form is
shown here:

final boolean isAlive( )

The isAlive( ) method returns true if the thread upon which it is called is still running. It

returns false otherwise. WhileisAlive( ) is occasionally useful, the method that you will

more commonly use to wait for a thread to finish is called join( ) , shown here:

final void join( ) throws InterruptedException

This method waits until the thread on which it is called terminates. Its name comes

from the concept of the calling thread waiting until the specified thread joins it.

Additional forms of join( ) allow you to specify a maximum amount of time that

you want to wait for the sp ecified thread to terminate.

class NewThread implements Runnable
{
String name; // name of thread

Thread t;

NewThread(String threadname)
{
name = threadname;

t = new Thread(this, name);

System.out.println("New thread: " + t);

t.start(); // Start the thread

}
 // This is the entry point for thread.
public void run()
{
try {

for(int i = 5; i > 0; i--)

{
System.out.println(name + ": " + i);

Thread.sleep(1000);

}
catch (InterruptedException e)
{
System.out.println(name + " interrupted.");
}
System.out.println(name + " exiting.");
}
}
 class DemoJoin
{
public static void main(String args[ ])
{
NewThread ob1 = new NewThread("One");

NewThread ob2 = new NewThread("Two");

NewThread ob3 = new NewThread("Three");

System.out.println("Thread One is alive: "+ ob1.t.isAlive());

System.out.println("Thread Two is alive: "+ ob2.t.isAlive());

System.out.println("Thread Three is alive: "+ ob3.t.isAlive());

 // wait for threads to finish
try
{
System.out.println("Waiting for threads to finish.");
ob1.t.join();

ob2.t.join();

ob3.t.join();

}
 catch (InterruptedException e)
{
System.out.println("Main thread Interrupted");

System.out.println("Thread One is alive: "+ ob1.t.isAlive());

System.out.println("Thread Two is alive: "+ ob2.t.isAlive());

System.out.println("Thread Three is alive: "+ ob3.t.isAlive());

System.out.println("Main thread exiting.");

}
Sample output from this program is shown here:
New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
New thread: Thread[Three,5,main]
Thread One is alive: true
Thread Two is alive: true
Thread Three is alive: true
Waiting for threads to finish.
One: 5
Two: 5
Three: 5
One: 4
Two: 4
Three: 4
One: 3
Two: 3
Three: 3
One: 2
Two: 2
Three: 2
One: 1
Two: 1
Three: 1
 Two exiting.
Three exiting.
One exiting.
Thread One is alive: false
Thread Two is alive: false
Thread Three is alive: false
Main thread exiting.
 Thread Priorities :
To set a thread’s priority, use the setPriority( ) method, which is a member of Thread.

This is its general form:

final void setPriority(int level )

Here, level specifies the new priority setting for the calling thread.

The value of level must be within the range MIN_PRIORITY and

MAX_PRIORITY . Currently, thesevalues are 1 and 10, respectively.

To return a thread to default priority, specify NORM_PRIORITY,

which is currently 5. These priorities are defined as final variables

within Thread
You can obtain the current priority setting by calling the getPriority( ) method of

Thread , shown here:

final int getPriority( )

 class clicker implements Runnable
{
int click = 0;
Thread t;

private volatile boolean running = true;

public clicker(int p)

{
t = new Thread(this);

t.setPriority(p);
}

public void run() {

while (running) {
click++;
}
}
 public void stop()
{
running = false;
}
public void start()
{

t.start();

}
}

class HiLoPri
{
public static void main(String args[ ])
{
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
clicker hi = new clicker(Thread.NORM_PRIORITY + 2);
clicker lo = new clicker(Thread.NORM_PRIORITY - 2);
lo.start();
hi.start();
try {
 Thread.sleep(10000);

} catch (InterruptedException e)
{
System.out.println("Main thread interrupted.");

lo.stop();

hi.stop();

// Wait for child threads to terminate.

Try
{
hi.t.join();
lo.t.join();
} catch (InterruptedException e) {
System.out.println("InterruptedException caught");
}
System.out.println("Low-priority thread: " + lo.click);

System.out.println("High-priority thread: " + hi.click);

}
 Synchronization:

When two or more threads need access to a shared resource, they need some way to

ensure that the resource will be used by only one thread at a time. The process by

which this is achieved is called synchronization

 class syn
{
static synchronized void method(String s)
{
for(int i=0;i<=10;i++)
{
System.out.println(s+i);
}
try
{
Thread.sleep(10);
}
catch(Exception e)
{
}
}
}
 class Th1 extends Thread
{
public void run()
{
syn.method("FIRST THREAD");
}
}
class Th2 extends Thread
{
public void run()
{
syn.method("SECOND THREAD");
}
}
 class MainThread
{
public static void main(String args[])
{
Th1 obj1=new Th1();
Th2 obj2=new Th2();
obj1.start();
obj2.start();
}
}
 OUTPUT:
FIRST THREAD0
FIRST THREAD1
FIRST THREAD2
FIRST THREAD3
FIRST THREAD4
FIRST THREAD5
FIRST THREAD6
FIRST THREAD7
FIRST THREAD8
FIRST THREAD9
FIRST THREAD10
SECOND THREAD0
SECOND THREAD1
SECOND THREAD2
SECOND THREAD3
SECOND THREAD4
SECOND THREAD5
SECOND THREAD6
SECOND THREAD7
SECOND THREAD8
SECOND THREAD9
SECOND THREAD10
AWT: ABSTRACT WINDOW TOOL KIT:

It is a collection of classes which provide graphical component such as

buttons,textboxes,text fields,labels etc.

It is combining classes used in java.awt package

Component class
This is a super of all components, it is providing a set of methods
which available in sub class.
The AWT supports the following types of controls:

■ Labels
■ Push buttons
■ Check boxes
■ Choice lists
■ Lists
■ Scroll bars
■ Text editing

These controls are subclasses of Component

Labels:
The easiest control to use is a label. A label is an object of type Label,

and it contains a string, which it displays. Labels are passive controls that

do not support any interaction with the user. Label defines the following

constructors:

Label( )
Label(String str)
Label(String str, int how)

The first version creates a blank label. The second version creates a

label that contains the string specified by str. This string is left-justified.

The third version creates a label that contains the string specified by str

using the alignment specified by how. The value of how must be one of

these three constants: Label.LEFT, Label.RIGHT, or Label.CENTER.

You can set or change the text in a label by using the setText( ) method. You can
obtain the current label by calling getText( ). These methods are shown here:

void setText(String str)

String getText( )

For setText( ), str specifies the new label. For getText( ), the current label is

returned. You can set the alignment of the string within the label by calling

setAlignment( ).To obtain the current alignment, call getAlignment( ). The

methods are as follows:

void setAlignment(int how)

int getAlignment( )
import java.awt.*;
import java.awt.event.*;
class myf extends Frame
{
public myf()
{
setVisible(true);
setSize(400,500);

setLayout(new FlowLayout(FlowLayout.LEFT));

Label one = new Label("One");

Label two = new Label("Two");
Label three = new Label("Three");
add(one);
add(two);
add(three);
addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent we)
{
setVisible(false);
System.exit(0);
}
});

}
}
 class mylabel
{
public static void main(String args[])
{
myf obj=new myf();
}
}

To execute the program:

Javac mylabel.java

Java mylabel
Using Buttons:

The most widely used control is the push button. A push button is a component
that contains a label and that generates an event when it is pressed. Push
buttons are objects of type Button. Button defines these two constructors:

Button( )
Button(String str)

The first version creates an empty button. The second creates a button that
contains str as a label.
After a button has been created, you can set its label by calling
setLabel( ). You can retrieve its label by calling getLabel( ). These methods
are as follows:

void setLabel(String str)

String getLabel( )

Here, str becomes the new label for the button.

Applying Check Boxes:

A check box is a control that is used to turn an option on or off. It consists of

a small box that can either contain a check mark or not. There is a label
associated with each check box that describes what option the box
represents. You change the state of a check box by clicking on it. Check
boxes can be used individually or as part of a group. Check
boxes are objects of the Checkbox class.

Checkbox supports these constructors:

Checkbox( )

Checkbox(String str)

Checkbox(String str, boolean on)

Checkbox(String str, boolean on, CheckboxGroup cbGroup)

Checkbox(String str, CheckboxGroup cbGroup, boolean on)

The first form creates a check box whose label is initially blank. The state

of the check box is unchecked. The second form creates a check box

whose label is specified by str. The state of the check box is unchecked.

The third form allows you to set the initial state of the check box. If on is

true, the check box is initially checked; otherwise, it is cleared. The fourth

and fifth forms create a check box whose label is specified by str and

whose group is specified by cbGroup. If this check box is not part of a

group, then cbGroup must be null. (Check box groups are described in the

next section.) The value of on determines the initial state of the check box.
To retrieve the current state of a check box, call getState( ). To set its

state, call setState( ). You can obtain the current label associated with a

check box by calling getLabel( ). To set the label, call setLabel( ).

These methods are as follows:

boolean getState( )

void setState(boolean on)

String getLabel( )

void setLabel(String str)

Here, if on is true, the box is checked. If it is false, the box is cleared.

The string passed in str becomes the new label associated with the
invoking check box.
Using a TextField:

The TextField class implements a single-line text-entry area, usually called an

edit control.Text fields allow the user to enter strings and to edit the text using

the arrow keys, cut and paste keys, and mouse selections. TextField is a

subclass of TextComponent. TextField defines the following constructors:

TextField( )

TextField(int numChars)

TextField(String str)

TextField(String str, int numChars)

The first version creates a default text field. The second form creates a text

field that is numChars characters wide. The third form initializes the text field

with the string contained in str. The fourth form initializes a text field and sets

its width.TextField (and its superclass TextComponent) provides several

methods that allow you to utilize a text field. To obtain the string currently

contained in the text field, call getText( ). To set the text, call setText( ).

These methods are as follows:

String getText( )

void setText(String str)

Here, str is the new string.

Using a TextArea:

Sometimes a single line of text input is not enough for a given task. To handle these
situations, the AWT includes a simple multiline editor called TextArea. Following are
the constructors for TextArea:

TextArea( )

TextArea(int numLines, int numChars)

TextArea(String str)

TextArea(String str, int numLines, int numChars)

TextArea(String str, int numLines, int numChars, int sBars)

Here, numLines specifies the height, in lines, of the text area, and

numChars specifies its width, in characters. Initial text can be

specified by str. In the fifth form you can specify the scroll bars that

you want the control to have. sBars must be one of these values:

SCROLLBARS_BOTH SCROLLBARS_NONE

SCROLLBARS_HORIZONTAL_ONLY

SCROLLBARS_VERTICAL_ONLY
Applet:

An Applet is a program designed in java and will be placed in the sever.

The Applet will be downloaded in the server to the client doing with the HTML

Document and run in the client web browser. An Applet can contain component

like,checkboxes radio buttons etc.applet can open network program

 Applet Initialization and Termination:

It is important to understand the order in which the various methods

shown in the skeleton are called. When an applet begins, the
AWT calls the following methods, in this sequence:

1. init( )

2. start( )

3. paint( )

When an applet is terminated, the following sequence of method calls takes place:

1. stop( )

2. destroy( )
init( )

The init( ) method is the first method to be called. This is where you should

initialize variables. This method is called only once during the run time of your

applet.

start( )

The start( ) method is called after init( ). It is also called to restart an applet

after it has been stopped. Whereas init( ) is called once—the first time an

applet is loaded—start( ) is called each time an applet’s HTML document is

displayed onscreen. So, if a user leaves a web page and comes back, the

applet resumes execution at start( ).

paint( )

The paint( ) method is called each time your applet’s output must be redrawn. This

situation can occur for several reasons. For example, the window in which the

applet is running may be overwritten by another window and then uncovered. Or

the applet window may be minimized and then restored. paint( ) is also called

when the applet begins execution. Whatever the cause, whenever the applet must

redraw its output, paint( ) is called. The paint( ) method has one parameter of

type Graphics. This parameter will contain the graphics context, which describes

the graphics environment in which the applet is running. This context is used

whenever output to the applet is required.

stop( )

The stop( ) method is called when a web browser leaves the HTML

document containing the applet—when it goes to another page, for

example. When stop( ) is called, the applet is probably running. You

should use stop( ) to suspend threads that don’t need to run when the

applet is not visible. You can restart them when start( ) is called if the

user returns to the page

destroy( )

The destroy( ) method is called when the environment determines that

your applet needs to be removed completely from memory. At this point,

you should free up any resources the applet may be using. The stop( )

method is always called before destroy( ).

import java.awt.*;
import java.applet.*;
/*
<applet code="AppletSkel" width=300 height=100>
</applet>
*/
public class AppletSkel extends Applet {
// Called first.
public void init() {
// initialization
}
/* Called second, after init(). Also called whenever
the applet is restarted. */
public void start() {
// start or resume execution
}
// Called when the applet is stopped.
public void stop() {
// suspends execution
}

/* Called when applet is terminated. This is the last

method executed. */

public void destroy() {

// perform shutdown activities
}

// Called when an applet's window must be restored.

public void paint(Graphics g) {

// redisplay contents of window
}
}
 /*
<applet code="AppletSkel" width=300 height=100>
</applet>
*/

To compile : javac filename.java

To execute: appletviewer filename.java

The above code must be inserted to execute the applet or u can use

Applet tag in html document

<HTML>
<HEAD></HEAD>

<BODY>

<APPLET CODE=“FILENAME” HEIGHT=“ “ WIDTH=“ “></APPLET>

</BODY>

</HTML>
Drawing Lines:

Lines are drawn by means of the drawLine( ) method, shown here:

void drawLine(int startX, int startY, int endX, int endY)

drawLine( ) displays a line in the current drawing color that begins

at startX,startY and ends at endX,endY.

// Draw lines
import java.awt.*;
import java.applet.*;
/*
<applet code="Lines" width=300 height=200>
</applet>
*/
public class Lines extends Applet
{
public void paint(Graphics g)
{
g.drawLine(0, 0, 100, 100);

g.drawLine(0, 100, 100, 0);

g.drawLine(40, 25, 250, 180);

g.drawLine(75, 90, 400, 400);

g.drawLine(20, 150, 400, 40);

g.drawLine(5, 290, 80, 19);

}
}
 Drawing Rectangles:

The drawRect( ) and fillRect( ) methods display an outlined and filled

rectangle, respectively. They are shown here:

void drawRect(int top, int left, int width, int height)

void fillRect(int top, int left, int width, int height)

The upper-left corner of the rectangle is at top,left. The dimensions of the

rectangle are specified by width and height.

To draw a rounded rectangle, use drawRoundRect( ) or fillRoundRect( ),

both shown here:

void drawRoundRect(int top, int left, int width, int height,int xDiam, int yDiam)

void fillRoundRect(int top, int left, int width, int height,int xDiam, int yDiam)
// Draw rectangles
import java.awt.*;
import java.applet.*;
/*
<applet code="Rectangles" width=300 height=200>
</applet>
*/
public class Rectangles extends Applet
{
public void paint(Graphics g)
{
g.drawRect(10, 10, 60, 50);
g.fillRect(100, 10, 60, 50);
g.drawRoundRect(190, 10, 60, 50, 15, 15);
g.fillRoundRect(70, 90, 140, 100, 30, 40);
}
}
Drawing Ellipses and Circles

To draw an ellipse, use drawOval( ). To fill an ellipse, use fillOval( ).

These methods are shown here:

void drawOval(int top, int left, int width, int height)

void fillOval(int top, int left, int width, int height)

// Draw Ellipses
import java.awt.*;
import java.applet.*;
/*
<applet code="Ellipses" width=300 height=200>
</applet>
*/
public class Ellipses extends Applet {
public void paint(Graphics g) {
g.drawOval(10, 10, 50, 50);
g.fillOval(100, 10, 75, 50);
g.drawOval(190, 10, 90, 30);
g.fillOval(70, 90, 140, 100);
}
}
Drawing Arcs:

Arcs can be drawn with drawArc( ) and fillArc( ), shown here:

void drawArc(int top, int left, int width, int height, int startAngle,int sweepAngle)

void fillArc(int top, int left, int width, int height, int startAngle,int sweepAngle)
// Draw Arcs
import java.awt.*;
import java.applet.*;
/*
<applet code="Arcs" width=300 height=200>
</applet>
*/
public class Arcs extends Applet {
public void paint(Graphics g) {
g.drawArc(10, 40, 70, 70, 0, 75);
g.fillArc(100, 40, 70, 70, 0, 75);
g.drawArc(10, 100, 70, 80, 0, 175);
g.fillArc(100, 100, 70, 90, 0, 270);
g.drawArc(200, 80, 80, 80, 0, 180);
}
}
Drawing Polygons:

It is possible to draw arbitrarily shaped figures using drawPolygon( ) and

fillPolygon( ),shown here:

void drawPolygon(int x[ ], int y[ ], int numPoints)

void fillPolygon(int x[ ], int y[ ], int numPoints)

// Draw Polygon
import java.awt.*;
import java.applet.*;
/*
<applet code="HourGlass" width=230 height=210>
</applet>
*/
public class HourGlass extends Applet {
public void paint(Graphics g) {
int xpoints[] = {30, 200, 30, 200, 30};
int ypoints[] = {30, 30, 200, 200, 30};
int num = 5;
g.drawPolygon(xpoints, ypoints, num);
}
}
Setting the Current Graphics Color

By default, graphics objects are drawn in the current foreground color. You
can change this color by calling the Graphics method setColor( ):

void setColor(Color newColor)

Here, newColor specifies the new drawing color.

You can obtain the current color by calling getColor( ), shown here:

Color getColor( )
// Demonstrate color.
import java.awt.*;
import java.applet.*;
/*
<applet code="ColorDemo" width=300 height=200>
</applet>
*/
public class ColorDemo extends Applet {
// draw lines

public void paint(Graphics g)

{
Color c1 = new Color(255, 100, 100);
Color c2 = new Color(100, 255, 100);
Color c3 = new Color(100, 100, 255);
g.setColor(c1);

g.drawLine(0, 0, 100, 100);

g.drawLine(0, 100, 100, 0);

g.setColor(c2);

g.drawLine(40, 25, 250, 180);

g.drawLine(75, 90, 400, 400);

g.setColor(c3);

g.drawLine(20, 150, 400, 40);

g.drawLine(5, 290, 80, 19);

g.setColor(Color.red);

g.drawOval(10, 10, 50, 50);

g.fillOval(70, 90, 140, 100);

g.setColor(Color.blue);

g.drawOval(190, 10, 90, 30);

g.drawRect(10, 10, 60, 50);

g.setColor(Color.cyan);

g.fillRect(100, 10, 60, 50);

g.drawRoundRect(190, 10, 60, 50, 15, 15);

}
}
Understanding Layout Managers:

Each Container object has a layout manager associated with it. A layout
manager is an instance of any class that implements the LayoutManager
interface. The layout manager is set by the setLayout( ) method. If no call
to setLayout( ) is made, then the default layout manager is used.
Whenever a container is resized (or sized for the first time), the layout
manager is used to position each of the components within it. The
setLayout( ) method has the following general form:

void setLayout(LayoutManager layoutObj)

Here, layoutObj is a reference to the desired layout manager. If you wish to disable

the layout manager and position components manually, pass null for layoutObj. If

you do this, you will need to determine the shape and position of each component

manually, using the setBounds( ) method defined by Component. Normally, you

will want to use a layout manager.

FlowLayout:

FlowLayout is the default layout manager. This is the layout manager that
the preceding examples have used. FlowLayout implements a simple
layout style, which is similar to how words flow in a text
editor.Components are laid out from the upper-left corner, left to right and
top to bottom. When no more components fit on a line, the next one
appears on the next line. A small space is left between each component,
above and below, as well as left and right.
Here are the constructors for FlowLayout:

FlowLayout( )

FlowLayout(int how)

FlowLayout(int how, int horz, int vert)

The first form creates the default layout, which centers components and

leaves five pixels of space between each component. The second form lets

you specify how each line is aligned. Valid values for how are as follows:

FlowLayout.LEFT

FlowLayout.CENTER

FlowLayout.RIGHT

These values specify left, center, and right alignment, respectively. The third form

allows you to specify the horizontal and vertical space left between components

in horz and vert, respectively.

BorderLayout:

The BorderLayout class implements a common layout style for top-level

windows. It has four narrow, fixed-width components at the edges and one

large area in the center. The four sides are referred to as north, south,

east, and west. The middle area is called the center. Here are the

constructors defined by BorderLayout:

BorderLayout( )

BorderLayout(int horz, int vert)

The first form creates a default border layout. The second allows you to

specify the horizontal and vertical space left between components in

horz and vert, respectively.BorderLayout defines the following

constants that specify the regions:

BorderLayout.CENTER BorderLayout.SOUTH

BorderLayout.EAST BorderLayout.WEST

BorderLayout.NORTH
When adding components, you will use these constants with the following form of

add( ), which is defined by Container:

void add(Component compObj, Object region);

Here, compObj is the component to be added, and region specifies where the
component will be added.
GridLayout:

GridLayout lays out components in a two-dimensional grid. When you

instantiate a GridLayout, you define the number of rows and columns.
The constructors supported by GridLayout are shown here:

GridLayout( )

GridLayout(int numRows, int numColumns )

GridLayout(int numRows, int numColumns, int horz, int vert)

The first form creates a single-column grid layout. The second form
creates a grid layout with the specified number of rows and columns. The
third form allows you to specify the horizontal and vertical space left
between components in horz and vert, respectively. Either numRows or
numColumns can be zero. Specifying numRows as zero allows for
unlimited-length columns. Specifying numColumns as zero allows for
unlimited-length rows.
 Card Layout:

The card layout is a set of cards will be added to the layout each card

Contains any number of components. To create a card panel will be used. Whenever

a card is selected by the user the components of that card will be on applet

CardLayout( )

CardLayout(int horz, int vert)

Use of a card layout requires a bit more work than the other layouts. The

cards are typically held in an object of type Panel. This panel must have

CardLayout selected as its layout manager. The cards that form the deck

are also typically objects of type Panel. Thus, you must create a panel that

contains the deck and a panel for each card in the deck. Next, you add to

the appropriate panel the components that form each card. You then add

these panels to the panel for which CardLayout is the layout manager.

Finally, you add this panel to the main applet panel. Once these steps are

complete, you must provide some way for the user to select between cards.

One common approach is to include one push button for each card in the

deck.
When card panels are added to a panel, they are usually given a name.
Thus, most of the time, you will use this form of add( ) when adding
cards to a panel:

void add(Component panelObj, Object name);

Here, name is a string that specifies the name of the card whose panel

is specified by panelObj.