core java

1

Contents

Chapter-1: Object Oriented Programming Fundamentals

Chapter-2: Evolution of java programming language

Chapter-3: Basic elements of java

Chapter-4: Operators in java

Chapter-5: Conditional statements and loops

Chapter-6: Class fundamentals

Chapter-7: Object reference

Chapter-8: Array in java

Chapter-9: Inheritance

Chapter-10: Inner class

Chapter-11: Exception Handling

Chapter-12: Package

Chapter-13: JAR File

Chapter-14: String

Chapter-15: StringBuffer

Chapter-16: Wrapper class

Chapter-17: Taking the input from keyboard

Chapter-18: Java Native Interface

Chapter-19: Multithreading

Chapter-20: Generics

2

Chapter-21: Files and Streams

Chapter-22: Exploring java.lang package

Chapter-23: java.util package(part-I):Collection

Framework

Chapter-24: java.util package(part-II)

Chapter-25:The Applets

Chapter-26:The java.awt package

Chapter-27:Java Foundation classes

Chapter-28:The java.net package

Chapter-29:The java.sql package

Chapter-30:Brain Teasers

3

Chapter1:

Object oriented programming fundamentals

While teaching new comers in java the first question that comes in

my mind to ask is “What is object”. All most all the new comer in java knows

C++. So the question is quite obvious & I expect to get a nice answer. The

answer usually is: “OBJECT IS AN INSTANCE OF A CLASS” which is

absolutely correct. Then, the next question from my side is “WHAT EXACTLY

A CLASS IS & CAN YOU GIVE ME A REAL LIFE EXAMPLE OF AN OBJECT” &

surprisingly most of the time no satisfactory answers. They know the

definition, but they have not visualized concept of object. Before migrating

from traditional programming world to OOP (Object Oriented Programming)

world, one has to have a strong fundamental concept of object.

Object is the instance of a class. Class is a template, i.e. it

contains various characteristics or attributes which were satisfied by the

object belonging to it, e.g. if human is a class, then SAM KOOL (Obliviously

Name of a MAN!!) is an object of human class.

4

Object is the entity which communicates with the environment. Class is an

abstract concept. It is merely a collection of attributes & characteristics.

Object gives life to those characteristics present in the class, & that is why

object can communicate with the surrounding. Since class is a template it

doesn‟t have memory but, the object has. Class template combines data and

functions or methods to manipulate those data. The data present in an

object can only be manipulated by the methods or functions belonging to

that object.

Overview of Object Oriented Programming

Way back in 1960s OOP gives its first hint of birth. In traditional

language like C, FORTRAN logic pays the highest priority. One question I

would like to ask reader whether the logic should have highest priority in

every aspect of programming. My answer is no, because logic always whirls

around data. Data should always enjoy highest priority. Programmer should

concentrate on data security & integrity while developing the software.

Procedural programming language does not have the tools to encapsulate

the data to prevent it to be accessed by any random methods. Along with

this fact code reusability is another issue that is not achieved by procedural

programming language. With the increase of complexity of software, security

of data, code reusability, polymorphic behavior of programs &

communication among various entities has to be addressed perfectly, but

traditional programming language has no answer at all. Then it comes

Simula, the first OOP language has answers to these issues. It introduces

the concept of class, object, method, virtual methods, inheritance &

polymorphism. Object Oriented Programming is simply a collection of objects

where objects interact with each other through the methods that have been

embedded in them. You can think of a object as a self sufficient machine.

What I mean to convey here is that like a machine object has concretely

defined way to take input, it has separate component to process the input &

has completely unique component to produce the output. Each object has

unique identification & existence. In Object oriented Programming the data &

the operations to access & manipulate the data are closely entangled to each

other.

5

Quarks of OOP

Class: class is an abstract concept. It is simply a template. When a class is

instantiated object is created. Class contains data & methods to manipulate the data. Class is simply a blueprint of a thing. In programming prospective

class encapsulate various primitive data types as well as user defined data

types.

6

Object

Object is the instance of a class. It is a bundle of variables and

related methods. The basic idea behind an object is the simulation of data

& methods to manipulate them.

Method

Methods are the entities through which objects interacts with the external environment. Whatever object is going do, can only be done

through the methods. Methods are concretely entangled with a particular object. Let me explain it through an example. Assume that

MyClass is a user defined class

Example-1

Class MyClass { Data_1;

Data_2; Method_to_manipulate_data_1()

{ Required codes

} };

If o1 & o2 are the two objects of MyClass. o2 cannot manipulate its

Data_1 through the use of Method_to_manipulat_data_1() of o1 just

like you cannot eat for yourself through your friends mouth.

7

Message passing

The process by which objects communicate with each other. Obliviously communication can only be done through methods.

Abstraction

Abstraction means simplification complex reality of a problem. In lay

man language abstraction means, “HIDING THE DETAILS”.

Programmer hides the complexity of the program from the end user. End users only have the methods or functions to interact with the data

without knowing how the manipulation is done. Consider the case of a cell phone. Cell phone users know only about various functionalities

available in the phone without knowing how they are implemented.

Encapsulation:

Encapsulation means binding both code and data together. Code

implies the methods or functions that manipulate the data. This technique

protects the data from outside interference & behaves as protective wrapper.

User can interact with the data through the methods that are available in the

specific object. Apart from those available methods it is not possible for user

to manipulate the data. But, in case of structured programming language

like C data can be manipulated by any function which decreases the security

& integrity of data e.g.

8

Example-2

struct xxx

{

int a;

};

main( )

{

struct xxx x;

void fun1(struct xxx*);

x.a=9;

fun1(&x);

printf(“%d”,x.a);

}

void fun1(struct xxx *ptr)

{

ptr->a=10;

}

The output is 10. Structured programming language gives a mean to handle

the real world data. But, any function can manipulate the data belonging to

any structure variable as shown in the above example. Encapsulation

prevents these entire unsecured mean to modify & access the data. Each

method has well defined task & they are strongly entangled with the

corresponding object. Encapsulation also abstracts the complexity involve in

a class from the end user.

Inheritance: Inheritance is a technique by which an object acquires the

feature of other object along with its own features. The object from which

9

property is acquired is known as parent object & the object which acquires

the property is known as child object. It depends upon the programmer to

decide what the properties are that has to be inherited from parent to child.

In java the parent class is known as super class & the child class is known as

sub class. Sub class can add new feature to it along with the inherited

properties. Inheritance facilitates code reusability.

Why inheritance is required?

Suppose you are developing software for market complex whose task is to

show the viewer what are the various items available. If you are developing

this project in C then you are going to declare a structure

Example-3:

struct xxx{

10

char item1_name[20];





};

You have designed the functions to show these items to the customers. In

latter stage if some new item is introduced than you have to again change

the structure template. But, in case of OOP just you have to create the sub

class or child class, then all the existing attributes are inherited to the sub

class & you just add the new items to it. Great!! Job is over & quite simple

also. By creating the base class you can add new items in future to the

existing class. In this way you can also add new methods to the sub-class to

improve functionality & accessibility.

Polymorphism: Polymorphism in OOP is the technique through which when

a method is called invocation of appropriate method is performed by the

appropriate type specification. Only name is not enough, argument type is

important along with the contents of the invoking object. In lay man

language polymorphism means one name many forms. In OOP

terminology polymorphism implies one method performing many tasks. A

novice object oriented programmer definitely going to ask “Do the

programmers really have scarcity of name?”, again lets go through an

example.

In the early version of cell phones one can only send text message. For

sending the messages assume the function is send which has the following

signature.

return_acknowledgement send(text_data,receiver_name);

All the cell-phone users are quite comfortable with send function. But when

multimedia messaging technique is discovered, send function need to be

11

redefined. In traditional programming technique one can not have same

named two or more function. One solution is that provide another function a

totally new one to send mms. Again this is awful because one function to

send text message and another one for mms. So the best solution to this

situation is the use of polymorphism through which we can have another

send function to send mms. In OOP a method is recognized through its

entire signature. Entire signature includes name of the function along with

the parameters it is taking.

return_acknowledgement send (mms_data,receiver_name);

These two functions are entirely different, see the signature. Great

solution!!!.Finally Novice Object Oriented programmer got the reason for the

birth Object Oriented Programming.

Conclusion: Logic is highly important for programming. But for which we

have to program & answer is data. Procedural language helps you to develop

logic but remain silent when it comes for the security & integrity of data.

With the evolution of distributed application, data is not stationary. What do

you think when sends some thing in internet how it goes? Not in raw data

format but in the form of objects. OOP provides a wrapper to the data which

is almost impossible to penetrate.

12

Chapter: 2

Evolution of java programming language.

Way back in 1991 James Gosling who took his first step in the development of Java programming language. Previously java was called as Oak, (yes! Name of a tree). Then the name Green comes finally ended with Java. Java is developed by SUN

Microsystem. Most of its syntax has been derived from C/C++. SUN released the 1st JDK1.0 in 1995. It promises to the programmer as a platform independent

language. The language is syntactically similar to C and C++ but works on a higher

abstraction level as compared to them. First Java 1.0 was released by Sun Microsystem in 1995. "Write Once, Run Anywhere" (WORA) was the tagline for java

1.0.It was secure and allowed network and file-access restrictions. Very soon java got popular due to which java 1.2 is released in December 1998.After the success of java 1.2 sun launched the new and different versions of java for different

purposes,e.g J2EE is for enterprise applications i.e for server side programming , J2ME for mobile applications , J2SE is for Standard Edition. Finally java evolved as:

A simple and object oriented language. A robust and secure language. A architecture neutral and portable language. A language with high performance rate.

A language which is interpreted, multi threaded, and dynamic. Portability is one of the most important characteristics , it means the compile byte-codes i.e. the class file written in the Java language runs similarly independent of the system hardware

and operating system i.e write a code once, compile it once, and run it anywhere. The platform independent feature of java is achieved by compiling the java source

code not to a machine code but to a intermediate code called byte codes. Byte codes are collection of instructions for java virtual machine which are later interpreted to native codes. Java provides a reach set library functions for graphics

designing, applet programs, GUI design through swing, remote method invocation & for multi threading applications. Some virtual machine implements techniques for

the conversion java source code to native machine codes. In Linux gcj compiler converts java source code to native machine codes resulting faster execution of java programs. When java file is compiled class file is created. Class file is merely a

collection of byte-codes. Byte codes are then interpreted by JVM. Interpretation is quite slow. Therefore the execution of java program is slow as compared to

executable native codes. This is great performance issue for java program. Over the years effort has given for the increase the execution of java program. Just In Time compiler is a solution to improve the performance. By the implementation of JIT

compiler when for the first time the byte codes are translated to native codes, it caches it. There is another technique in which java source code is directly converted

to machine readable native codes. This is done by AOT (Ahead Of Time) compiler. This technique increases the performance because native code executes faster than byte codes. GCJ compiler available in Linux is a AOT compiler. AOT compilation

disables the most important feature in java, i.e. the platform independence feature.

I have seen most of the new comers in java, treat it as a language having more functionality, abstraction & a lot of similarity with C/C++. This because of large set

13

of keywords & operators are matched with keywords & operators of C/C++. But, this is not true at all. Java survives & grows in this world because of its own unique

identity. Let me address on those issues. Java has neither preprocessor directive nor header files. Predefined methods

& classes are available to java through the packages. Packages are collection of class files.

All the methods, variables & all sorts of codes always reside within the class

template. Through wrapper class java provides an object oriented view of primitive

data type like integer, float, byte, char, boolean etc. This wrapper class package has enabled java as a complete object oriented programming language.

Java does not support global variables. In C++ global variables does not belong to a particular class & can be modified by any function. This is the

unsecure mean of data manipulation. Java has restricted this controversial issue by not supporting the global variable.

Memory management is not provided to the programmer. Unused data is

deleted from memory by the invocation of the demon thread named garbage collector. Memory leak problem is quite optimized in java.

Non existence of memory pointers. Memory pointers are always threat to any automated system. These are used to break the security & can crash a

system. Not having these memory pointers is an advantage to java. During any assignment operation java strictly follows type checking. Due to

this feature precession loss or data loss is minimal in java.

Java strictly follows type safety. Programmer can not arbitrarily cast on data-type to another one.

Local variables in side a method can be declared when they are needed. Implementation of floating point variables is platform dependent. There fore

java provides the keyword strictfp to maintain its platform independent

property. Union provides memory over lapping feature which is discarded in java.

No typdef to create alias of data-type. Array index out of bound is checked in java to prevent the unauthorized

manipulation of memory.

WHY JAVA ?

Platform Independence The Write-Once-Run-Anywhere (Java Virtual Machine for different platforms usually required), concept is strictly followed.

Introduction of wrapper class makes java a complete object oriented

programming language. When a java source file is compiled, class file is generated which is collection

of byte-codes. These byte-codes are latter interpreted to native codes by JVM. Byte-codes are portable.

Byte codes are least affected by virus as compared to executable files. If it is

affected, then JVM recognize then & never allow them to be executed. Built in support for exception handling.

Built in support for multi threading application development.

14

Java provides communication with C/C++ source codes through Java Native Interface.

By the use of Compiler class java source code can be compiled to native machine codes.

Package like java.lang.SecurityManager provides permission to the object to have an access on variables, files & other resources.

Built in support for networking.

Virtual Machine When you read the java language, java virtual machine is quite a familiar term.

But, what is a virtual machine?

The philosophy behind virtual machine is to abstract the system hardware of a single computer in to several different virtual systems such that it makes the user to feel that different environment or platform is implemented on a

single system.

15

Diagram:

Diagram-2

16

System that implement the virtual machine.

Each virtual machine provides different environment or platform to the user. According to the platform provided, only a particular set of processes can be

executed in a particular virtual machine. Processes those are executed in Virtual Machine-1 cannot be executed in Virtual Machine-2. Implicitly these virtual machine perform appropriate system call for the execution of different

processes.

When different processes are running, virtual machine makes the end user to feel that different processes are running not only in different platform, but

also in different CPUs. This illusion is created by the implementation of different CPU scheduling

algorithm by the underlying OS.

17

The Java Virtual Machine. JVM consists of following components shown in the diagram.

These components are abstract in nature. It completely depend upon the designer to develop these components. Class loader Sub System: when a java file is compiled class file is generated. When we invoke the class file for execution class

loader subsystem is called by Java Virtual Machine to load the class file into JVM memory space. The task of Class loader sub system is to load the classes &

interfaces in the memory. In Java Virtual Machine there are two types of loader is available. A boot strap loader & other one is user defined class loader. The job of the class loader sub-system is not only to load the class file but also it checks

correctness of the loaded class, allocates required memory to static variables (static variables are explained in class fundamental). The class loader sub-system

performs its task in sequential way 1st: Loading of class file. 2nd: Checks the correctness of class file. If you have read the class file by notepad or word-pad in a

windows system, then that class file cannot be executed. For this behavior class

18

loader sub-system is responsible. 3rd: allocates memory to static variables. Static variables are otherwise known as class variables. They are the property of classes

rather than the property of objects. 4th: transformation of symbolic reference into direct reference. 5th: sets default value of all static variables.

Method Area: it is a logical memory component of JVM. This logical section of memory holds the information about classes & interfaces. Static variables are treated as class variable, because they take memory from method area. The size of

the method area is not fixed. It shrinks & expands according to the size of the application.

Heap: In java when an object or array is created, memory is allocated to them from heap. The Java virtual machine through the use of new operator allocates memory from the heap for a new object. Java does not provide any technique to the

programmer to free the memory that has been allocated by new operator. Once memory is allocated from heap to an object or array, programmer cannot free the

memory. The JVM has demon thread known as Garbage Collector whose task is to free those objects from heap whose reference is not alive in stack. Java stacks: Method codes are stored inside method area. When method starts execution, it

needs memory because of the local variables & the arguments it has taken. For this purpose java stack is there. All the local variables & the arguments method have

taken acquires memory from stack. PC registers: It keeps track of the sequence of execution of the program. PC registers or Program Counter registers holds the

address of the instruction to be executed next. Native method stacks: When a java application invokes a native method, that application is not going to use Java stack only, rather it uses the native method stack also for the execution of native

methods. Native methods are generally in C/C++ & executed in side native method stack. The libraries required for the execution of native methods are available to

the Java Virtual Machine through Java Native Interface. Execution Engine: Execution engine is there to generate & execute the java byte code. It contains an interpreter & Just In Time Compiler. Java Run-time Environment

Byte-Codes Byte code is the unique characteristic property of java programming

language. It is something like a normal text file. That‟s why it cannot be affected by virus. You can say that it is a intermediate human readable source & machine readable source. Byte codes are plat form independent & that‟s why JVM is plat

form dependent to make the java programming as platform independent. Just like C source codes are portable, byte codes are portable. The cost of platform

independence behavior of byte codes is paid by its slower execution speed when it is compared with execution of native codes even in just in time compiler. How to Construct the FAMOUS Hello, World!!! Program in JAVA Don‟t get surprised with the

name it‟s just our first program in java that we are going to write.

Example public class hello

{ public static void main(String ag[])

{ System.out.println(“Hello, World!!!”);

19

} }

Output: Hello, World!!!

1: Now in the above program we have declared the class containing the main method as public so we have to save it in a file which has the same name as

that of class name. e.g. hello.java 2: after the file is saved we have to compile the hello.java file using the javac command. e.g. javac hello.java 3:

After compilation hello.class file will be generated. Then to get the output we have to run the .class file using java command. e.g.: java hello note : if we are not declaring the class containing the main method as public , then we

can save the file in any name. But when we will compile the .java file then the name of the class file generated will be same to the

name of the class containing the main method. To get the output we have to run the program using the name of the .class file.

Example-2

xyz.java

class hello

{

public static void main (String ag []) {

System.out.println(“Hello”); }

}

Output: Hello

To get the output: 1: javac xyz.java 2: the class file will be generated in

name of hello.class. Now run it with the java command to get the output. 3: java

hello Restrictions:- 1:-In java top level class is declared either through public or no access modifier. 2:-When the class is declared through public access modifier class

name must be same as the file name. 3:-When the class is declared through no access modifier class name and file name may same or may not

20

CHAPTER 3:

Basic Elements of JAVA

1. IDENTIFIERS Identifier are the set of rules for giving the names of the variables

of primitive data types, methods, user defined classes, interfaces and

reference variables of classes. Java is said to be strongly typed language, means you must declare the identifier & initialize it before it is used.

Identifiers should not begin with a number and an identifier should not contain these following characters ;

{}

()

//

[]

*

\

+

-

,

;

“”

„‟

#

%

!

^.

21

Like C/C++ (dollar)$ &(underscore) _ is allowed in java.

KEYWORDS

The table below lists the keywords, or reserved words, as of Java 5.0. We will discuss the meaning and function of most of them during this course.

KEYWORDS DESCRIPTION

abstract

it is used to declare a class or method to be abstract. An

abstract method does not contain its body. Abstarct methods only have the declaration, but their body is defined else

where. In interface the methods are by default public & abstract which has to be defined concretely where these

interfaces are implemented.

assert

This keyword was introduced in J2SE 1.4. This keyword is used in the program to check whether a specified condition is

true or not. If the condition is true then the program execute in a normal way otherwise an AssertionError is thrown.

boolean

Boolean is a primitive data type in java. It can have either

true or false value. Internally Boolean is represented as integral value in JVM. When Boolean variable is use as

instance or static variable its default vaue is false. When ever a condition checking is done in java, Boolean value is

returned by the condition checking operator. Size of a

Boolean variable is 8 bit.

break

Break keyword is used in loops & switch case. It is

particularly used to break the normal flow of the program.

byte

Byte is a primitive data type in java. Its size is 1byte or 8 bit. Default vale of byte variable when it is used as instance

variable or static variable is zero.

case The case keyword is used to create individual cases in a switch statement. Case clause preceded with integral

constant & enum members. In place integer constant you can have character constants and bytes since they are auto

converted to integer.

22

catch

This is a component of exception handling mechanism. Always follows the try block to catch the exception object

thrown from catch block.

char

It is a primitive data type in java. Unlike c/c++ it is of 16 bit

used to hold the Unicode character.

class

Class is the key word through which programmer defines the user defined class template.

const const keyword is not available to the programmer.

continue

When continue keyword is encountered the control jumps to

the condition checking part of do, do-while loop & the increment part of for loop . Continue statement can be

followed with a level name to resume execution from the specified level name.

default The default is an optional component of switch case. When

no condition is satisfied default case is executed in switch case.

do

Solely do has no existence. It always entangled with while o

form the do-while loop.

double

It is a primitive data type in java of 64 bit used to store real

numbers.

else

It is used along with if statement following the if block. Used

for condition checking. When if part is not executed control jumps to else part. Solely else has no existance. In an if-else

statement else part is optional.

enum JDK 1.5 has introduces this key word used to create constant. Enum is a class in java.

extends Extend key word is used to support inheritance in java

false A boolean constant..

final Final keyword is used in case of variables to create

constants. Where used in case of class, that class cannot be inherited. When used in case of methods, that method

cannot be overridden.

finally It is a component of exception handling in java. whenever

try block is executed , it is mandatory that the codes inside

the catch block has to be executed.

float This keyword is used to store real numbers. Its size is 32 bit.

23

for

It is used to create looping statement.

Goto This keyword is not available to the java programmer.

If It is used for condition checking purpose

implements It is used to inherit multiple number of interfaces

import It is used to import existing packages. Packages are the

collection of class files.

instanceof It is a binary operator used to determine the parent child relationship between two objects.

int It is used to store the natural numbers. It‟s size is 4 bytes

interface

Interface is used to support multiple inheritance in java. By default all the methods declared are public and abstract. To

use the methods declared inside a interface u have to override it in the child class.

long It is used to store integral values . it‟s size is 8 bytes

native Like abstract method the body of native method is defined elsewhere in foreign language.

new Used to create an object. It is a operator.

null A reference literal value.

package Package is a collection of class files. Package keyword is

used to declare a package.

private It is a access modifier. When an entity inside a class is

declared as private it cannot be inherited to it‟s child class.

Private variables are only accessed inside the class.

protected It is a access specifier. Protected entities are accessed out

side the package through inheritance.

public It is an access specifier. Public variables can be accessed from anywhere.

return Used to return control from method along with a value.

short Primitive data type in java. It is of 8 bit size.

static Static keyword is associate with method and constructor. Static variables are treated as class variable. Static entities

are accessed through class name.

24

strictfp

Floating point numbers are stored in the memory depending

upon the platforms to have a platform independent representation of real numbers strictfp is used

super Used to acess the parent class element.

switch Switch case is used for condition checking.

synchronized Synchronized keyword is used to avoid dead lock in thread.

Synchronized keyword can be used for block or method.

this This keyword is used by object to refer to itself.

throw It is a component of java exception handling mechanism. Used throw an exception object.

throws

Throws keyword Is used along with the method signature. It used by the called method to throw the UnhandledException

to the calling method.

transient Transient keyword is used for those variables if programmer does not want to strew the variable persistently.

true A boolean constant.

try A component of exception handling mechanism of java. All the exception generated codes are embedded inside try block

void If a method does not return anything then void is used to

denote its return type during the definition of method.

volatile Volatile is used along with a variable name. volatile variable

changes their value without informing the JVM. System clock values are stored in volatile variable.

while While is a key word in java used for creating a loop.

25

Java Primitive Data Types

Type Values

Default Size Range

byte Natural numbers 0 8 bits -128 to 127

short Natural numbers 0 16 bits -32768 to 32767

int Natural numbers 0 32 bits -2147483648 to 2147483647

long Natural numbers 0 64 bits -9223372036854775808 to

9223372036854775807

float Real numbers 0.0 32 bits

+/-1.4E-45 to +/-

3.4028235E+38,

+/-infinity, +/-0, NAN

double Real numbers 0.0 64 bits

+/-4.9E-324 to

+/-

1.7976931348623157E+308,

+/-infinity, +/-0, NaN

char Unicode character \u0000 16 bits \u0000 to \uFFFF

boolean true, false false

1 bit

used in

32 bit

integer

NA

26

Chapter-4

Operator

Since java maintains most of the syntactical similarity with C/C++ there fore most

of the operators those are available in C/C++ are also available in java. In C++

operators can be overloaded by the programmer, but that is not possible in java.

Java provides user a large set of operators to the programmers. Operators acts

upon operand to provide desired output. e.g. a=b+c a,b,c are operand where as + and = are

operators.

There is an important aspect that has to be understood by the reader before getting

in to the depth of the operators i.e. how the positive & negative integers are stored

in memory.

int x=12. x will be stored in the memory in the form of binary as

00000000 00000000 00000000 00001100 but things are became twisted when it

comes for negative numbers. Negative numbers are stored in the form of two‟s

complement & left most bit is treated as sign bit. When the value of sign bit is one,

the number is a negative number.

Let‟s have an example to clear the idea.

Int x=-12.

How to have two‟s complement form

1: convert the no. into binary leaving the negative sign.

The binary form of 12 is 00000000 00000000 00000000 00001100

2: reverse the polarity of each bit to one‟s complement of the number

11111111 11111111 11111111 11110011

3: add 1 to have the final result that is two‟s complement

11111111 11111111 11111111 11110100 in this format -12 is stored in memory.

27

Operators available to the java programmer

Type:1 (Unary Operators)

+ Unary plus

- Unary minus

++ Postfix increment & prefix

increment

-- Postfix decrement

() Casting operator

~ Bitwise inversion

! Boolean complement operator

Unary Plus Operator & minus operator

Unary plus & minus operator is used to represent positive & negative number.

Programs below will give you a clear picture. I don‟t think explanations are

required. Output in each program is simple & straight forward.

class Demo {

public static void main(String []args)

{

int x=12;

System.out.print(-x);

}

}

Output: -12

28

class Demo {

public static void main(String[]args)

{

int x=12;

System.out.print(+x);

}

}

Output: 12

class Demo {


{

int x=12;

System.out.print(-+x);

}

}

Output: -12

class Demo {


{

int x=12;

System.out.print(-(-x));

}

}

Output: 12

29

The postfix operator:

class Demo

{

public static void main(String args[])

{

int i=6;

int j=i++;

System.out.println(i);

System.out.println(j);

}

}

Output:

7

6

Explanation:

Variable i is initialized to 6. Incase post fix increment operation use of the variable

enjoys the highest priority where as increment is done in second phase. In the

statement j=i++ 1st value of i i.e. 6 is assigned to j & then i is incremented to 7.

Now you can think of why the output is 7 & 6.

See another interesting behavior of post fix operation

class Demo

{

public static void main(String args[]){

int i=6;

i=i++;

30


}

}

Output

6

Foxed dear!!! See I have already said in post fix operation use of the variable

enjoys highest priority. In the above piece of code since assignment & increment is

done over one variable the increment part is rejected because of its lower privilege.

It‟s a rule.

Similarly you can try for postfix decrement operator.

Prefix operation

class Demo

{


int i=6;

int j=++i;



}

}

Output

7

7

In the above code I have used the pre fix increment operator. In this case

increment enjoys the highest priority. So first value of i is incremented to 7 & then

it is assigned to j.

31

class Demo

{


int i=6;

i=++i;


}

}

Output 7

Since increment enjoys the highest priority output is straight forward.

Cast Operator: (type)

Casting is used to convert the value of one type to another. In other words casting

is used to explicitly convert the value of one type to another. The result of cast is a

new reference or a value. In java not only data types are casted but also object is

casted. In java casting is of two types:

Casting of primitive data types

Casting of object type

Casting primitive types:

Casting between primitive types allows explicitly convert one primitive data

type into another. In java boolean data type cannot be casted to any data

type. If you want to cast a smaller data type to a larger one then implicit

casting is done in java.

32

The larger type provides more precision than the smaller type and hence no

information is lost when the value is cast. When the larger type is assign to the

smaller type then explicit cast must be required. See the diagram if the flow of data

moves from opposite direction then explicit conversion is required.

Example:

public class Cast1

{


{

int i=10;

long l=1;

double d=3.4;

byte b;

b=(byte)i; // type casting

System.out.println(b);

i=(int)l; // type casting


l=(long)d; // type casting

System.out.println(l);

}

33

}

Output:-

10

1

3

Casting Object

Instance of one class can be casted to instance of another class. Restriction of this

principle is that class that is being casted must be related by inheritance. An

instance of the sub class is casted when the super class instance is assign to the

sub class object as the sub class contains all the information that the super class

contains.

Example:

class Test1

{

void show()

{

System.out.println("Super Class");

}

}

class Test2 extends Test1

{

void display()

{

System.out.println("Sub Class");

}

34

}

public class Test

{


{

Test1 t1=new Test1();

Test2 t2=(Test2)t1;

t2.show();

t2.display();

}

}

Output:-

The program compiles successfully but at the runtime the program is terminated by

Exception in thread “main” java.lang.ClassCastException

Bit wise inversion operator: (~)

class Demo{


{

int x=12;

System.out.println(~x);

}}

Output : -13

Lets have a deeper look. Binary representation of x is

00000000 00000000 00000000 00001100 . When „~‟ operator is operated on x

then 0 turns to 1 & 1 turns to 0. Hence the value of x is now

35

11111111 11111111 11111111 11110011 . The left most bit is the sign bit, since it

is turned to 1 because of „~‟ operator, therefore the number becomes a negative

number. All the negative numbers are stored in memory in the form of two‟s

complement.

Two‟s complement= 1‟s complement+1

To get the final out put 1st determine the one‟s complement of

111111111 11111111 11111111 11110011 which is(by converting 0 to 1 & 1 to 0)

10000000 00000000 00000000 00001100 here sign bit never change its polarity.

Finally add 1 & the output is

10000000 00000000 00000000 00001101

Sign bit says it‟s a negative number & rest other says the final output is -13.

Lets have another example

class Demo{


{

int x=-12;

System.out.println(~x);

}}

Output: 11

Here the number is a negative number. It will be stored in the memory in two

complement form.

11111111 11111111 11111111 11110100

When ~ is operated on these bits then the output will be

0000000 0000000 00000000 00001011. This is the binary form of 11 got it!

Boolean complement operator

As the name suggests this operator work only for Boolean data type, other wise

compilation error will occour.

class Demo {

36


{

boolean x=true;

System.out.print(!x);

}

}

Output: false

This operator just inverse the value of Boolean variable.

Type 2 (Binary Operators)

Arithmetic operators + ,-, *, /, %

Assignment operators = ,+=,-=,*=,/=,%=,&=,^=,|=

Conditional operator ==,>=,<=,>,<

Bitwise operator &,|,^

Shift operator >>,<<,>>>

instanceof operator

Short circuit operator &&,||

37

Arithmetic operators

Arithmetic operators are used to evaluate mathematical expressions. All the

operators are simple & their behavior is straight forward. A novice programmer may

be confused about the %, the modulus operator. This operator is used to determine

the remainder when a division is performed. See the example

class Demo {


{

int x=12;

int y=5;

x=x%y;

System.out.print(x);

}

}

Output: 2

Assignment operators

An interesting fact about assignment operator:

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

byte i=10; byte j=9;

i=j+i; System.out.println(i);

}

}

38

Output:

Exception in thread "main" java.lang.Error: Unresolved compilation problem:

Type mismatch: cannot convert from int to byte

at demo.Thread1.main(Thread1.java:9) see the output is compilation error. Why ? because = operator accepts an integer

variable in the left hand side when arithmetic operation is done. But, check the

codes below

class Thread1

{


byte i=10;

byte j=9;

i+=j;


}

}

Output

19

The reason here is that += is overloaded to return appropriate type. Similarly other

assignment operators like -=,*=,/=,%=,^=,&=,|= is over loaded. Remember that

in assignment operator the left hand side value is assigned to right hand side only if

the right hand side is a similar or bigger data-type with respect to left hand side.

class Demo {


{

int x;

byte y=5;

x=y;


}

39

}

Output=5.

Right hand side is an integer variable where as left hand side is a byte variable.

Hence there is no problem in assignment. But, if the situation is reversed then

compilation error will be generated. See the codes below.

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

{ byte x;

int y=5; x=y; System.out.print(x);

} }

Output:


Type mismatch: cannot convert from int to byte at demo.Demo.main(Demo.java:9)

Conditional Operators

== equals to operator

!= Not equal to

>Greater than

< Smaller than

>=greater than equals to

<= smaller than equals to

These operators are particularly useful in conditional statements & loops.

class demo1

{

40

public static void main(String ar[])

{

int i = 5;

int j= 10;

if(i==j)

System.out.println("equall");

else

System.out.println("not equall");

if(i!=j)


else


if(i>j)


else


if(i<j)


else

41


i=20;

if(i>=j)


else


if(i<=j)


else


}

}

Output :

not equall

equall

not equall

equall

equall

not equall

Codes & the out clearly explain the behavior of all the conditional operators.

42

Bitwise Operators

~ Bitwise inversion operator

& Logical AND

| Logical OR

^ Logical XOR(exclusive OR)

>> Bitwise Right Shift

<< Bitwise Left Shift

>>> Bitwise Unsigned Right Shift

Lets have logic table of first four bit wise operators to have a primary idea, then we

will go for codes.

x y ~x ~y x&y x|y x^y

0 0 1 1 0 0 0

0 1 1 0 0 1 1

1 0 0 1 0 1 1

1 1 0 0 1 1 0

Bitwise inversion operator is explained earlier in unary operator.

Bitwise and operator ( & ) :

class Demo{


{

int x=12;

int y= 13;

x=x&y;

System.out.println(x);

}}

43

Output :

12

Let‟s see what actually happens. See the truth table above, in case of AND (&)

operation only 1 & 1 gives 1 else in all other cases results 0. In the above example

x =12 will be stored in the memory as 00000000 00000000 00000000 00001100

y = 13 will be stored in the memory as 00000000 00000000 00000000 00001101

x =x&ywill be stored in the memory as 00000000 00000000 00000000 00001100

from above we can see that only in the 3rd bit and 4th bit of both 12 and 13 is 1 so

by the & operation the value of 3rd and 4th bit will remain 1 else will remain 0. The

result is the binary form of 12 & so is the output.

Let‟s see what happens when the AND (&) operation is performed between a

negative and a positive number

class demo

{


{

int x = -12;

int y = 13;

x= x & y;


}

}

Output :

44

4

Here x is a negative number hence it will be stored in the memory in the form of

twos complement.

x =-12 will be stored in the memory as 11111111 11111111 11111111 11110100

y = 13will be stored in the memory as 00000000 00000000 00000000 00001101

x=x&y will be stored in the memory as 00000000 00000000 00000000 00000100

The sign bit of the resultant is 0, hence it is a positive number which is 4.

Bitwise OR(|)operator

class Demo {


{

int x=12;

int y=13;

x=x|y;


}

}

Output:13

The bit wise OR (|) operator checks individual bits of two different operand, if any

bit of any of the operand is 1 then output is 1.

X=12 its binary form is 00000000 00000000 00000000 00001100

Y=13 its binary form is 00000000 00000000 00000000 00001101

X=x|y out put is 00000000 00000000 00000000 00001101

The right most bit of 12 is 0 whwre as that of 13 is 1, hence the right most bit of

result is 1 as shown above. The resultant is the binary form of 13 which is the

desired output.

45

Lets have another example

class Demo {


{

int x=-12;

int y=13;

x=x|y;


}

}

Output: -3

Here x is a negative number hence it will be stored in the memory in the form of

twos complement.

X=-12 will be stored in the memory as 11111111 11111111 11111111 11110100

Y=13 will be stored in the memory as 00000000 00000000 00000000 00001101

X=x|y will be stored in the memory as 11111111 11111111 11111111 11111101

Clearly the resultant is a negative number since its sign bit is on. To get the final

out put 1st determine the one‟s complement of

11111111 11111111 11111111 11111101which is (by converting 0 to 1 & 1 to 0)

10000000 00000000 00000000 00000010 here sign bit never change its polarity.

Finally add 1 & the output is 10000000 00000000 00000000 00000011. So it is -3.

BITWISE XOR OPERATOR( ^ ):

class demo1

{


{

46

int x = 12;

int y = 13;

x= x ^ y;


}

}

Output :

1

In XOR ( ^) operation when ever the value of a operand is equall to the value of

the same bit of another operand then the the result will contain 0 in that bit else it

will contain 0. In the above program

x = 12 is stored in the memory as 00000000 00000000 00000000 00001100

x = 13 is stored in the memory as 00000000 00000000 00000000 00001101

x = x ^ y the output is 00000000 00000000 00000000 00000001

now we can see that all the bits in 12 and 13 contains same values except the right

most bit which contains 0 incase of 12 and 1 incaze of 13. So the output will only

have 1 in it‟s rightmost place all other bits will have the value 0.

Let‟s see what happens when one of the operands I positive and the other is

negative

class demo1

{


{

47

int x = -12;

int y = 13;

x= x ^ y;


}

}

Output :

-7

In the above example

x = -12 is stored in the memory as 11111111 11111111 11111111 11110100

y = 13 is stored in the memory as 00000000 00000000 00000000 00001101

x = x ^ y the output is 11111111 11111111 11111111 11111001

so we can see that -12 is stored in memory in it‟s two‟s complement form and 13 in

it‟s usuall form. All the bits of the operands except the 2nd and the 3rd bit contain

same value so the output will have all the values 1 except 2nd and 3rd bit ,which will

contain 0. Because we have 1 in the highest bit so it is a negative number so to get

the result we have to convert it into two‟s complement form which will be -7.

Below program shows how to swap two variables without using third

variable through XOR ( ^ ) operator

class demo1

{


{

48

int x = 12 ;

int y = 13 ;

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

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

x = x ^ y ;

y = x ^ y ;

x = x ^ y ;

System.out.println(" AFTER SWAPPING ");

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

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

}

}

Output :

value of x = 12

value of y = 13

AFTER SWAPPING

value of x = 13

value of y = 12

Bitwise Shift Operator

The bitwise Right Shift operator

49

The syntax for bitwise right shift opearator is given below.

Variable >> no.of shifts

Here variable represents the variable on which we want to carry out the shift

operation., and no.of shifts represents the number of bits the value of the variable

should be shifted.

e.g x >> 2 ;

Bitwise right shift operator shifts the bits of a number to a specified number of bits

towars right preserving the signed bit. We can say that the empty bits are filled

with the value of the highest order bit i.e for a positive number it is filled by 0

and for a negative number it is filled by 1.

class demo1

{


{

int i = 5;

i = i >> 2;


i = -5;

i = i >> 2;


}

}

50

Output :

1

-2

Let‟s see what happens in the above example. What actually happens in memory.

i = 5 is stored in the memory as 00000000

00000000 00000000 00000101

i >> 2 value after the shift of two bits towards right 00000000 00000000

00000000 00000001

So after shifting we get the value of I as 1.

But in case of negative numbers there is some difference. We all know that

negative numbers are stored in memory in two‟s complement form and when we

want to see the value it is again converted to two‟s complement and the original

value is shown to us. Now let‟s see

i = -5 is stored in the memory as 11111111 11111111 11111111

11111011

I >> 2 value after the shift of two bits towards right 11111111 11111111

11111111 11111110

so after shifting we get the value of i as -2.

*note : when we use the shift operators on byte and short variables then the values

are shifted to int and the result after evaluation is also int so we should properly

typecast it to get the correct result.

Bitwise Left Shift Operator ( << )

The syntax for bitwise left shift opearator is given below.

Variable << no.of shifts

51



should be shifted.

e.g x << 2 ;

Bitwise left shift operator shifts the bits of a number to a specified number of bits

towards left preserving the signed bit. We can say that the empty bits are filled

with 0 .

class demo1

{


{

int i = 5;

i = i << 2;


i = -5;

i = i << 2;


}

}

Output :

20

-20

52


i = 5 is stored in the memory as 00000000 00000000

00000000 00000101

i >> 2 value after the shift of two bits towards left 00000000 00000000

00000000 00010100

So after shifting we get the value of i as 20 .

But in case of negative numbers there is some difference. We all know that

negative numbers are stored in memory in two‟s complement form and when we

want to see the value it is again converted to two‟s complement and the original



11111011

i >>2 value after the shift of two bits towards left 11111111 11111111

11111111 11101100

so after shifting we get the value of i as -20 .




Bitwise Unsigned Right Sift Operator ( >>> )

The syntax for bitwise right shift opearator is given below.

Variable >>> no.of shifts



should be shifted.

e.g x >>> 2 ;

53

Bitwise unsigned right shift operator shifts the bits of a number to a specified

number of bits towars right without preserving the signed bit. We can say that the

empty bits are filled with 0 .

class demo1

{


{

int i = 64;

i = i >>> 4 ;


i = - 64;

i = i >>> 4 ;


}

}

Output :

4

268435452


i =64 is stored in the memory as 00000000 00000000 00000000

01000000

54

i >>> 4 value after the shift of two bits towards right 00000000 00000000

00000000 00000100

So after shifting we get the value of i as 4 .

here in case of negative numbers also the empty bits are filled with o. We all know

that negative numbers are stored in memory in two‟s complement form and when

we want to see the value it is again converted to two‟s complement and the original



11111011

i>>> 4 value after the shift of two bits towards right 00001111 11111111

11111111 11111111

so after shifting we get the value of i as 268435452.




Short circuit operators && ,||

These operators are used particularly in control statement & loops.

The && operator

If(condition_1 && condition_2)

{

Codes

}

In && operator both condition_1 & condition_2 is checked, if both the parts are true

then codes with in block followed by is executed. If condition_1 is checked as false

then condition_2 is never evaluated.

class Demo {

55


{

int x=9;

int y=0;

if((++x)==10 && (++y)==1)

{

}


System.out.println(y);

}

}

Output: 10

1

In the above piece of code, see the if statement both sides are evaluated because

of && operator. But if first statement is evaluated as false then control never goes

to the second one.

class Demo {


{

int x=9;

int y=0;

if(++x==1&& ++y==1)

{

}

56



}

}

Output:

10

0

See the output first condition is evaluated as false there fore control does not go to

the second condition.

The || operator

If(condition_1 || condition_2)

{

Codes

}

In this case first condition_1 is evaluated & control goes to the second condition

only if condition_1 is false.

class Demo {


{

int x=9;

int y=0;

if(++x==10||++y==1)

{

57

}



}

}

Output:

10

0

See the output. It clearly shows that since 1st condition is evaluated as true control

does not go to the second condition.

class Demo {


{

int x=9;

int y=0;

if(++x==1||++y==1)

{

}



}

}

Output:

58

10

1

Here 1st condition is evaluated as false, there control goes to the second condition.

Ternary if-then-else operator ( ?: )

We can say that we can execute a if else statement using ternary if-then-else

operator ( ?: ). Syntax is given below

Evaluation_Part ? codes_of_section_1 :codes_section_2

First Evaluation_Part is evaluated if it is true then codes_of_section_1 is

excuted else codes_section_2 is executed.

e.g.

class demo1

{


{

int i = 64;

int k=0;

k =(i>k)? 10 : 5;

System.out.println(k);

k= (i<k)? 10: 5;

System.out.println(k);

59

}

}

Output :

10

5

From the above example you can check that the Ternary if-then-else operator ( ?: )

works like if else.

OPERATOR PRECEDENCE TABLE

Highest

() []

! ~ - + ++ --

* / %

+ -

<< >> >>>

< <= > >=

60

== != === !==

&

^

|

&&

||

?:

= += -= *= /= %= <<= >>= >>>= &= ^= |=

Lowest

If there are more than one operators in an expression then they are evaluated

according to their precedence.

61

CHAPTER 5:

CONDITIONAL STATEMENTS AND LOOPS

Decision making and branching:

When a program makes a sequential control code and joins another part of code. Then it is called branching.

Conditional branching: It based on particular condition.

Unconditional branching: This takes place without any

decision.

Control statement:

1. If statement.

2. Switch case statement. 3. Conditional operator.

If statement:

It's a two-way decision making statement, which use in construction with an expression.

a. Simple if.

b. if ... Else. c. Nested if.

d. else.... if ladder.

if statement - of Java will take only the logical value true or false, Java

not allow the integer value as condition, (0 as false and any non-zero

value as true like C and C++).

If statement – of java will allow only the statement which return true or

false, rather than the statement which return any integral value.

62

Simple if:

if (expression) {

statement(s); }

statement (x);

if ...else:

Syntax:

If (test Expression)

{ statement(s);

} else{

statement(s); }

if

Test

?

false

true

Statement of body of if

Exit

63

Nested if ... else:

Syntax:

if (test expression) {

if(test expression) {

statement(s);

} else

{ statement(s);

} }

else statement(s);

Test

Expression

Block of if Block of else

Exit

if

False

True

64

else ... if ... ladder

Syntax:

If

True

Test

Expression

If

False

Test

Expression

Block 3

False True

Block 2 Block 1

Statement x

Exit

65

if (test expression) {

statement(s); }

else if (test expression) {

statement(s); }

else statement(s);

statement(x);

//THIS IS A else-if ladder statement for setting-up a multi-way condition checking

If

false true

true

false

Test

Expression

Exit

If

false

Test

Expression

If

B 3

B 2 B 1

B 4

true

Test

Expression

66

switch ... case statement:

Java has a build in multi-way design statement called a switch.

The switch statement test the value of given variable or expression against the list of case value when a match is found a block of

statement associated with that case is executed. The expression inside the switch case may be an integer or

character.

Value 1, 2, 3, 4, n are constant or constant expression.

Each of these values should be unique in a switch block otherwise, it will hang the computer.

Each case must end with a colon.

If there is no match with any case specified in the switch case than

the default statement is executed.

Each case must be terminated with a break statement.

Syntax:

switch (expression/variable) {

case Val 1: statement(s);

break;

case Val 2: statement(s);

break; case Val 3:

statement(s); break;

default: statement(s)

break; }

Another of the decision making constructs is the switch-case construct which is ideally suited for making multiple choice application, like, for example,

user menus. Typically, in situations where we have one value or expression

67

that has to be exactly matched with a list of pre-defined values or options

the switch … case is the construct of choice. The switch statement is a multiway – decision making construct based

upon the evaluated expression. It gives you a faster way to make a decision

from a multiple number choice, the break statement is require after each

case because if the switch expression contain default then this statement will

execute by default and as well the after finding the require condition it will

go for checking other cases which is a drawback, so it is better to use break

after each case.

Switch(exp)

Entry

Break Case Y

B-1 Val 1

N Break

Y Case

Val 2 B-2

N

Break

Y Case

Val n B-n

N

Default

Statement x

Exit

68

Conditional operator:

Syntax:

Exp1? Exp 2:Exp 3;

e.g. : ((X!= A)?((X>A)?(4X+100):(X+30)):(3X+50));

A program to show compute the net amount paid by the costumer if he purchased Rs. X from mill clothes and Rs. Y from handloom clothes

Looping:

Entry controlled.

Exit controlled. While loop.

Do loop. For loop.

Jump statement. Break.

Continue.

Looping: The process of repeatedly executing a block of statement is called as looping; the

statement in the block may be executed any no. Of time from 0 – n times.

If loop continues forever then it is called as infinite loop. In looping a

sequence of statement executed until some condition for termination of the loop is satisfied.

A program will consist of two parts.

Control statement. Body of the loop.

69

The control statement tests certain condition and then directs repeated

execution of statement. Contain in the body of the loop. Depending upon the position of the condition or the control statement it may

be of two types.

Entry control:

Here control condition is test before the start of the loop execution. It

will not execute the block of statement for once also if the specified

condition is false.

e.g., while (test expression)....

Exit control:

Here test is performing at the end of the body of the loop and before that, the body is executed unconditionally for the first time. It must

run the body of the loop at least once whether the condition is true or false this will not hamper the first execution of the block. E.g.

do...while (test expression).

For loop is the easiest to understand of the loop in Java. The for loop is execute the block of loop for the fixed no. Of time. It's generally used when

you know, before entering the loop, how many time the loop will execute the code.

Here is an example to show the use of for loop in Java.

This is the sample program to show the use of for loop and as well as find

out the whether a no is odd or even from a given set of no.

Entry

if

Test

Expr n

False

True

True

Exit

Increment/

Decrement

Block - 1

70

Entry Control Loop

These are the control statement or control condition tested before the body

start of loop execution. The example of this type of loop is:

e.g.

While (condition)

{

statement(S); }

This loop is run only when the condition is true other wise the will not be executed. This loop is never execute the statement if the condition is false.

Entry

Block - 1

If

True

Test

exprn

False

Exit

71

Exit control loop

These are the control statement or control condition is placed at the end of

the body of the loop and before that the body is executed un-conditionally at least for one time, which is not possible in the case of Entry control loop.

do

{ statement(s);

} while (condition);

Step in looping process:

1. Setting and initialization of a counter.

2. Execution of statement in the loop.

3. Test for a specified condition for execution of loop. 4. Incrementing or decrementing the counter.

while loop (Entry control loop)

Initialization

If

N Exit Test

exprn

Y

Statement(s)

72

while loop:

initialization;

while (test condition) {

Loop body; }

Here when the test condition is fails control is transfer out of the loop

otherwise loop will be continue or repeated. Here the body of the loop may be executed at all if the condition

doesn't satisfy for 1st time. Here also the expression (Test condition) should return only the true

and false rather than any integer value as we have in C and C++.

e.g.:

sum = 0; add = 1;

while(n<=10) {

sum=sum+n; n=n+1;

} System.out.println(sum);

Do while statement (Exit control loop)

Initialization

do

Body of loop

While

Y

Test

Condition

N

Exit

73

do while loop:

initialization

do {

Body of the loop } while (test condition);

Free from language free from any indentation.

Since the test, condition is provided at bottom of the loop it always executed at least one.

This loop will executed till the condition is true.

The program to show the use of do while loop.

Example-1

/* find out the sum of the first ten natural no. */

class Test1

{ public static void main (String args[])

{ int s=0,n=1;

do{ s=s+n;

n++; } while (n<=10);

System.out.println ("Summation of the fist ten natural no. : "+s); }

}

For loop (Entry control loop)

Format:

for (initialization; test condition; increment or decrement)

{ Loop body;

}

74

Body of loop of this loop may not be executed at all if the specified condition fails at the start.

Example-2

/* Find out the sum of the first ten natural no. */

class Test2 {

public static void main(String args[]) {

int s=0;

for (int n=1;n<=10;n++) {

s=s+n; }

System.out.println("Summation of the fist ten natural no. : "+s); }

}

Additional feature of For loop:

More than one variable can initialize at a time in for loop statement.

The increment section also must have more than one part. Test condition may have any compound relation and testing may not

be limited only two loop control variable.

We can use expression in the assignment statement of initialization of increment section.

Both initialization and increment in the for statement. We can setup time delay using null statement using for loop.

Nesting of for loop:

for(initialization; condition; increment or decrement){ for(initialization; condition; increment or decrement){

statement(s);} statement(s);}

75

Example-3

public class Nest1

{ public static void main(String args[])

{ int i=0,j=9;

do{ i++;

if(j--<i++)

{ break;

} } while (i<5);

System.out.println(i+"\t"+j); }

}

Output:-

Example-4

public class Nest2

{


int j=0; do

for(int i=0;i++<2;) System.out.println(i);

while(j++<2)

} }

76

Output:-

Jumping statement in loop:

Break and continue:

Java permits to jump from one statement to the end or beginning as well as jump out of a loop.

An early exit from a loop can be accomplished using a break statement.

In case of nesting loop break will exit only a single loop. e.g.

1. while(condition)

{ statement(s);

if (condition) break;

statement(s); }

2.for(int i=0;i<10;i++)

{ statement(s);

if(condition) break;

statement(s); }

77

3.do {

statement(s); if(condition)

break; statement(s)

}while(condition);

Continue causes the loop to be continue of to the next iteration of the skipping statements.

In while and do loops continue causes the control to go directly to test

the condition and then continue the iteration process.

In for increment section of for is executed before the test condition is

evaluated.

Label loops:

In java we can give, a label is a valid variable name followed by colon.

If we want to jump outside nested loop or continue at an outer loop we can use label break or label continue statement.

Example-5

public class Loop

{ static String o="";


z: for(int x=2;x<7;x++)

{ if(x==3)continue;

if(x==5)break z; o=o+x;

} System.out.println(o);

}

78

}

Output:-

Brain Drill

Assignment-1

Enter a number and check it is an Armstrong number or not?

import java.io.*;

public class Armstrong

{

public static void main(String args[])throws Exception

{

int n,t=0,s=0,r=0;

BufferedReader br=new BufferedReader(new

InputStreamReader(System.in));

System.out.println("Enter A Number");

n=Integer.parseInt(br.readLine());

t=n;

while(n>0)

{

r=n%10;

s=s+(r*r*r);

n=n/10;

79

}

if(t==s)

System.out.println("Armstrong Number is "+t);

else

System.out.println("Not an Armstrong Number

"+t);

}

}

Output:-

Assignment-2

Enter a number from keyboard and check it is Prime number or not?

import java.io.*;

public class PrimeCheck

80

{


{

int a=0,b=1,c=0;



System.out.println("Enter A Number");

a=Integer.parseInt(br.readLine());

while(b<=a)

{

if(a%b==0)

{

c=c+1;

}

b++;

}

if(c==2)

{

System.out.println("Prime Number Is "+a);

}else{

System.out.println("Not A Prime Numer

"+a);

}

}

81

}

Output:-

Assignment-3

Enter a number and count how many prime number are present

within it?

import java.io.*;

public class PrimeCount

{


{

int a=1,r;



System.out.println("Enter a Number");

82

r=Integer.parseInt(br.readLine());

while(a<=r)

{

int b=1,c=0;

while(b<=a)

{

if(a%b==0)

c=c+1;

b++;

}

if(c==2)

System.out.println("Prime Number is "+a);

a++;

}

}

}

Output:-

83

Assignment-4

Enter A Character and find out the ASCII value of that number?

import java.io.*;

public class Ascii

{


{

System.out.println("Enter A Character and findout the Ascii value");

byte b=(byte)System.in.read();

System.out.print(b);

84

}

}

Output:-

Assignment-5

Enter A Number and check it is a Binary Number or not?

import java.io.*;

public class BinaryCheck

{


{

int r,c,n,t;



System.out.println("Enter Binary Number");


t=n;

c=r=0;

85

while(n>0)

{

if(n%10==0 || n%10==1)

c++;

r++;

n=n/10;

}

if(c==r)

{

System.out.println("It is a Binary Number");

}else{

System.out.println ("It Is not a binary number");

}

}

}

Output:-

86

Assignment-6

Enter A Number and Find Out The Factorial?

import java.io.*;

public class Factorial

{


{

int n,f,i;



System.out.println("Enter any Numer");


i=n;

f=1;

while(i>0)

{

f=f*i;

i--;

}

System.out.println ("Factorial of "+n +" Is "+f) ;

}

}

Output:-

87

Assignment-7

Enter A Number and add each digit of that number?

import java.io.*;

public class SumDigit

{


{

int r=0,s=0,n;



System.out.println("Enter Any Number");


while(n>0)

{

r=n%10;

s=s+r;

n=n/10;

}

System.out.println("Sum Of Digit Is "+s);

}

88

}

Output:-

Assignment-8

See the Pyramid and Draw It?

import java.io.*;

public class Pyramid1

{


{

int i,j,row;

89



System.out.println("Enter The Number Of Rows");

row=Integer.parseInt(br.readLine());

for(i=1;i<=row;i++)

{

for(j=1;j<=i;j++)

{

System.out.print("* ");

}

System.out.print("\n") ;

}

}

}

Assignment-9

See The Pyramid and Draw It?

90

import java.io.*;

public class Pyramid1

{


{

int row=0,t=0,i=0,j=0,k=0,s=0;





t=1;

for(i=1;i<=row;i++)

{

for(j=0;j<(row-i);j++)

System.out.print(" ");

s=(2*i)-1;

for(k=0;k<s;k++)

{

if(t<10)

System.out.print(" "+t);

else


t++;

}

System.out.print("\n\n") ;

91

}

}

}

Assignment-10

Draw A Number Triangle?

import java.io.*;

public class NumberTriangle

{


{

int i,j,t=1,row;



System.out.println("Enter number of rows");


92

for(i=0;i<row;i++)

{

for(j=0;j<=i;j++)

{

if(t<10)

{


}else{


t++;

}

}

System.out.print("\n");

}

}

}

93

Assignment-11

Draw A Pascal Triangle?

import java.io.*;

public class Pascal

{


{

int b,p,q,r,x;



r=Integer.parseInt(br.readLine());

b=1;

q=0;

System.out.println("Pascal's Triangle");

while(q<r)

{

for(p=30-3*q;p>0;p--)

System.out.print(" ");

for(x=0;x<=q;x++)

94

{

if(x==0 || q==0)

b=1;

else

b=(b*(q-x+1)/x);

System.out.print(" "+b);

}

System.out.print("\n") ;

q++;

}

}

}

95

CHAPTER 6 :

CLASS FUNDAMENTALS

I must say this is the most important chapter, the foundation

on which the entire java programming language is developed. It‟s my

sincere advice to the reader to be careful & focused. Class can be defined as

a template or an abstract model. It contains variables and methods which

are required to modify the values of the variables belonging to the particular

class. An object is known as the instance of a class. Class templates takes

no memory, when object is created memory is allocated.

Local variable

Example-1

class p

{

public static void main (String args [ ])

{

int x;


}

}

Above program generates compilation error . The error is given below


The local variable x may not have been initialized at .p.main(p.java:5)

Above program will result a compilation error. x is a local variable. In java

each local variable has to be initialized before they are used other

wise it will give compilation error. Local variable scope is the method

(including constructor) where it is declared. It is invisible to outside the

method. Therefore it cannot be accessed from out side the method. In

96

C/C++ an uninitialized local variable takes garbage value. But, there is no

such thing called garbage value in java.

Example-2

class p

{

public static void main(String args[ ])

{

int x=3;

{-/

int x=7;


}


}

}

Above program generates compilation error. The error is given below


Duplicate local variable x

at p.main(prj1.java:5)

Output: compilation error. In C/C++ block scope is there inside the

function but java doesn‟t define block scope inside method, be

careful with this. So inside a method we cannot have more than one

variable having same name.

97

Creation of object

Object is created by calling the constructor of the corresponding class

through new operator.

Example-3

class p

{

public static void main(String a[ ])

{

p x=new p();

/*x is known as reference variable of class p. Through new operator

constructor is called to create the object of class p.*/

}

}

If an object having no reference is created then it is called orphan object.

Example-4

class p

{


{

new p();

//orphan object is created

}

}

98

Constructor is used to create the object of the corresponding class.

Therefore constructor name must be same as that of the class

name. It‟s a rule OOP.

Constructor does not have any return type.

Constructor cannot use any access modifier.

Constructor is of two types

Parameterize constructor

Non-parameterize or default constructor

Constructor cannot be over ridden but cannot be over loaded.

Note:

If there is no constructor defined by the programmer then JVM

automatically recognize the default constructor but, if the programmer

define the parameterize constructor & call the default constructor then

compile time error occurs.

Check it out:

Example-5

class p

{

p(int i)

{

System.out.println(“Hello, World!!”);

}


{

p x=new p();

}

}

Above program generates compilation error. The error is given below

99


The constructor prj1() is undefined

at p.main(prj1.java:8)

So the solution is either the programmer has to define a default constructor

or only can call the parameterized constructor that has been defined by the

programmer.

static modifier

“static” is a key word or modifier in java.

static variables are declared outside the method & constructor.

If the static variable is not initialized then it takes the default

value of the data type.

There is only one copy of the static variable exist for a

particular class.

It is directly accessed within a non static method & constructor.

static variables can be accessed through class name, object

name & directly with in a static method.

If a method is static then the programmer can call the method

without creating the object of the corresponding class.

Example-6

class p

{


{

fun();

//fun is a static method & main is static therefore main can call

fun directly.

p.fun();

//fun can be called through class name since fun is static

p x=new p();

100

x.fun();

//fun can also be called through object name.

}

static void fun()

{

System.out.println("Hello!");

}

}

Output will be

Hello!

Hello!

Hello!

Example 7:

class p{

public static void main(String f[ ])

{

p x=new p();

x.fun1();

}

static void fun()

{

System.out.println("Hello!");

}

101

void fun1()

{

System.out.println("Hie");

fun();

// fun is called directly from a non-static method

p.fun();

//fun is called from non static method through class name.

p x=new p();

x.fun();

//fun is called from a non static method through object name.

}

}

Output will be

Hie

Hello!

Hello!

Hello!

Instance variable

It is declared outside the method & constructor.

If the instance variable is not initialized then it takes default

value of the data type.

Same named instance variable cannot be in a single class.

It is accessed by its name inside non static method.

It is accessed by the object name inside a static method.

Instance variables are known as class member variable.

Size of an object is equal to the size of instance variables

present in the corresponding class.

102

Methods

Class consist instance variables and the methods to manipulate those

instance variables. Now we are going to discuss the fundamentals about

methods. The syntax of declaring a method is

return_type method_name ( parameters );

Here return_type indicates the type of data returned by the method. The

return type of a method can be of any valid data type, including the user

defined classes. If the method does not returns any value it‟s return type

must be void. return keyword is used to return a value from a method.

e.g. return value ;

Here value represents the value that is returned from method.

method_name represents the name of the method. It can be any legal

identifier.

parameters are the variables that receive the value of the arguments

passed to the method when it is called. If the method has no parameters,

then the parameter list will be empty.

Adding a simple method to class

Now we will see how to a simple method to a class.

Example-8

// This program uses a method.

class Rectangle

{

double width;

double height;

103

// compute and return volume

double area()

{

return width * height ;

}

}

class RectangleDemo

{


{

Rectangle rec1 = new Rectangle();

double area;

// initialize each rectangle

rec1.width =10 ;

rec1.height = 20;

// get area of first rectangle

area = rec1.area();

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

}

}

Output :

Area is 200.0

In the above example we used a method called area to calculate the area of

a Rectangle object.

104

Adding a Parameterized Method to a Class

In addition to defining methods that provide access to data, you can also

define methods that are used internally by the class itself.

Example-9

// This program uses a parameterized method.

class Rectangle

{

double width;

double height;


double area()

{

return width * height ;

}

// sets dimensions of the rectangle

void setValue(double w, double h)

{

width = w;

height = h;

}

}

class RectangleDemo

{


105

{



double area;

// initialize each rectangle

rec1.setValue(10, 20);

rec2.setValue(3, 6);


area = rec1.area();


// get area of second rectangle

area = rec2.area();


}

}

Output :

Area is 200.0 Area is 18.0

As you can see, the setValue( ) method is used to set the dimensions of

each rectangle. For example, when rec1.setValue (10, 20); is called, 10 is

copied into parameter w and 20 is copied into h. Inside setValue( ) the

values of w and h are then assigned to width and height respectively. The

area() method is used to calculate the area of each rectangle and then the

calculated value is returned.

106

Constructor

A constructor is used to create the object when it is invoked through new

operator. 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 when the object is created, before the new

operator completes. Constructors do not have any return type. It is quite

obvious not to have return type of constructors. Lets rework the Rectangle

example so that the dimensions of a rectangle are automatically initialized

when an object is constructed. To do so, replace setValue( ) with a

constructor. Let‟s begin by defining a simple constructor that simply sets the

dimensions of each rectangle to the same values. This version is shown

here:

Example-10:

class Rectangle {

double width ; double height ;

//This is the constructor for Rectangle.

Rectangle()

{ System.out.println("Constructing Rectangle");

width = 10; height = 10;

}

// compute and return area

double area()

{ return width * height ;

} }

class RectangleDemo

{


107

// declare, allocate, and initialize Rectangle objects

Rectangle rec1 = new Rectangle(); Rectangle rec2 = new Rectangle();

double arae;


arae = rec1.area();

System.out.println("area is " +arae);

// get area of second rectangle arae = rec2.area();

System.out.println("area is " + arae);

}

}

Output :

Constructing Rectangle Constructing Rectangle

area is 100.0 area is 100.0

As you can see, both rec1 and rec2 were initialized by the Rectangle( )

constructor when they were created. Since the constructor gives all

rectangles the same dimensions , 10 by 10 , both rec1 and rec2 will have

the same area. Rectangle rec1 = new Rectangle(); new Rectangle( ) is

calling the Rectangle( ) constructor. When you do not explicitly define a

constructor for a class, then Java creates a default constructor for the class.

This is why the preceding line of code worked in earlier examples of

Rectangle class where we have not defined a constructor. The default

constructor automatically initializes all instance variables to zero.

Parameterized Constructors

108

To set different values for different object of Rectangle class we can use

parameterized constructor .The following example defines a parameterized

constructor which sets the dimensions of a rectangle as specified by those

parameters.

Example-11

class Rectangle {

double width;

double height; // This is the constructor for Rectangle.

Rectangle(double w, double h) {

width = w; height = h;}

// compute and return area double area() {

return width * height ; }

} public class RectangleDemo {


// declare, allocate, and initialize Rectangle objects Rectangle rec1 = new Rectangle(10, 20);

Rectangle rec2 = new Rectangle(3, 6); double arae;

// get area of first rectangle arae = rec1.area();

System.out.println("area is " +arae); // get area of second rectangle

arae = rec2.area(); System.out.println("area is " +arae);

}

}

Output :

area is 200.0 area is 18.0

109

See, each object is initialized as specified in the parameters to its

constructor. For example, in the following line, Rectangle rec1 = new

Rectangle(10, 20); the values 10 and 20 are passed to the Rectangle( )

constructor when new creates the object. Now width and height of rec1 will

contain the values 10 and 20 respectively. Note : if we define a

parameterized constructor for a class we have to also define the constructor

taking no arguments otherwise we can only make call to the parameterized

constructor, making call to the default constructor will show an error. For

example

Example-12

class Rectangle {

double width; double height;

// This is the constructor for Rectangle. Rectangle(double w, double h) {

width = w; height = h;

}

// compute and return area double area() {

return width * height ; }

} public class RectangleDemo {

public static void main(String args[]) { // declare, allocate, and initialize Rectangle objects

Rectangle rec1 = new Rectangle(10, 20); Rectangle rec2 = new Rectangle(); // this line will result an error

double area;

// get area of first rectangle area = rec1.area();

System.out.println("area is " + area); // get area of second rectangle

area = rec2.area(); System.out.println("Volume is " + area);

} }

110

Output :


The constructor Rectangle() is undefined

at RectangleDemo.main(RectangleDemo.java:18)

The above program will result in an compilation error. Because in the line

Rectangle rec2 = new Rectangle(); // this line will result an error we

make call to the default constructor , but we have not defined the default

constructor. So it is the duty of the programmer to define the default

constructor whenever he is defining a parameterized constructor, if he is

going to use the default constructor.

Overloading Methods

When we define two or more methods within the same class that have the

same name, but take different types of arguments, then the methods are

overloaded. Method overloading is a powerful feature of Java. In OOP

terminology method over loading is termed as static binding or static

polymorphism. I hope reader can sense that when a method is invoked, only

the method name is not sufficient to uniquely determine a method, along

with the method name the type of argument method is taking is also

necessary. When an overloaded method is invoked, JVM invokes the method

according to the type and/or number of arguments the method is taking. In

case of method overloading method name must be same where as differ in

the type and/or number of their parameters. In case of method overloading

methods may have same or different return types.

Example-13

// method overloading.

class Overload { void show() {

System.out.println("No parameters"); }

111

// Overload show for one integer parameter.

void show(int a) { System.out.println("a: " + a);

} // Overload show for two integer parameters.

void show(int a, int b) { System.out.println("a and b: " + a + " " + b);

} // overload show for a double parameter

double show(double a) { System.out.println("double a: " + a);

return a*a; }

} class Demo{


Overload ob = new Overload(); double result;

// call all versions of test() ob.show();

ob.show(10); ob.show(10, 20);

result = ob.show(20.25); System.out.println("Result of ob.show(20.25): " + result);

}

}

Output:

a: 10 a and b: 10 20

double a: 20.25

Result of ob.show(20.25): 410.0625

As we can see, show( ) is overloaded four times. The first method takes no

parameters, the second takes one integer parameter, the third takes two

integer parameters, and the fourth takes one double parameter.

Overloading Constructors

We can also overload constructors.

Example-14

112

Let see the example below

/* Here, Rectangle defines three constructors to initialize

the dimensions of a rectangle in various ways. */

class Rectangle { double width;

double height; // constructor with two arguments

Rectangle(double w, double h) { width = w;

height = h; }

// constructor with no arguments Rectangle() {

width = 25;

height = 25; }

// constructor with one argument Rectangle(double var) {

width = height = var; }


double area() { return width * height ;

} }

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

// create rectangles using the three constructors

Rectangle rec1 = new Rectangle(10.0, 20.0); Rectangle rec2 = new Rectangle();

Rectangle rec3 = new Rectangle(15.0); double arae;

// get area of rec1 arae = rec1.area();

System.out.println("area of rec1 is " + arae); // get area of rec2

arae = rec2.area(); System.out.println("area of rec2 is " + arae);

// get area of rec3 arae = rec3.area();

System.out.println("area of rec3 is " + arae);

113

}

}

Output :

area of rec1 is 200.0 area of rec2 is 625.0

area of rec3 is 225.0

Here the required constructors are called according to the type and/or

number of arguments.

finalize( )

Usually during the training of new comers in java a question always asked

by loyal C++ programmer is what the corresponding tool of C++ destructor

in java. The answer is finalize() method. finalize() method is called just

before the object is garbage collected. Before an object is garbage collected

garbage collector implicitly calls finalize() method of object class.

The syntax of finalize( ) method is :

public void finalize( )

{

// finalization code here

}

this Keyword

To allow a method to refer to the object that invoked it , Java defines the

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

object. this is always a reference to the object on which the method was

invoked.

Example-15

To get a clear view what this refers to, consider the following example

/* Here, Rectangle defines three constructors to initialize

114

the dimensions of a rectangle in various ways.

*/

class Rectangle {

double width;

double height;

// constructor with two arguments

Rectangle(double w, double h) {

this.width = w;

this.height = h;

}

// constructor with no arguments

Rectangle() {

this.width = 25;

this.height = 25;

}

// constructor with one argument

Rectangle(double var) {

this.width = this.height = var;

}


double area() {

return this.width * this.height ;

}

}

115

public class RectangleDemo {


// create rectangles using the three constructors

Rectangle rec1 = new Rectangle(10.0, 20.0);


Rectangle rec3 = new Rectangle(15.0);

double arae;

// get area of rec1

arae = rec1.area();


// get area of rec2

arae = rec2.area();


// get area of rec3

arae = rec3.area();


}

}

Output :




This example operates exactly like the previous example.here instead of

using only the variable name inside the methods and constructors we have

used this.variable name to assign values

116

to the variables of the invoking objectof Rectangle class . Inside Rectangle(

), this will always refer to the invoking object. this is useful in various

contexts.

Static and Non Static block in java

Block starts with a „{‟ and ends with „}‟. Syntax is

{

//Java codes;

}

In java there are two types of blocks one is Static block and the other one is

the non static block.

Static block

Whenever a block is declared with the static keyword, then it is known as

static block. Its syntax is

static {

//Java codes;

}

The nature of static block is that the codes inside it gets executed

before the main method is execute i.e. when you run the class file first the

codes within the static block is executed and after that the main method

starts execution. Let‟s have an example to know how it exactly behaves

Example-16

class Demo

{

static {

System.out.println("Samita is in Static block");

}

117

public static void main ( String ag[])

{

System.out.println("Samita is in main method");

}

}

Output :

Samita is in Static block

Samita is in main method

From the above example we can see that first the code inside the static

block is executed and afer that the code inside the main method is executed.

By the use of static block we can execute any code before main is called.

Example is given below

Example-16

class Demo

{

static {

System.out.println("Lory is inside static block");

int a=5;

int b=6;

int x= a+b;

System.out.println("Value of x= "+x);

}

public static void main(String ag[])

{

118

}

}

Output :

Lory is inside static block

Value of x= 11

In the above example you can see that we have printed a statement,

calculated the value x and displayed it without writing it inside main method.

Example-17

public class Demo

{

static {

System.out.println("Lory is in the first Static block");

}


{

System.out.println("Lala is in the main method");

}

static{

System.out.println("Samita is in the second static block");

}

}

Output :

Lory is in the first Static block

Samita is in the second static block

119

Lala is in the main method

In the above program there are two static blocks so they will be executed

sequentially one after another before main method is executed , it doesnot

matter whether we put the static block above or below main method .

An interesting fact can we execute a java program without main method?

Answer is yes!! Foxed folks

Example-18

Test.java

Class Demo{

static {

System.out.println(“hello world”);

System.exit(0);

}

}

Compile it javac Test.java

Run it by java Demo

Out put is hello world

Actually when we call System.exit(0) in side static block, it forces the

termination of the program.

Note : Static block cannot be declared inside any method.

Static block is executed only once.

Non Static block

A block without static key word is known as Non Static block. The

statements inside the Non Static block gets executed whenever a object of

that class is created.

120

Example-19

Let‟s see a example.

public class Demo

{

{

System.out.println("Lory is in the first Non Static block");

}

Demo()

{

System.out.println("Asim is inside the constructor");

}


{

System.out.println("Lala is in the main method");

Demo a= new Demo();

Demo a1= new Demo();

}

{

System.out.println("Samita is in the second Non static block");

}

}

121

Output :

Lala is in the main method

Lory is in the first Non Static block

Samita is in the second Non static block

Asim is inside the constructor

Lory is in the first Non Static block

Samita is in the second Non static block

Asim is inside the constructor

In the above example we can see that whenever a object of the class

containing the non Static blocks is created the non Static blocks are

executed first sequentially before the codes inside the constructors of the

class is executed. And also we can see that every time when a object of that

class is created the Non static blocks are again executed.

122

Chapter-7

Object Reference

Does JAVA have memory pointer?? Billion Dollar Question!! My

experience with JAVA says JAVA has memory pointer but not as prominent

as in case of C/C++. Reference variables behave like pointers. In computer

terminology reference variable means such a variable which can hold the

address.

p.java

class p

{

int x;

public static void main(String args[ ]) {

p z=new p( );

z.x=3;

System.out.println(z.x);

}

}

This is a simple java program. Here p is a class

having an instance variable x. To create an object of class p we have to call

the default constructor of class p through new operator. The job of new

operator is to allocate memory dynamically during runtime. z is known as

reference variable of class p. As I have said reference variable holds the

address of a memory location. In java memory management is completely

done by JVM. After compiling above java code p.class file is created. During

123

the execution of p.class file first it is loaded in the memory by the boot

strap class loader which is a component of JVM. „z‟ is a reference variable

which is created inside stack area. When the constructor of class p is called

through new operator memory chunk is allocated from heap area and it‟s

starting address is stored in z & we say that object of class p is created.

Then, how much memory will be allocated? The amount of memory that is to

be allocated depends up on the sum of size of instance variables belonging

to that class. If the class contains a reference variable as an instance

variable then 4 byte memory will be allocated for that. Static variables

& methods are not the part of an object, so they are stored in different part

of memory known as method area. In its entire life z will hold the starting

address of the memory chunk that has been allocated to it from heap area

unless until a new memory chunk is allocated to it by calling the constructor

through new operator. When z will die the memory chunk allocated to it is

freed by garbage collector.

Diagram1:

124

STACK HEAP

Z

566656

z is the reference variable

created inside STACK

566656

int x

When the constructor of

class p is called through new

operator memory chunk is

allocated from heap area and

it‟s starting address

(566656)is stored in z.

The swapping problem

If you have understood the concept of reference then this

problem is going to test your depth.

Example-1

p.java

class p

{

int x;

125


{

p a=new p();

a.x=1;

p b=new p();

b.x=2;

valueSwap(a,b);

System.out.println(a.x);

System.out.println(b.x);

}

static void valueSwap(p k,p l)

{

int i=k.x;

k.x=l.x;

l.x=i;

}

}

Out put is

2

1

126

Example-2

class q

{

int x;


{

q a=new q();

a.x=1;

q b=new q();

b.x=2;

valueSwap(a,b);

System.out.println(a.x);

System.out.println(b.x);

}

static void valueSwap(q k,q l)

{

q temp;

temp=k;

k=l;

l=temp;

}

}

Out put is

127

1

2

Output of p.java & q.java is different. Why?

Consider p.java program. „a‟ & „b‟ are reference variables created inside

stack area. When we call the constructor through new operator, memory is

allocated from heap. Assume that 1000 is the starting address of the

memory chunk allocated to „a‟ & 5000 is starting address of the memory

chunk allocated to „b‟ as shown in the figure.

STACK HEAP

a

1000

B

5000

1000

x=1

5000

x=2

128

valueSwap() method takes a & b as its argument. In valueSwap()

method content of a is copied to k & content of b is copied to l. Now k=1000

& l=5000. „k‟ & „l‟ are the local reference variables of valueSwap() method

created inside stack.

In side the function valueSwap() the code int i=k.x; implies i‟s value is 1.

Code k.x=l.x; means the content of x present in the memory chunk whose

starting address 1000 is changed to 2.Similarly the code l.x=i; means

content of x present in the memory chunk whose starting address is 5000 is

changed to 1. Now the feature is described below.

X=2

1000

X=1

5000

HEAP

STACK

When control goes out of the method valueSwap() although the reference

variables k & l become dead but the changes they have made in heap area is

permanent. When control goes back to main() method the changes reflected

there as shown in the figure

K

1000

L

5000

129

STACK HEAP

a

1000

B

5000

1000

x=2

5000

x=1

Now consider the 2nd program q.java. up to the function call

valueSwap(), everything is similar to that of p.java. Here inside the method

valueSwap() of the program q.java things are different. „temp‟ is an

reference of class q. temp=k; means now temp=1000;, k=l; means

k=5000 & l=temp; means l=1000. When control goes out of the method

valueSwap(), k&l become dead because they are local reference variables

created inside stack. Hence changes are not reflected.

130

One has to understand the concept that local variables always die

when control goes out of a method. But, if the local variables are of

reference type then the changes they have made in the memory locations

they are pointing are permanent.

Hash code

When an object is created through new operator by

calling the constructor of the corresponding class a unique identifier is

assigned to the reference variable, known as hash code. Hash code is

allotted by JVM. How to determine the hash code?

Example-3

class p {


{ p x=new p();

System.out.println(x.hashCode()); }

}

The method hashCode() returns the hash

code of the corresponding reference when object is created. Hash code is

assigned only to reference variables when memory is allocated from heap

area.

Local variables of primitive data types are created

inside stack area & memory is allocated from there also. All the above

complexities are not involved here. Local variables of primitive data types do

131

not have any hash code because they do not acquire memory from heap

area. To get hash code the variable must be of reference type.

Example-4

class p

{

public static void main(String f[ ])

{

int mak=5;

System.out.println(mak.hashCode());

}

}

Above program will result a compilation error because mak is not a reference

variable & memory is not allocated to it from heap. The error is “int can not

be dereferenced”. The next question that arises is it possible to allocate

memory to variables of primitive data type from heap & the answer is yes. I

will explain it in array.

A note from author: Ok, our voyage of “OBJECT & REFERENCE”

is completed. But, there is a mystery still to be unrevealed.

Mystery is about static variables. Static variables are created

inside method area. Objects are inside heap. References are

inside stack. Static variables can be accessed by reference

variables, but only after the object is created by invoking the

constructor of the class through new operator, other wise

compilation error will arise. When an object is created inside

heap, along with the instance variables it also contains a

pointer to the memory location of method area which contains

the static variables of corresponding class. All the objects of a

particular class contains pointer which holds the address of

same particular memory location inside method area

containing the static data member of that class.

132

Chapter-8

Array

Array is a linear homogeneous data structure. It is simply

a collection of similar type elements. An element present in the array is

accessed through its index. You can define an array either as int[ ] arr; Or

as int arr[ ]. But the former one is preferred by most java programmer. A

specific element of an array is accessed by the index. The syntax of one

dimensional array declaration is

Data_Type variable_name [ ] =new Data_Type[size];

Or

Data_Type [ ] variable_name=new Data_Type[size];

Here Data_Type specifies the type of array that is created, size specifies

number of elements in the array, and variable_name is the array variable or

in particular a reference variable of the corresponding data type. But, things

are quite different in case of an array of objects.. The 1st element of the

array is accessed by placing 0 in the [ ]. 0th index represents the 1st element

of the array.

Example-1

public class Demo

{

public static void main(String[] args) {

int[] arr=new int[2]; System.out.println(arr[0]);

System.out.println(arr[1]); }

}

Output is

0

0

133

In general to create an array you must follow three steps

Declaration

Construction

Initialization

Declaration tells the java compiler what the array‟s name is and what the

type of its elements will be. For example,

int[ ] ints;//ints ia an integer array variable

double[ ] dubs;//dubs is a double array variable

char[ ] chars//chars is a character array variable.

float[ ] floats;//floats is a float array variable.

Construction means calling the new operator to allocate memory for the

array variable. During initialization process the elements of the array is

initialized to their default values.

Array Element Initialization Values

Element Type Initial Values

Byte 0

Int 0

Float 0.0f

Char „\u0000‟

Short 0

Long 0L

Double 0.0d

Boolean false

reference null

134

In the above program array constructed where it is declared. You can

separate the process.

Example-2

public class Demo {

public static void main(String[] args)

{ int[] arr;//array declaration

arr=new int[2];//array construction System.out.println(arr[0]);

System.out.println(arr[1]); }

}

A closer look at array

Example-3

public class Demo


{ int [ ]mak=new int[3];

//Array declaration in java mak[0]=1;

mak[1]=2; mak[2]=3;

System.out.println(mak[0]); System.out.println(mak[1]);

System.out.println(mak[2]); }

}

Output is

1 2

3

int mak[ ]=new int[3]; is the statement to create the integer array of

length 3. Remember that new operator always allocates memory

from the heap. If [ ] is associated with variable declaration then, that

variable is of reference type. So „mak‟ is a reference type variable that

135

means it is going to hold the address of a memory location. The new

operator allocates memory from heap according to the size specified & the

starting address is stored in mak. The memory is allocated continuously for

mak from heap.

„mak‟ is the reference variable created inside stack. The new operator

allocates memory from heap & the starting address of the memory location

i.e. 65556 is stored in mak. Since for array continuous memory allocation is

done & integer takes 4 byte of memory therefore the address of the next

memory location is 65560 & so on.

To access the elements present in the array the statement is

System.out.println(mak[0]); System.out.println(mak[1]);

System.out.println(mak[2]); Value

stored in mak

mak[0] means value stored at (65556+0* size of integer )

mak[1] means value stored at (65556+1* size of integer)

mak[2] means value stored at (65556+2*size of integer)

136

In general if you have declared

Data_Type [ ]var_name=new Data_Type[size];

var_name[i] means value stored at (starting address+ i* size of

Data_Type)

here i is an integral index & i<size.

If the data type is of object reference then size will be 4 bytes.

Array actually are objects, even to an extent you can execute methods on

them, mostly of the object class. But, you can not create child class or sub

class of an array.

Creating a programmer-initialized array

Example-4

public class Demo


{ int [ ]mak={1,2,3};


mak[1]=2; mak[2]=3;

System.out.println(mak[2]); }

}

Output is 3

One may think that how array is created with out new operator. In the

above situation java compiler implicitly calls the new operator to allocate

memory from heap.

Accessing the element beyond the size of an array throws a compile time

error as shown in the program below.

137

Example-5

public class Demo

{


int [ ]mak={1,2,3}; //Array declaration in java

mak[0]=1; mak[1]=2;

mak[2]=3; System.out.println(mak[3]);

}

}

This program generates an Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3

at Demo.main(Demo.java:13)

Creation of reference to a primitive:

This is a useful technique to create a reference of primitive data type. Array

in java provides such technique. In this procedure the data is stored in heap

instead of stack. Simply you just create an array of one element of primitive

data type

Example-6

public class Demo {


int [ ]mak=new int[1];


changeIt(mak); System.out.println(mak[0]);

} static void changeIt(int []p)

{ p[0]=100;

}

138

}

Out put are 100

Due to reference change is reflected.

MULTIDIMENTIONAL ARRAY

Two dimension array:

To declare a multidimensional array variable, specify each additional index using another set of square brackets. For example, the

following declares a two-dimensional array variable called twoD.

int twoD[ ][ ] = new int[4][5];

This allocates a 4 by 5 array and assigns it to twoD.

[0][0] [0][1] [0][2] [0][3] [0][4]

[1][0] [1][1] [1][2] [1][3] [1][4]

[2][0] [2][1] [2][2] [2][3] [2][4]

[3][0] [3][1] [3][2] [3][3] [3][4]

Left index indicates row number & right index indicates column number. A closer look at two dimensional array. The declaration Int [][]town;

town=new int[3][3]; Or int [][]town=new int[3][3] creates a two dimensional array. What exactly town is?. town in fact a reference to an

array of integer reference. Surprised!!,(If you are good in c,c++ you can feel that it is something like pointer to an array of pointers.)

A closer look at two dimensional array.

139

The declaration

Int [][]town;

town=new int[3][3];

Or

int [][] town=new int[3][3] creates a two dimensional array. What

exactly town is?. town in fact a reference to an array of integer reference.

Surprised!!,(If you are good in c,c++ you can feel that it is something like

pointer to an array of pointers.)

In the statement town=new int [3][3]; it is the number of

rows.Actually no of rows represents the number of integer references to

which town is pointing.The no.ofcolumn represents the length of the integer

array towhich each element of the array of references pointing. Confused!!!

Ok lets have the snap short of memory representation of two dimensional

array .

Really is it happens! Yes 100%.Fine lets check it out programmatically.

140

Exampe-7

class demo

{

Public static void main(String args[])

{

Int [][]town=new int[4][];

System.out.println(town[0]);



}

}

OUTPUT:

null

null

null

Why null null null ?

As I have said earlier in java when you create an array all the elements are

initialized to their default value according to the variable. If you check that

table reference type variable‟s default value is null.

This is the reason why the output is null

null

null

lets have a snap short of memory for the above program.

141

STACK HEAP

Example-8

Unequal second dimension

class demo

{

Public static void main(String args[])

{

Int [][] town=new int[3][];

town[0]=new int [1];



Int I,j,k=0;

for(i=0;i<3;i++)

for(j=0;j<=I;j++)

Town

1000

1000

1004

1008

1012

null

null

null

null

142

{

town[i][j]=k;

K++;

}

for(i=0;i<3;i++)

{

for(j=0;j<i;j++)

{

System.out.print(town[j][j]+” “);

}

System.out.println( );

}

}

}

Output:

0

1 2

3 4 5

Let me explain the program. As I have said town is a reference variable

pointing to an array of reference of length 3 as shown in the snap shot of

memory .

143

town[o] is a reference to integer type. So through a new operator we

allocate memory to it.

town[0]=new int [1]; implies that integer array of length one is created in

the heap and its starting address 6000 here is allocated to town[0]. An

interesting thing is that reference is created inside heap and memory is

allocated to it from the heap also.

Array of objects

Example-9

Let‟s begin this section with an example

class Demo

{

int x; public static void main(String args[])

144

{ Demo []arr=new Demo[3];

arr[0]=new Demo(); arr[0].x=0;



for(int i=0;i<3;i++) System.out.println(arr[i].x);

} }

Output: 0

1 2

In the above example I have created an array of objects. The above codes

are not simple & straight as it looks. Let me explain the program: Demo [] arr=new Demo[3]; Demo is the class name. What is arr? As I have

mentioned in the previous sections, in Java a variable of class type is not a normal variable, rather it is a reference variable. So arr is a reference to an

array of references & each element of the array is a reference of class Demo created inside heap. Let‟s have a snap shot of memory.

Diagram:

arr is created inside stack. When the statement Demo []arr=new

Demo[3];is executed array of references is created inside stack, & the

staring address is stored in arr. Remember that size of a reference variable

is 4 bytes, if 1000 is the address of the 1st element of the array then next

one is 1004 & so on.

Each element of the array is a reference variable of Demo class, so you

cannot access instance variable x. if you try to do that then null pointer

exception will arise. This is because whenever a reference variable is created

in side heap, its default value is null. Finally I have to allocate memory to

each element present in the array to access the instance variable. This is

145

done by calling the constructor of Demo class through new operator.

(arr[0]=new Demo();) Now I can store a value in the instance variable x.

Method returning reference to an array

See the example below. Just check the signature of the method returning

the reference else everything is straight forward.

Example-10

class Demo

{


{

Demo x=new p1();

int[ ] arr_Ref=x.funRef();

System.out.println(arr_Ref[2]);

}

int[] funRef()

{

int [ ]arr1=new int[3];

arr1[0]=1;

arr1[1]=2;

arr1[2]=3;

return arr1;

}

}

146

Brain Drill

Assignment-1:-

Draw this By the help of Array in java?

Program:-

import java.io.*;

public class ArrayTask1

{


{

147

try{




int r=Integer.parseInt(br.readLine());

char c[][]=new char[r][];

for(int k=0;k<r;k++)

{

c[k]=new char[k+1];

}


{

for(int j=0;j<=k;j++)

{

if(j==0)

c[k][j]='*';

else if(j==k)

c[k][j]='*';

else if(k==(r-1))

c[k][j]='*';

else

c[k][j]=' ';

}

148

}


{

for(int j=0;j<=k;j++)

System.out.print(c[k][j]);

System.out.println();

}

}catch(IOException ie)

{

}

}

}

Assignment-2:-

Draw This Triangle By Array?

149

Program:-

import java.io.*;

public class ArrayTask2

{


{

try{


InputStreamReader(System.in)) ;

System.out.println("Enter Number Of Rows");

int r=Integer.parseInt(br.readLine());

150

char c[][]=new char[r][r];


{

for(int j=0;j<r;j++)

{

if(j<k)

c[k][j]=' ';

else

c[k][j]='*';

}

}

System.out.println("See The Structure");


{

for(int j=0;j<r;j++)

{

System.out.print(c[k][j]);

}


}


{

}

}

151

}

Assignment-3:-

Enter four integer value from keyboard and Sort the elements of

array in Ascending order?

import java.io.*;

public class ArrSortA

{


{



int i=0,j,temp;

int ar[]=new int[4];

System.out.println("Enter The Array Elements");

for(i=0;i<ar.length;i++)

{

ar[i]=Integer.parseInt(br.readLine());

for(j=0;j<ar.length;j++)

{

if(ar[i]<ar[j])

{

temp=ar[j];

ar[j]=ar[i];

ar[i]=temp;

}

152

}

}

for(i=0;i<ar.length;i++)

{

System.out.println(ar[i]+"\n");

}

}

}

Output:

Assignment-4:-

Enter 5 integer through an array and find out Smallest Number?

153

import java.io.*;

public class ArrSmall

{


{

int i,j,temp=0;



int ar[]=new int[5];

System.out.println("Enter The Array Elements");

for(i=0;i<5;i++)

{

ar[i]=Integer.parseInt(br.readLine());

for(j=0;j<5;j++)

{

if(ar[i]<ar[j])

{

temp=ar[j];

ar[j]=ar[i];

temp=ar[i];

}

}

}

System.out.println("Smallest No is "+temp) ;

}

154

}

Output:

Assignment-5:-

Enter A Number and find out the Binary Value?

import java.io.*;

public class Binary

{


{

int num,i=0,j,k;

int a[]=new int[20];

int b[]=new int[20];



System.out.println("Enter any number");

155

num=Integer.parseInt(br.readLine());

while(num>0)

{

a[i]=num%2;

i++;

num=num/2;

}

k=i-1;

System.out.print("\n\n");

for(j=0;j<i;j++)

{

b[j]=a[k];

System.out.print(b[j]);

k--;

}

}

}

Output:

156

Assignment-6:-

Enter a decimal and find out the octal value?

import java.io.*;

public class DecimalOctal

{


{

int r,q,o,num;

int a[]=new int[10];

int b[]=new int[10];



System.out.println("Enter Any Number");

num=Integer.parseInt(br.readLine());

o=0;

while(num>0)

{

157

if(num<8)

{

a[o]=num;

o++;

break;

}else{

a[o]=num%8;

o++;

num=num/8;

}

}

r=0;

for(q=o-1;q>=0;q--)

{

b[r]=a[q];

r++;

}

System.out.println("Octal Number Is ") ;

for(q=0;q<r;q++)

158

{

System.out.print(b[q]);

}

}

}

Output:

159

CHAPTER 9 :

Inheritance

Inheritance is one of the fundamental concepts of object

oriented programming. Using inheritance, you can create a general class

that defines traits common to a set of related items. This class can then be inherited by other, more specific classes, each adding those things that are

unique to it. In the terminology of Java, a class that is inherited is called a super class & the class that inherits the properties of super-class is known as

derived class or child class. Java uses extends keyword to support inheritance. The general syntax is

class X

{ //Codes

}

class Y extends X {

//Codes }

Class baseClass extends superClass{ //Codes

} should be the syntax.

Here X is the super class Y is the child class or derived class

Benefits of inheritance Code reusability because derived class (child class) copies the

member of super class (parent class).

Restriction: if the super class members are private, then child class cannot copy them & another thing JAVA does not support multiple

inheritances.

To inherit a class, you simply incorporate the definition of one class into another by using the extends keyword. To see how, let‟s begin with a short

example.

160

class X{ void show()

{ System.out.println("Hello, Java I am inherited");

} }

class Y extends X {

}

class Demo {

public static void main(String argts[]) {

Y a=new Y();

a.show(); }

}

Output: Hello, Java I am inherited

In the above example X is known as the super class & Y is the derived class

or you may say the child class. In side main() method object of child class is created but the show() method of parent class is invoked. show() method is

not a member of Y. In case of inheritance child class copies members of the parent class those are not private, to it self. show() method belongs to class

X. It has default access specifier. Therefore it can be inherited with in a package. By using extend keyword show() method is copied to class Y.

Hence any object of class Y can invoke show() method.

Multi-level inheritance. class X

{ void show()

{ System.out.println("Hello, Java");

} }

161

class Y extends X

{

}

class Z extends Y {

Z() {

super.show(); }

} Output:

Hello, Java

Hello, Java

Here show() method of X is copied to class Y & from class Y to

class Z. Hence the object of class Z can invoke show() method which is written in class X. In this way inheritance facilitates code reusability.

super Keyword

super is a keyword. Through the use of super keyword programmer can access the members of super class. Java does not allow the use of super

keyword inside static method & static block. super keyword is used for two purposes

If the super class instance variable name is same as that of child class or sub class instance variable name, then to access the

super class instance variable super keyword is used only the

inside sub class. class X{

int i=9; }

class Y extends X {

int i=90; void showSuper()

{ System.out.println(i);

System.out.println(super.i); }

}

162

class Demo


{ Y a=new Y();

a.showSuper(); }

}

Output: 90

9

X is the base class which has the instance variable i. Y is derived from X & also has the instance variable i. Inside the child class Y showSuper() is a

method. The first statement inside the showSuper() method prints the value

of i that belongs to child class Y. To access the parent class i, super keyword is used. Through the use of super.i programmer can access the super class

instance variables.

Java uses super keyword for explicitly calling the super class

constructor within child class constructor. Restriction:

super must be the first statement in side the child class constructor, other wise it will give compile time error.

Example:

class X {

X()

{ System.out.println("Parent class");

} }

class Y extends X {

Y() {

super();

163

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

}

} class Demo extends Y

{ public static void main(String argts[])

{ Y d=new Y();

} }

Output: Parent class

Child class

Just like super, this is also used to call the constructor of the current class with in a constructor & it must be the first

statement otherwise compile time error will arise.

class Demo {

Demo()

{ System.out.println("Inside Default constructor");

} Demo(int i)

{

this(); System.out.println("Inside parameterized

constructor");

} public static void main(String argts[])

{ Demo d=new Demo(3);

} }

164

Output:

Inside Default constructor Inside parameterized constructor

Calling of constructor

In case of inheritance when the programmer creates the child class object by calling the child class constructor through new operator, at that time the

super class default constructor is implicitly invoked.

class X {

X() {

System.out.println("Inside super class default constructor");

} X(int i)

{ System.out.println("Inside super class parameterized

constructor"); }

} class Y extends X

{

} class Demo


{

Y d=new Y(); }

}

Output

Inside super class default constructor

When you define the super class parameterized constructor & do not define

the super class default constructor then compile time error will arise.

165

class X

{

X(int i) {

System.out.println("Inside super class parameterized constructor");

} }

class Y extends X {

}

class Demo {

public static void main(String argts[])

{ Y d=new Y();

} }

Output

It will give compile time error as

Exception in thread "main" java.lang.Error: Unresolved compilation

problem: Implicit super constructor X() is undefined for default constructor.

Must define an explicit constructor

at demo.Y.<init>(Demo.java:12)

at demo.Demo.main(Demo.java:20)

If you call the child class parameterized constructor at that time also parent

class default constructor is called.

class X {

166

X() {

System.out.println("Inside super class default constructor");

}

X(int i) {


} }

class Y extends X {

Y(int i)

{ System.out.println("Inside child class parameterized

constructor"); }

}

class Demo {


Y d=new Y(6); }

}

Output:

Inside super class default constructor Inside child class parameterized constructor

If you are not defining the super class default constructor then inside child

class constructor just calls the parent class parameterized constructor as shown in the example below.

class X

{

X(int i) {

167

System.out.println("Inside super class parameterized

constructor"); }

} class Y extends X

{ Y(int i)

{ super(8);

System.out.println("Inside child class parameterized constructor");

}

} class Demo

{


Y d=new Y(6); }

}

Output: Inside super class parameterized constructor

Inside child class parameterized constructor

See here parent class parameterized constructor is called through super key word & it is the first statement in side child class constructor.

Method over ridding & Dynamic method dispatch

Method over ridding is only possible in case of inheritance where super class method is over ridden in its child class. In case of method over ridding

method name, its argument type, no. of arguments & return type is exactly same. Access specifires may be same or least restrictive in the child class

where the parent class method is over ridden. Private methods can not be over ridden. Static & final methods also can not be over ridden.

class X

{

X() {

168


constructor"); }

void fun() {

System.out.println("Parent"); }

} class Y extends X

{ Y()

{ System.out.println("Inside child class parameterized constructor");

} void fun()

{

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

}

class Demo {


Y d=new Y(); d.fun();

} }

Output:

Inside super class parameterized constructor

Inside child class parameterized constructor Child

Here the fun method is over ridden in Y. inside Demo class I have created

the object of Y i.e. d is the object of Y, so d.fun() invokes the fun method that is overridden in Y.

class X

{

X() {

169


constructor"); }

protected void fun() {

System.out.println("Parent");

} }

class Y extends X {

Y() {

System.out.println("Inside child class parameterized constructor"); }

public void fun()

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

}

} class Demo


{ Y d=new Y();

d.fun(); }

}

Output:

Inside super class parameterized constructor Inside child class parameterized constructor

Child

See here in the parent class X access specifier of fun is protected & when it is over ridden in its child class Y acess specifier of fun is public which is less

restrictive than protected. There fore the program is successfully compiled & child class fun method is invoked.

class X

{ X()

{

170


} void fun()

{ System.out.println("Parent");

} }

class Y extends X {

Y() {


proteted void fun()


} }

class Demo {


Y d=new Y(); }

}

This program will result compilation error because in parent class the access specifier of fun is default where in child access specifier of fun is protected

which is more restrictive than default access. So you have to be careful in

this issue while performing the method over ridding.

Dynamic method dispatch in case of method over ridding : Method over ridding implements dynamic polymorphism i.e. it is executed in run

time. So when over ridden method is invoked, it completely depends which class object invokes the method.

class X

{

X() {

171


constructor"); fun();

} void fun()


} }

class Y extends X {

Y() {


void fun()


}



{ Y d=new Y();

d.fun(); }

}

Inside super class parameterized constructor

Child Inside child class parameterized constructor

Child

Output clearly shows that fun method of child class is invoked. Inside main method since child class object is created therefore fun method of child class

is called although it is called inside the body of the super class constructor. If you write this.fun() inside the super class constructor due to the mentioned

reason the fun() method of child class is called.

class X {

{

172

fun();

}

X() {



} void fun()


} }

class Y extends X

{ Y()


} void fun()


} }

class Demo extends Y {


Y d=new Y();

d.fun(); }

}

Output: Child

Inside super class parameterized constructor Child

Inside child class parameterized constructor Child

Here also fun() method of child class is invoked. This is because when any overridden method is called it completely depends through which object the

173

overridden method is called & according to that appropriate function call

takes place.

Parent class reference variable can hold the child class object. In this case also since the object of child class is created, therefore child class method

will be invoked. See the example below class X

{

X() {



}

void fun() {

System.out.println("Parent"); }

} class Y extends X

{ Y()


} void fun()


}



{ X d=new Y();

d.fun(); }

}

Output: Inside super class parameterized constructor

Child

174

Inside child class parameterized constructor

Child Inside main() method X d=new Y() implied that parent class reference

variable holds the address of child class created. Since child class object is created there fore child class fun method is called.

Behavior of instance variables in case of inheritance.:

Instance variables are initialized at the compile time. If super class

instance variable name is same as that of child class instance variable name, when you access such a variable then the reference type matters.

class X

{ int i=40;

} class Y extends X

{ int i=90;

}



X d=new Y(); System.out.println(d.i);

} }

Output: 40

In main() method I have created reference variable of parent class.

Variables are initialized at compile time; hence parent class instance variable is accessed.

Behavior of overloaded method in inheritance:

Method overloading is done at compile time. So when you call a

overloaded method according to the reference type appropriate method is called.

175

class X {

void fun() {

System.out.println("Parent class"); }

} class Y extends X

{ void fun(int x)

{ System.out.println("Child class");

}



{ X d=new Y();

d.fun(); Y a=new Y();

a.fun(); a.fun(6);

} }

Output:

Parent class

Parent class Child class

Here d is a reference of parent class. So when you write d.fun(); parent class fun() is invoked.

Rest of the lines are straight foreward.

Now another important thing. See the program below. class X

{ void fun()


}

176

}

class Y extends X {

void fun(int x) {

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

}



{ X d=new Y();

d.fun();

d.fun(6); }

} Above program will result compilation error. Because parent class X does not

have a fun method which takes an integer argument.

So what we conclude is that when ever programmer deals with aspects those are performed at compile time, the type reference variable matters.

When programmer deals with the aspect which are performed at run time the type of object created matters.

Difference between super & this

super is a keyword in java but this is a reference variable. super is only used to access the parent class members & the parent class constructor.

class X

{ X()


} }

class Y extends X {

Y()

177

{

super(); System.out.println("Child class");

} Y fun()

{ return this;

} void show()

{ System.out.println("Hello R u foxed!!");

} }

class Demo extends Y

{


Y d=new Y(); Y x=d.fun();

if(d==x) {

x.show(); }

} }

Out put

Parent class Child class

Hello R u foxed!!

Here in child class fun method return this, the address of the currents object

memory location which is assigned to x. That is address of d is assigned to x.

package demo; class X

{ X()


} }

class Y extends X

178

{

Y() {

super(); System.out.println("Child class");

} X fun()

{ return super;

} }



Y d=new Y();

X x=d.fun(); }

} Above program will result a compilation error because super is not a

reference variable. it is simply keyword in java. Hence to fix the bug rewrite the program as below

class X

{ X()


} }

class Y extends X

{ Y()

{ super();

System.out.println("Child class"); }

X fun() {

X x=new X(); return x;

} void show()

{

179

System.out.println("Hello R u foxed!!");

} }

class Demo extends Y


{ Y d=new Y();

X a=d.fun(); }

}

Output: Parent class

Child class

Parent class Here out put is straight foreword.

That‟s all about inheritance in java folks.

abstract

abstract is a keyword or modifier used in case of class & method. If the

class is declared as abstract, programmer cannot instantiated that class

means cannot create the object of that class. Abstract method means

method having declaration only. Abstract method body is not defined where

it is declared rather it is declared somewhere else.

Syntax to declare an abstract class:

abstract class X{

}

You can create the reference of an abstract class but you cannot create the

object of the abstract class by calling the constructor of the corresponding

class through new operator. If you try to create the object of the abstract

class compilation error will arise.

X ab;// possible

ab=new X();//Compilation error

180

If a class is declared as abstract the methods those are the member of that

class may abstract or may not be. But on the other hand if any of the

method of a class is abstract then the class has to be abstract. Abstract

methods are declared inside the abstract class but defined in their child

class. If any of the child class does not define the abstract method of its

super class then that child class has to be declared as abstract class

otherwise compilation error will be generated.

abstract class X

{ int i=10;

public abstract void display(); {

System.out.println("Hello"); }

}

class Y extends X

{ int i;

public void display() {

System.out.println("Finally I got Life!!");

} }

class Demo


{ X a=new Y();

a.display();

System.out.println(a.i); }

}

181

Output:

Hello

Finally I got Life!! 10

final & abstract behave complement to each other. When a class is declared

with final keyword, that class can not be inherited. But abstract class has to

be inherited in order to define its abstract methods. There fore abstract class

can not use final keyword. Constructors can not be abstract. Although you

can not call the constructor of abstract class, still you can declare the

constructor of the abstract class. Using super keyword inside the constructor

of child class you can invoke the constructor of abstract parent class.

abstract class X {

public abstract void fun(); X()

{ System.out.println("X constructor");

} }

class Y extends X

{ public void fun()

{ System.out.print("Hello");

}

Y() {

super(); }

} class Demo


{ X a=new Y();

a.fun(); }

182

}

Output:

X constructor

Hello

Interface

First of all interface is a keyword. Interface declaration is same as class

declaration.

e.g.

public interface X {

}

Interface X {

}

Interfaces are implicitly abstract in nature. Interface cannot be

instantiated. In interface all the methods are public & abstract by default.

As the methods are public & abstract by default therefore those methods has

to be overridden in their corresponding child class. The methods belonging

to an interface are looked up at runtime. In interface variables are implicitly

public, static & final. The advantage of declaring variables within an interface

is that they become globally available to all classes and need not be declared

explicitly in classes implementing them.

interface supports multiple inheritance.

Example:-1

interface in

{

String toString();

}

183

public class Test implements in

{

public static void main(String a[])

{

System.out.println(new in()

{

public String toString()

{

return "test";

}

});

}

}

Output:-

test

Example-2

interface Declare

{

public static final int i=3;

void doStuff(int i1);

}

public class A implements Declare

{

184


{

int x=5;

new A().doStuff(++x);

}

public void doStuff(int s)

{

s+=i + ++s;

System.out.println("Output Is "+s);

}

}

Output:-

Output is 16

Final keyword:

Final keyword is used in class, method and variable. If the class is declared as final the then the class cannot be inherited. String, Math, Wrapper classes

are treated as final so these classes have no child class.

Ex. class X extends String //error as String is a final class

If the method is declared as final then method cannot be override. In

technical term final method cannot be override.

Ex. class X

{ Final void show()

{

//code here }

}

185

class Y extend X

{ void show()

{ //code here

} }

//error final method cannot be override.

If the variable is declared as final then the value of final variable cannot be changed or modified. In technical term we cannot assign the value

to final variable.

Ex. final int i=10;

void show() {

i++; //Error }

final variable must be initialized.

Ex. public class X {

final int i; void show()

{ System.out.println(i); }


X ab=new X(); ab.show(); }

} Error:

This program generates a compile time error that „i‟ is not initialized. As i is a final variable , i must be initialized.

186

Chapter-10

Inner Class / Nested Class

Java supports Inner class or nested class. Define one class within another

class is treated as Inner class or nested class. In java four types of inner

classes are used.

Static Inner Class

Non-static Inner Class

Local Inner Class

Anonymous Inner Class

A nested or inner class is the member of its enclosing class. Nested class can

be declared by using any access modifier. In java outer class or enclosing

class is declared by using public or no access modifier. Nested class is able

to access private, protected, no access or public member of enclosing class.

Advantage of Using Inner / Nested class:-

1. Logical grouping of classes

2. Increased encapsulation 3. More readable, maintainable code

Static Inner Class

If the Inner class uses the static modifier then the Inner class is treated as

static inner class.

For Example:-

class X

{

static class Y

{

}

187

}

Here Y class is treated as static inner class.

Key Points of Static Inner Class:-

Programmer declares the static inner class by using any access

modifier.

Static Inner class access the static member of outer or enclosing class

through the outer class name or directly.

Static Inner class access the non-static member of the outer or

enclosing class through the instance or object of the outer class.

Static Inner class static member access the non-static member of the

Inner class through the instance of static Inner Class.

Static Inner class static member access the static member of the Inner

Class through the name of the static inner class or directly.

Static Inner Class‟s Non-static member access the static member of

the inner class through the Inner class name or directly.

Static Inner class‟s non-static member access the non-static member

of the inner class directly.

Static Inner Class supports inheritance.

Example-1:-

public class Inner1

{

String name;

static int roll;

private String getName(String n)

{

name=n;

return name;

}

static int getRoll(int r)

188

{

roll=r;

return roll;

}

static class Test

{

int age=10;

static String add="Cuttack";

void display()

{

Inner1 i1=new Inner1();

System.out.println("Name Is "+i1.getName("Sai"));

System.out.println("Roll Number Is "+Inner1.getRoll(1));

System.out.println("Age Is "+age+"\t"+"Address Is "+add);

}

}


{

Test t1=new Test();

t1.display();

}

}

Output:

189

Example-2

public class Inner2

{

String name;

static int roll;


{

name=n;

return name;

}

static int getRoll(int r)

{

roll=r;

return roll;

}

static class Test

{

int age=10;

static String add="Cuttack";

190

static void display()

{


Test t=new Test();

System.out.println("Name Is "+i1.getName("Sai"));

System.out.println("Roll Number Is "+Inner1.getRoll(1));

System.out.println("Age Is "+t.age+"\t"+"Address Is

"+Test.add);

}

}


{

Test.display();

}

}

Output:

Example-3

public class Inner3

{

String name;

191

static String add;

static int age;

private static class Test1

{

int roll;

String getName(String n)

{


i3.name=n;

return i3.name;

}

int getAge(int a)

{

Inner3.age=a;

return Inner3.age;

}

}

protected static class Test2 extends Test1

{

int getRoll(int r)

{

roll=r;

return roll;

}

192

String getAddress(String a)

{

Inner3.add=a;

return Inner3.add;

}

}


{

Test2 t=new Test2();

System.out.println("Name Is "+t.getName("Sai"));

System.out.println("Age Is "+t.getAge(10));

System.out.println("Roll Number Is "+t.getRoll(1));

System.out.println("Address Is "+t.getAddress("Cuttack"));

}

}

Output:

193

Non-static Inner Class:-

Class declared within another class without using static modifier is treated as

non-static Inner class. Non-static inner class is popularly known as Inner

class. We declare non-static inner class by using any access modifier.

Class X

{

Class Y

{

}

}

Here class Y is treated as non-static inner class

Key Points of Non-Static Inner Class:-

Non-static inner class non-static member access the static member of

the outer class through the outer class name or directly.

Non-static inner class non-static member access the non-static

member of the outer class directly without creating any instance of the

outer class.

Within non-static inner class we cannot declare any static member

This inner class is very popularly used.

Example-4

public class Inner4

{

String name;

static int age;


194

{

name=n;

return name;

}

static int getAge(int a)

{

age=a;

return age;

}

private class Test1

{

int roll;

String add;

int getRoll(int r)

{

roll=r;

return roll;

}

String getAddress(String s)

{

add=s;

return add;

}

void display()

195

{

System.out.println("Name Is "+getName("Sai"));

System.out.println("Age Is "+Inner4.getAge(10));

System.out.println("Roll Number Is "+getRoll(1));

System.out.println("Address Is "+getAddress("Cuttack"));

}

}


{

Inner4 t1=new Inner4();

t1.show();

}

void show()

{

Test1 t1=new Test1();

t1.display();

}

}

Output:

196

Example-5

public class Outer1

{

String name;

int roll;

public class Inner1

{


{

name=n;

return name;

}

int getRoll(int r)

{

roll=r;

return roll;

}

}


{

Outer1 o1=new Outer1();

Inner1 i1=o1.new Inner1();

System.out.println("Name Is "+i1.getName("Asit"));

System.out.println("Roll Number Is "+i1.getRoll(4));

197

}

}

Local Inner Class:-

Class declared within the method is treated as local inner class.

class X

{

void show()

{

class Y

{

}

}

}

Here class Y is treated as Local inner class as it is declared within the

method show.

Key Points of Non-Static Inner Class:-

Local inner class is declared through no-access modifier but not

declared through public, private and protected access modifier.

Local Inner class access the private member of the outer class

198

Local Inner class non-static member directly access the static

member of the outer class. Local inner class non-static member directly access the non-

static member of the outer class. Local inner class only accesses the final member of the method

where the class is declared. Programmer creates the object of local inner class within the

method where the class is declared.

Example-6

public class Local1

{

String name;

private static int roll;

protected static int age;

String add;

void go(final int a,int b)

{

final int x=a+b;

int y=a-b;

class Inner

{


{

name=n;

199

return name;

}

int getAge(int a)

{

age=a;

return age;

}

int getRoll(int r)

{

roll=r;

return roll;

}

String getAddress(String s)

{

add=s;

return add;

}

void show()

{

System.out.println("Name Is

"+getName("Sai"));

200

System.out.println("Age Is "+getAge(10));

System.out.println("Roll Number Is

"+getRoll(1));

System.out.println("Address Is

"+getAddress("Cuttack"));

}

void display()

{

System.out.println("Value Of A Is "+a);

//System.out.println("Value Of B Is "+b);

System.out.println("Value Of X Is "+x);

}

}

Inner i1=new Inner();

i1.show();

i1.display();

}


{

Local1 l1=new Local1();

l1.go(10,2);

}

}

201

Output:

Anonymous Inner Class:-

You can also declare an inner class within the body of a method without

naming it. These classes are known as anonymous inner classes. In other words the

declaration and initialization of the class is done on the same line.

addFocusListener(new FocusAdapter()

{

Public void focusGained(FocusEvent fe)

{

}

});

Here FocusAdapter is treated as Anonymous Inner Class.

202

CHAPTER 11:

Exception Handling

Introduction

Exceptions are abnormal behavior of

program during its execution state. You can say that exceptions are runtime error.

Compile time errors never come under exception. They are simply errors. Exception

occurs only at the execution state of the program. Exceptions that can be

generated in a java programs are

If the array index cross the range.

If the number divide by zero.

The file you try to open may not exist.

The class file programmer want to load may be missing etc.

Some of the exceptions are detected at compile time & some of the exceptions are

detected during run time. In java the exceptions those are detected during compile

time is known as checked exception & exceptions those detected during the

execution of java program by JVM is called unchecked exception. Since unchecked

exceptions are generated during the execution of the program, java programmer

can create programs having unchecked exceptions. But, things are completely

different in case of checked exception. If the programmer does not handle the

checked exception then java compiler detects them & program terminate at the

compilation stage. Programmer can not ignore the checked exception.

In java exception handling is done by 5 keywords: try,catch,throw,throws & finally.

Briefly here is how they work. Programming codes that you want to monitor for

exceptions are embedded inside this block. If an exception is generated inside try

block then it has to be thrown. When the programmer manually handles the

exception, he has to use throw keyword. In this case catch follows the try block in

order to handle the exception. When an exception is thrown out of a method throws

keyword has to be used. If some piece of code that is necessary to be executed

after try block then those has to be written in side finally block. The general syntax

of exception handling block is

try{

//Block of code to monitor for errors

}

203

catch(Exception_Type_1 excp1){

//Codes to handle the exception

}

catch(Exception_Type_2 excp2) {


}

catch(Exception_Type_3 excp3) {


}

//….

finally{

//Codes that has to be executed must

}

In java Exception is handled by five keywords try, catch, finally, throw,

throws.

204

In java Exception is of two types Checked and Unchecked Exception.

Checked exceptions: ClassNotFoundException, IOException & its child classes all

are checked exceptions.

Unchecked Exception: Error,RuntimeException & its child classes all are treated as

unchecked exception.

Types of Exception:-

ArithmeticException. ArrayIndexOutOfBoundsException.

ArrayStoreException. ClassCastException.

IllegalArgumentException. IllegalMonitorStateException.

IllegalStateException. IllegalThreadStateException.

IndexOutOfBoundsException.

205

NegativeArraySizeException.

NullPointerException. NumberFormatException.

SecurityException. StringIndexOutOfBounds.

UnsupportedOperationException. ClassNotFoundException.

CloneNotSupportedException. IllegalAccessException.

InstantiationException. NoSuchFieldException.

NoSuchMethodException.

Types of Error:-

AWTError

VirtualMachineError

OutOfMemoryError

StackOverFlowError

AssertionError

Throwable Class

Throwable is a class present in java.lang package. Throwable is the super

class of Exception and Error.

Constructors of Throwable class

public Throwable() this constructor creates a Throawble object with a null information

embedded within the object. public Throwable(String mess)

this constructor creates a Throawble object with a the message „mess‟ supplied by the programmer embedded within the object.

public Throwable(String message, Throwable reason)

http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html


http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Throwable.html

206

this constructor creates a Throawble object with a the message „mess‟

supplied & the reason behind the exception through the Throwable object „reason‟ .

public Throwable(Throwable reason)

this constructor creates a Throawble object with a the reason behind the exception by Throwable object „rason‟.

Use of try, catch & finally block:

try block: All the exception generating codes are embedded within try block.

Java supports nested try block.

catch block: catch block is treated as exception handler. The catch block

caught the exception that will arise within the try block. Every try block must

be followed by a catch block. In java one try block can have multiple catch

block. If the catch parameter matched with the exception, then the

programmer is able to handle the exception. On the other hand if the catch if

the catch parameter is not matched, then the program is terminated. The

matching is done by JVM using instanceof operator.

Finally block: In java the try block is executed means the finally block must

be executed. Without try block finally block cannot be executed. Either the

programmer caught the exception or not finally block must be executed. If

the programmer is able to caught the exception, first catch block is executed

& then finally block is executed. But in the other hand if the programmer is

not able to caught the exception, finally block is executed & program

terminates. Finally block is executed in java to give control to the

programmer. As the finally block must be executed, with in the finally block

you can use another try catch block.

Throws: throws keyword is used in java to throw the exception from the

called method to the calling method. The calling method should have the

tool to handle the exception thrown from called method. It is used in method

definition.

Exception handling provides two benefits

1: Allows to fix the bug.

2: Prevents the automatic termination of the program.

http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Throwable.html

207

How JVM handles an exception

Now it is important for the beginners to understand what will happen if

you don‟t handle the exception. Let me explain it through an example

Example-1

public class Demo

{


{

int x=12,y=0,z;

z=x/y;

System.out.println(“I am not executed”);

}

}

Output:-

This program is compiled successfully. During its execution, JVM detects the

attempt to divide by zero. At that instant of time JVM generates unchecked

exception object & throws it. This terminates the execution at the runtime.

When the exception is thrown, there must have some technique to handle or

mange it by the use of catch block. In the given program there is no

exception handler provided by the programmer so the default exception

handler of JVM caught the exception. If programmer manually does not

handle the exception then JVM handle them by default handler. The default

handler throws a message to the screen as

208

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

at Demo.main(Demo.java:7).

Actually when exception occurs & it is handled by JVM, JVM shows the stack

trace message from the point where exception has been occurred. If you see

the message carefully it clearly shows exception occurs in demo package‟s

Demo class‟s main method at line no: 7. When such run time exception

occurs, it leads to abnormal termination of the program. The codes below

the point where such exceptions occur are never executed. That is the

reason why the last statement of the program is not executed.

Use of try & catch block

Let me use the try, catch tool for the previous program.

Example-2

public class Demo

{


{

int x,y,z;

x=9;

y=0;

try{

z=x/y;

}catch(ArithmeticException e)

{

System.out.println("You can not devide an intrger by

zero");

System.out.println("so using y++");

209

y++;

z=x/y;

}

System.out.println("I am executed");

}

}

Output:-

In the first case there no exception handler provided by the programmer,

therefore the program terminates abnormally. To prevent the abnormal

termination of the program, simply put the codes to be monitored inside the try block. A catch block immediately follows the try block to catch the

thrown exception. When an integer is divided by zero java generates ArithmeticException. The catch block catches the exception by the

ArithmeticException object e. So the program does not terminate abnormally. But, one thing the programmer has take care of is that the

codes below the point where the exception is generated is not going to be executed. The program below illustrates the above fact.

Example-3

class Demo


{

int x,y,z; x=9;

y=0; try{

z=x/y; System.out.println("I am not Executed");

210


{ System.out.println("Exception is handled");

} }

}

Output:

Exception is handled

A try block holds a piece of Exception arising codes and its catch block treats as an Exception handler. If the Generated Exception is handled by the catch

block through that Exception or its super class then the programmer is able to handle the Exception.

How to know why the exception is generated

As Throwable is the child class of Object class it overrides the public String toString() method. Through this method returns a string

where it describes about the type of Exception.

Example-4

public class Demo {


int x=9; try{

x=x/0;

}catch(ArithmeticException e) {

System.out.println("inside catch block"+e); }

} Output:

inside catch block java.lang.ArithmeticException: / by zero

Multiple catch blocks

211

In some special case one try block can have multiple catch block. In other

words more than one Exception can be generated within a single line of code, so the programmer required multiple catch statement for one try

block. To handle such situations multiple catch blocks are required. When multiple Exception is generated, each catch statement inspected in order.

Example-5

public class Demo


{ try{

int len=argts.length; System.out.println(“Length=”+len);

int con=5/len;

int mak[]={222}; mak[42]=1000;

}catch(ArithmeticException e) {

System.out.println("inside catch block"+e); }

catch(ArrayIndexOutOfBoundsException aoe) {

System.out.println(“Inside Catch Block”+aoe); }

} }

Output:-

This program will generate an ArithmeticException if in the command line

the programmer not passes any arguments, so the length is equal to zero. But if the programmer passes any command line arguments then the length

is not equal to zero and the program not generates any ArithmeticException. But program must generate an ArrayIndexOutOfBoundsException, since

the int array mak has a length of 1, yet the program attempts to assign a value to mak[42].

212

Parent class reference variable can hold the object of child

class. So the exception thrown by a try block can be caught by its parent class reference. When one try block having multiple catch

statement then Exception of sub class must placed before Exception of super class. It is a restriction otherwise it generates compile time error.

Example-6

import java.io.*;

class New extends Exception {

} public class Multi

{ public static void main(String args[])throws IOException

{

int a=10; int b=args.length;

try{ System.out.println(a/b) ;

BufferedReader br=new BufferedReader (new InputStreamReader(System.in));

System.out.println("Enter A Number"); int i=Integer.parseInt(br.readLine());

throw new New(); }catch(ArithmeticException ae)

{ ae.printStackTrace();

} catch(NumberFormatException ne)

{

System.out.println(ne.getMessage()); }

catch(Exception n) {

System.out.println("Caught"); }

} }

Use of throw statement

So far we have caught the exceptions generated by JVM. Java provides

213

support to generate exception manually by the programmer just by

instantiating the appropriate exception class. You have to use the throw statement to thyrow the exception. The general form will be

throw instance_of_Throwable_or_its_child_class;

You can throw the object of Throwable or the object of the child class of

Throwable. The execution stops when JVM encounters the throw statement & controls jumps to the catch block. The codes below the throw statement are

never going to be executed.

Example-7

public class Demo {


{ ArithmeticException a=new ArithmeticException();

try{ throw a;

System.out.println("inside try block"); }catch(ArithmeticException e)

{ System.out.println("inside catch block");

} }

}

Output:

inside catch block

Example-8

class X extends RuntimeException

{ void show()

{ throw new X();

} }

public class Demo {


214

{

X a=new X(); try{

a.show(); }catch(RuntimeException e)

{ System.out.println("inside catch block");

}

} }

Output:

inside catch block

Explanation: this program represents another way to generate exception inside a method. class X extends the RuntimeException. This class has show

method which has a statement throw new X();. When you want to call the method, it should be inside try block. Rests of the things are straight

forward.

Nested try block:

Java supports nested try block. Nested try block means one try block defined within another try block. The context of the Exception is stored in stack,

when the try statement executed each and every time. If the inner try block has no catch block or has a catch block that is not able to

handle the Exception, then stack is unwound and the next try statement‟s catch block are inspected to handle the Exception of the Inner try block.

This process will continue unless until one of the catch statements matched,

or until all of the nested try blocks are exhausted. If no catch statement matches, then at the runtime the Java run-time system will handle the

Exception.

The throws keyword

If a method generate an Exception and not handle the exception by catch block, then the programmer must specify throws keyword so that the caller

of the method can guard it‟s code against that exception. If method generate a Checked Exception and the programmer does not want to handle

the checked exception then the programmer should throw them out by using throws keyword otherwise an error flagged by java compiler. But in case of

unchecked exception if the programmer does not want to handle the

215

unchecked exception then the programmer should not throw them out by

using throws keyword.

Example-9

public class Excep1 {


try{ amethod();

}catch(Exception e) {

System.out.println("Exception"); }

System.out.println("Finished");

} public static void amethod()throws Exception

{ try{

throw new Exception(); }finally{

System.out.println("Finally") ; }

} }

Output:-

Example-10

public class Excep2 {

public static void main(String afg[]) {

try{ show();

216

System.out.println("A");

}catch(RuntimeException re) {

System.out.println("B"); }

catch(Exception e) {

System.out.println("C"); }

finally{ System.out.println("D");

} System.out.println("E");

} public static void show()

{

throw new RuntimeException(); }

}

Output:-

If any statement generates exception, the remaining statement in the try block is skipped and exception is jumped to catch block.

Every try block must be followed by at least one catch block.

Both try and catch block have more than one statement. Catch statement work like a method statement.

Catch statement is passed a single parameter, which is reference to

the exception object thrown by try block.

If catch parameter is matches with the type of exception object then exception is caught and statement of catch block will be executed

otherwise default exception handle will be executed otherwise default

exception to terminate.

217

User-defined Exception

Customized exceptions are necessary to handle abnormal conditions of

applications created by the user. The advantage of creating such an exception class is that, according to situations user generate user defined

exception. It also possible to set any condition or value to a variable and generate user defined exception.

Example-11

import java.io.*;

class Excep1 extends Exception

{

private int a; Excep1(int b)

{ a=b;

} public String toString()

{ return "Excep1[" +a+ "]" ;

} }

public class User {

public int x; final int k=5;

void getInt()

{

try{ BufferedReader br=new BufferedReader(new

InputStreamReader(System.in)) ; System.out.println("Enter A Number in between 1-10");

String line; while((line=br.readLine())!=null)

{ x=Integer.parseInt(line);

if(x==5) {

218

System.out.println("Congrats You Will Generate an

Exception"); throw new Excep1(x);

}else System.out.println("Try Again") ;

continue; }

}catch(Excep1 e1) {

System.out.println("Generated Exception : "+e1); }

catch(NumberFormatException ne) {

System.out.println("Please Enter A Number"); }

catch(IOException ie)

{ }

} public static void main(String args[])

{ User u=new User();

u.getInt(); }

}

Output:-

Exception Restriction:-

219

When we override a method, we can throw only the exceptions that have

been specified in the base-class method. This is very useful restriction since it means that the code which works with the base class will automatically

work with any object derived from the base class, including exceptions.

It is useful to realize that, although exception specifications are enforced by the compiler during inheritance, the exception

specifications are not part of the type of a method.

220

Chapter-12

Package

It consists of classes and interfaces grouped together according to

functionality. Package contains a set of classes in order to ensure that class names are unique. Package is the container for classes or interfaces.

Packages contain classes and interfaces in a hierarchical order and are imported when the programmer wants to access classes or interface within

it.

Advantage:

Classes contained in the packages of other program can be easily reused.

Two classes in two different packages can have the same name.

Packages provide a way to hide classes. Packages provide a way for separating design from coding.

Classpath variable:

When a class is defined without package declaration, then it is defined that

the class is included in java‟s default package. If the programmer not declared the package name then the class files are stored in the current

working directory so by default the current working directory included in the classpath variable. At the runtime the java interpreter search the .class

files in the path specified in the classpath environmental variable. In case of creating a user defined package ensure that the root directory of the

package is included in the classpath variable.

When programmer develops a package program,

program follow three steps:

Package Declaration Import statement

Class Definition

The format of package declaration is quite simple. Keyword package followed by package name. Package name must be same as the

directory name. When class files are created, they must be placed in a directory hierarchy that reflects the package name.

221

package p1;

import is a keyword in java that is used to access the class files of the user defined package and pre defined package.

import p1.*;

import java.util.*; Naming convention: -

Package begins with lower case letter.

Every package name must be unique, to best use of package. To ensure uniqueness in naming packages, domain name as used as prefix to

package name.

Access protection:

Java having four different types of access specifiers namely private, no

access, protected and public. In java if the method and variable declared

without any access specifier then by default members are no access and the methods and variables are accessed to all classes within the same package.

Members private no access protected public

Same class Yes Yes Yes Yes

Within the

same package class is

inherited

No Yes Yes Yes

Within the

same package class is not inherited

No Yes Yes Yes

Outside the package class

is inherited

No No Yes Yes

Outside the

package class is not inherited

No No No Yes

222

If the members are private then the data is only accessed within

the class but it is not accessed outside the class. If the members are no access then the data is accessed within

the class and accessed within the same package either the class is inherited or not.

If the members are protected then the data is accessed within the class and accessed within the package the package either the class

is inherited or not but outside the package only when the class is inherited.

If the members are public then the data is freely access within the package and outside the package either through inheritance or

not.

Program:-

Create a directory named as pack Open a file Name.java

223

package pack;

class Name {

String n; String setName(String name)

{ n=name;

return n; }

}

In Name class the class, method and variable are declared without using any

access specifier that means the members are only accessed within the same package “pack”.

In the same package open Roll.java

package pack; public class Roll

{ protected int roll;

protected int getRoll(int r) {

roll=r; Name n1=new Name();

System.out.println("Name Is "+n1.setName("Amit")); return roll;

} }

As the Roll class members are protected then it accessed outside the package through inheritance.

Inside the pack directory creates a subdirectory named as subpack

Inside the subpack directory creates a file named as Address.java

package pack.subpack; import pack.Roll;

public class Address extends Roll {

public String address; public String getAddress(String a)

{

224

address=a;

Address a1=new Address(); System.out.println("Roll Number Is "+a1.getRoll(7));

return address; }

}

In this class the members are public so it is freely access within the package and outside the package either through inheritance or not. Here c:\java is

the root directory. In the root directory write the main application PackDemo.java.

In c:\java open PackDemo.java

import pack.subpack.Address;

public class PackDemo


{ Address a1=new Address();

System.out.println("Address Is "+a1.getAddress("Nayabazar, Cuttack"));

} }

Output:

225

Chapter-13

JAR File

Java Archive(JAR) files provides a standard mechanism to compress and

package a set of files for distribution to users. JAR is a platform independent

file format that aggregates many files into single unit. Programmer creates

java archive file format for compress number of class files and improve the

download performance of applet and application. In JAR programmer can

store not only .class files but store different types of file. JAR stands for the

Java Archive. This file format helps the programmer to reduce the size of the

file and collect many file in one by compressing these files. The following

files may be packed into one JAR file:

The Beans

Any Supporting class files.

Text and HTML class files that provides help to the user.

Static Images.

Audio and video clips.

Configuration data.

In java some commands are used to perform main operations for the jar file. These commands are performed in java by using jar tool.

Option Description

C

f

m

T

V

X

O

M

Create an Archive

The first element in files is the name of

the archive to be created.

The second element in the file is the

name of the manifest file.

Tabulate the content of the archive.

Provide verbose output

Extract files from the archive.

Don‟t use Compression

Don‟t create a manifest file

226

The jar utility provided with jdk is to create and manage the JAR files.

Step-1

Write the source code

import java.io.*;

public class Sort

{

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

{



System.out.println("Enter First String");

String first=br.readLine();

System.out.println("Enter Second String");

String second=br.readLine();

int l1=first.length();

int l2=second.length();

int count1=0,count2=0,i;

for(int c=0;c<128;c++)

{

for(i=0;i<l1-1;i++)

{

if((byte)c==(byte)first.charAt(i))

{

227

count1++;

}

}

for(i=0;i<l2-1;i++)

{

if((byte)c==(byte)second.charAt(i))

{

count2++;

}

}

if(count1>count2)

{

for(i=1;i<=count1;i++)

{

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

}

}else{

for(i=1;i<=count2;i++)

{

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

}

}

}

}

228

}

Step-2

Create the manifest file named as

Sort.mft

Name: Sort.class

Java-Bean: True

Step-3

Create the jar file.

Tabulating the contents of the jar file

Extracting Files from a jar file

229

Manifest File

This is an ordinary text file that can be viewed with an editor. This file

consists

Manifest-Version: 1.0

Name: Sort.class

Java-Bean: True

The first line of the manifest file provides version information. The other

lines provide information about each of the element in the JAR file. One of

the most important items to note in this file is Java-Bean: True.

230

Chapter-14

String

In java strings are sequence of Unicode characters. String is a predefined

class present in java.lang package. String is a final class that means String

class cannot be inherited. String is the child class of Object class and

implements the CharSequence, Comparable, Serializable interfaces. Each

quoted string is an object of the String class. So it is created inside heap.

Therefore s1 must have a hash code value. Let‟s check it out

class Demo {


String s1="Java"; System.out.println(s1.hashCode());

} }

Output:

71355168

Yes, s1 is a reference of string class. But, how object is created inside

without new operator!! When JVM encounters String s1=”Java”; such

statement it implicitly invoke new operator to allocate memory from heap.

Java has maintained most of the C/C++ syntax & that is the reason why

java provides this facility to declare a string. String objects are created in

side heap in string pool. Java String Class is immutable, i.e. Strings in java,

once created and initialized, cannot be changed on the same reference. If

you change the content of the original String object then an entirely new

String object is created. A java.lang.String class is final which implies no

class can extend it.

http://java.sun.com/j2se/1.4.2/docs/api/java/lang/CharSequence.html

http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Comparable.html

231

Most frequently used Constructors of String class:

No argument constructor

String s=new String() this constructor is used to create an empty

string.

String(char chars[ ])

This constructor can be used to create a string from array of

characters

class Demo {


char mak[]={'a','b','c'}; String s1=new String(mak);

System.out.println(s1); }

}

Output:

abc

String(char[] c, int start, int length);

The parameter start specifies the index from which the charcters are used to create the String object, and length specifies the number of

characters to be used from the character indicated by start.

class Demo {


char mak[]={'a','b','c','d','e','f','g'};

String s1=new String(mak,3,3); System.out.println(s1);

} }

232

Output is

def

String(String stringObj);

class Demo {


String s1=new String("Hello,Java!"); System.out.println(s1);

} }

Output is

Hello,Java!

class Demo {


String s2="Hello World!"; String s1=new String(s2);


}

Output is Hello World!

In java Strings are set unicode character sequence. Unicode characters take 2 byte from memory. If the programmer is assured that the user characters

in a string are only from keyboard i.e. only ASCII character set then it is advisable to use byte data type rather than char. The constructors are

String(byte b[ ]) String(byte b[],int start, int length)

The parameter b represents the array of bytes. The parameter start specifies the index from which the characters are used to create the String

object, and length specifies the number of characters to be used from the character indicated by start i.e. the range.

class SubStringConstructiom

{

233


{ byte ascii[] = {65, 66, 67, 68, 69, 70 };

String s1 = new String(ascii); System.out.println(s1);

String s2 = new String(ascii, 2, 3);


}

This program generates the following output:

ABCDEF CDE

Extended versions of the byte-to-string constructors are also defined in which you can specify the character encoding that determines how bytes are

converted to characters. However, most of the time, you will want to use the default encoding.

Behavior of == operator in case of string

The == operator is used to determine whether the content of two variables

are same or different. But when == used in case of string references some

abnormal behavior is shown. See the program below.

class Demo {


{ String s1="java";

String s2="java"; if(s1==s2)

System.out.println("Surprised!!!"); }

}

Output

Surprised!!!

S1 is reference of string class. S1=”java”; statement instructs the JVM to

call the constructor of string class through new operator implicitly. S1

created inside stack & memory is allocated to it from heap. Similarly s2 is

234

created in side stack & JVM implicitly calls the constructor to allocate

memory to it from heap. Since s1 & s2 are two different reference variables

therefore it is quite oblivious that two separate chunk of memory is allocated

& their starting address has to be stored in s1 & s2 respectively.

So, s1 cannot be equal to s2. Concept is absolutely correct. But, in case of

string object when the constructor is called implicitly, JVM behaves in

different way. Strings are immutable i.e. content of a string object can not

be altered in a given reference. So when JVM implicitly calls the string class

constructor, first JVM searches the heap area whether any memory chunk of

string object that has the same character set in same sequence available or

not. If such a memory chunk is available then, instead of allocating new

memory chunk it uses the existing one.

In the above program, s1 & s2 has the same character set in the same

sequence. JVM first allocates memory to s1 from heap say 1000 as shown in

the figure. When s2 is encountered, JVM searches the heap to find whether

same character set in same sequence present or not, & it gets. So instead of

allocating new memory chunk, JVM assigns the starting address of the

memory chunk that has been allocated to s1, allocates to s2. So s2 also

contains 1000. when programmer explicitly calls the constructor through

new operator a new separate memory chunk is allocated. So s1 is now not

equal to s2

class Demo


{ String s1="java";

String s2=new String("java"); if(s1==s2)

System.out.println("hello"); }

}

Output:

no output

235

A closer look at equals() & hashCode() method

In case of String class, the equals() method & the hashCode() has been over

ridden. The hashCode() method returns the same unique integral value for

any two objects that compared as equal and a different integral value for

any two objects that is not compared equal & equality is inspected by the

equals() method. Except String class in all cases equal method checks the

content of reference variable, if the content is same then it returns true.

class X

{ int x;

} class Demo


{

X d1=new X(); d1.x=9;

X d2=new X(); d2.x=9;

if(d1.equals(d2)) System.out.println("Hello! We are same.");

else System.out.println("No, We are different.");

if(d1==d2) System.out.println("Same same dear.");

else System.out.println("Believe dear we are different.");

}

}

Output:

No, We are different.

236

Believe dear we are different.

In the above program, JVM has allocated two different chunk of memory to

d1 & d2. Since d1 & d2 both are reference variables, they are going to

contain the starting address of the memory chunk allocated to them. So the

content of d1 & d2 is entirely different. == operator & equals method

checks the content of reference variables & since the content is different

output is quite obvious. But, the story is different in case of String objects.

Check this program

class Demo

{


String d1=new String("Java"); String d2=new String("Java");





}

}

Output:

Hello! We are same. Believe dear we are different.

Foxed dear!!! Why different output?

Let me explain the program from the very beginning. d1 & d2 are the

reference variables of String class. I have explicitly invoked the constructor

of string class through new operator. JVM allocates memory from heap to d1

& d2. Definitely d1 & d2 have different address. So d1 is not equal to d2. ==

237

operator checks the content of d1 & d2, since the are different out put is as

usual. But, in case of equals method, as I have said behave in a different

way in case of String class. equls() method checks whether the character

sequence & character case (upper or lower) is same or not while invoked by

string objects. If the character sequence & character case is same then

equals method returns boolean true else false. The hashCode() method

returns the same integral value if the equals() method returns boolean true

value for two objects. See the program below

class Demo


{

String d1=new String("Java"); String d2=new String("Java");





System.out.println(d1.hashCode()); System.out.println(d2.hashCode());

}

}

Out put: Hello! We are same.

Believe dear we are different. 2301506

2301506

See since the character set & character sequence is same in both String

objects, equals() method returns the same Boolean true value. There fore

hashCode() method returns same value for two objects. All these stuffs are

only because Strings are immutable.

238

Some Important Methods of String class with example:-

public int length()

this method is used to determine the length of the string. class Demo{


String s1="Hello world"; int i=s1.length();

System.out.println(i); }}

Output: 11

public char charAt(int index) this method is used to extract a specified character from the string by

the particular index supplied by the programmer. The index supplied

must be within the length of the string.

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

{ String s1="Hello world";

char ch=s1.charAt(2); System.out.println(ch);

}} Output: l

Suppose the programmer supplies the index which is greater than the length of the string then string out of bound exception will be

generated. For example class Demo{



char ch=s1.charAt(12); System.out.println(ch);

}} Upon execution this program throws string out of bound index

exception. public void getChars(int start,int end,char c[], int index_1)

this method is used to copy the set of Unicode characters from the string from the index supplied through the start variable up to the

index represented by end variable in to a character array c. the last variable index_1 represents the index number of the array from which

the characters copied from the string has to be stored.

239

class Demo{


String s1="Hello world"; char ch[]=new char[5];

s1.getChars(1,3,ch,2); for(int i=0;i<5;i++)

System.out.println(ch[i]); }}

Output:

e

l

public byte[] getBytes() this method is used to to convert a unicode string in to to an array of

bytes class Demo{


String s1="Hello"; int i=s1.length();

byte b[]=new byte[i]; b=s1.getBytes();

for(int j=0;j<i;j++) System.out.println(b[j]);

}} Output:

72

101 108

108 111

public boolean equalsIgnoreCase(String s) this method is used to compare two strings ignoring the upper or lower

case. class Demo{


String s1="Hello world"; String s2="hello world";

boolean b=s1.equalsIgnoreCase(s2);


240


}} Output:true

public int compareTo(String sobj); this method is used to compare two strings. Lets have an example how

this method behaves. class Demo {

public static void main(String[]args) {

String s1="Java"; String s2="C++";

int i=s2.compareTo(s1); System.out.println(i);

} }

Output:

-7 Ok fine now check these two programs


{ String s1="Java";

String s2="C++"; int i=s2.compareTo(s2);

System.out.println(i); }

} Output:

0

class Demo {


String s1="Java"; String s2="C++";

int i=s1.compareTo(s2); System.out.println(i);

} }

Output:7 Conclusion is that

i<0 means invoking string is less than the string taken as argument. i=0 both the string object are same.

i>0 means string is greater than the string taken as argument.


241

Actually how the comparison is made only through the length. No absolutely

not. Comparision is done through dictionary order & upper case letter comes first. See the example below


{ String s1="Java";

String s2="java"; int i=s1.compareTo(s2);


} Output: -32

public boolean startsWith(String prefixValue,int index) checks whether the string begins with the specified prefixValue

from specified index class Demo {


String s1="Java is cool";

boolean i=s1.startsWith("cool",8); System.out.println(i);

} }

Output: true public boolean startsWith(String prefixValue)

checks if the string starts with the specified prefixVlaue. So you

can feel that startsWith method of string class is overloaded. class Demo {


String s1="Java is cool";

boolean i=s1.startsWith("Java"); System.out.println(i);

} }

Output true public boolean endsWith(String suffixValue)

242

checks whether the string ends with the specified suffixVlaue or

not. public int indexOf(int ch)

this method is used to return the place value of the specified character in the string.



int b=s1.indexOf('w');

System.out.println(b); }}

Output:6 public int indexOf(int ch,int fromIndex)

this method returns the place value of the specified character with in the

string. If the string does not have the character with in the string then -1 is returned. This checking is done with respect to the integer value

fromIndex. class Demo{


String s1="Hello world";

int b=s1.indexOf('l',4); System.out.println(b);

}} Output 9

class Demo{



int b=s1.indexOf('l',4);


Output:2



243

int b=s1.indexOf('H',4);


Output: -1 public int lastIndexOf(int ch)

public String concat(String str) adds the string send in the argument to at the end of the string

through which it is invoked. class Demo{


String s1=" Hello"; String s2=s1.concat(" World");

System.out.println(s2); }}

Output: Hello World

public String toLowerCase()

this method is used to convert all the characters present in the string to lower case & assigns it to a new string object.


{ String s1="Hello World";

String s2=s1.toLowerCase();


Output: hello world

public String toUpperCase() this method is used to convert all the characters present in the string to

upper case & assigns it to a new string object.

public String trim() this method is used to eliminate the white space from the

beginning of the string. class Demo{


String s1=" Hello World";


244

String s2=s1.trim(); System.out.println(s1);


Output: Hello World Hello World

public char[] toCharArray()

this method is used to convert the string to character array. class Demo{


String s1=" HELLO WORLD"; int i=s1.length();

char ch[]=new char[i];

ch=s1.toCharArray(); for(int j=0;j<i;j++)

System.out.println(ch[j]); }}

Output:

H E

L L

O

W O

R

L D

245

Chapter-15

StringBuffer

StringBuffer is a class present in java.lang package. StringBuffer is a final

class. StringBuffer class cannot be inherited as it is a final class. StringBuffer

class in java is a sub class of java.lang.Object class & implements the

interfaces CharSequence, Serializable.

An instance of StringBuffer class represents a String that can be

dynamically modified. String class objects are immutable where as a StringBuffer class objects are mutable. StringBuffer object is like a String,

but can be changed or modified. StringBuffer object is auto flushed.

Constructor of StringBuffer

StringBuffer() This constructs an empty StringBuffer StringBuffer(int capacity) This constructs an empty StringBuffer with

the specified initial capacity. StringBuffer(String s) This constructs a StringBuffer that initially

contains the special String.

Methods of StringBuffer

public synchronized int length() : returns the length of the

StringBuffer. public synchronized int capacity() : returns the capacity of the

StringBuffer. A StringBuffer has a capacity, which is the longest String it can represent without needing to allocate more memory.

public synchronized void setLength(int length) :This method is used to set the length of the StringBuffer.

public synchronized void ensureCapacity(int capacity) :This method is used to set the capacity of the StringBuffer.

public synchronized char charAt(int index) :This method returns a character from the StringBuffer.

public synchronized void getChars(int stat,int end,char c[],int

index) :This method extract more than one character from the StringBuffer.

246

public synchronized void setCharAt(int index, char ch) :This

method set a character in the StringBuffer. public synchronized StringBuffer append(Object o) :This method

calls toString() on Object o and append the result to the current StringBuffer.

public synchronized StringBuffer append(String s) :This method append a String in the StringBuffer.

public synchronized StringBuffer append(StringBuffer sb) : public synchronized StringBuffer append(char c) :

public synchronized StringBuffer delete(int index, int length) : This method is used to delete more than one character from the

StringBuffer. public synchronized StringBuffer deleteCharAt(int index) : This

method is used to extract a character from the StringBuffer. public synchronized StringBuffer replace(int index, int length,

String s) :This method is used to replace a String in the StringBuffer.

public synchronized StringBuffer insert(int index, String s) :This method is used to insert a String in the StringBuffer.

public synchronized StringBuffer reverse() :This method is used to reverse the StringBuffer.

public String toString() :This method is used to convert the String to StringBuffer.

247

Chapter-16

Wrapper class:

Each java primitive data types has a corresponding wrapper class. When we

create an object of the wrapper class, it contains a field and in this field primitive data types are stored.

Primitive data types Wrapper class

boolean Boolean

byte Byte

short Short

char Character

int Integer

float Float

long Long

double

Double

Why We Require Wrapper Class? Vector, ArrayList, LinkedList classes present in java.util package cannot handle primitive

data type like int, char, float etc. hence primitive may be converted into object type using Wrapper classes present in java.lang package.

Wrapper class converts primitive data types into objects.

Character

Character class object is a wraps around a char.

The Constructor is

Character (char ch)

To obtain the char value contained in the Character object is

Methods:

public static Character valueOf(char c): this method converts a single

character into Character class object.

public char charValue( ): This method is useful to convert character class

object into primitive char value.

public int hashCode(): returns the hash value of Character class Object.

248

public static String toString(char c): This method coverts char data types

into String.

Boolean

Boolean is wrapper around boolean value. The constructor of the Boolean

class is overloaded.

Boolean(boolean b)

Boolean(String s)

If the s contains the String “true” (in uppercase and in lowercase) then the

Boolean object hold true values. Otherwise the Boolean object will hold false

vales.

To obtain a boolean value contained by the Boolean object is

boolean booleanValue()

Methods:

public static boolean parseBoolean(String s): converts String to boolean

public boolean booleanValue() :Extract boolean value from the Boolean

Object.

public static String toString(boolean b) : This method coverts boolean data

types into String.

public int hashCode() : returns the hash value of Character class Object.

public static Boolean valueOf(String s) :This method convert a String that

contains a boolean value into Boolean object.

public static Boolean valueOf(boolean b): This method converts a boolean

value into Boolean object.

Number

Number is an abstract class whose subclass is Byte, Short, Integer, Float,

Long and Double.

The method of the Number class is override in the child classes. Methods of

the Number class are:

249

byte byteValue()

short shortValue()

int intValue()

float floatValue()

long longValue()

double doubleValue()

Byte class:

Byte class wraps a value of the primitive type “byte” in an object. The Byte

class object contains byte value.

Constructor:-

Constructor of Byte class is Overloaded

Byte(byte b)

Syntax:-

Byte b1=new Byte ((byte) 12);

Byte(String s)

Syntax:-

Byte b2=new Byte (“45”);

Byte b3=new Byte(“Java”);//when we extract the value from the b3 object

then the program is terminated at runtime by throwing an Exception

“NumberFormatException”.

Methods:

public static byte parseByte(String s): Converts String to byte datatype.

public static Byte valueOf(String s): Converts String to Bye class object.

public static Byte valueOf(byte b): Converts byte value to Byte class object.

public int hashCode(): returns the hash value of Byte class Object

public static String toString(byte b): Converts byte value to String

250

Short class:-

Short class wraps a value of the primitive type “short” in an object. The

Short class object contains short value.

Constructor:-

Constructor of Short class is Overloaded

Short(short s)

Syntax:-

Short s1=new Short ((short) 12);

Short(String s)

Syntax:-

Short s2=new Short (“45”);

Short s3=new Short (“Java”);//when we extract the value from the s3

object then the program is terminated at runtime by throwing an Exception


Methods:

public static short parseShort(String s): converts String to short data types.

public static String toString(short s): Converts short data types to String.

public static Short valueOf(String s): Converts String to Short class object.

public static Short valueOf(short s): converts short data types to Short class

Object.

public int hashCode(): Returns the hash value of Short class Object.

Integer class:-

Integer class wraps a value of the primitive type “int” in an object. The

Integer class object contains int value.

Constructor:-

Constructor of Integer class is Overloaded

Integer(int b)

251

Syntax:-

Integer i1=new Integer(12);

Integer(String s)

Syntax:-

Integer i2=new Integer (“45”);

Integer i3=new Integer (“Java”);//when we extract the value from the i3



Methods:

public static int parseInt(String s): converts String to int data type.

public static String toString(int s): converts int dada type into String.

public static Integer valueOf(String s): Converts String class object into

Integer class Object.

public static Integer valueOf(int s): converts int data type into Integer class

object.

public int hashCode(): Returns the hash value of Integer class Object.

Long class:-

Long class wraps a value of the primitive type “long” in an object. The Long

class object contains long value.

Constructor:-

Constructor of Long class is Overloaded

Long(long l)

Syntax:-

Long l1=new Long (12);

Long(String s)

Syntax:-

Long l2=new Long(“45”);

252

Long l3=new Long (“Java”);//when we extract the value from the l3 object



Methods:

public static long parseLong(String s): Convert String class object into long

data types.

public static String toString(long s): Converts long data types into String.

public static Long valueOf(String s): Converts String class Object into Long

class Object.

public static Long valueOf(short s): Converts long data types into Long class

object.

public int hashCode(): Returns the hash value of Long class Object.

Float class:-

Float class wraps a value of the primitive type “float” in an object. The Float

class object contains float value.

Constructor:-

Constructor of Float class is Overloaded

Float(float b)

Syntax:

Float f1=new Float ((float) 12.5);

Float(String s)

Syntax:-

Float f2=new Float (“45”);

Float f3=new Float(“Java”);//when we extract the value from the f3 object



253

Method:

public static Float parseFloat(String s): Converts String class object to float

data type.

public static String toString(float s): Converts float data types into String.

public static Float valueOf(String s): Converts String class object into Float

class Object.

public static Float valueOf(float s): Converts float data types into Float class

Object.

public int hashCode(): Returns the hash value of Float class Object.

Double class:-

Double class wraps a value of the primitive type “double” in an object. The

Double class object contains double value.

Constructor:-

Constructor of Double class is Overloaded

Double(double b)

Syntax:-

Double s1=new Double (23.09);

Double(String s)

Syntax:-

Double d2=new Double (“5.9”);

Double d3=new Double (“Java”);//when we extract the value from the d3



254

Method:

public static double parseDouble(String s): Converts String class object to

double data type.

public static String toString(double s): Converts double data types into

String.

public static Double valueOf(String s): Converts String class object into

Double class Object.

public static Double valueOf(double s): Converts double data types into

Double class object.

public int hashCode(): Returns the hash value of Double class object.

Example-1

public class Wrap1

{

public static void main(String rs[])

{

String s="22";

int i=Integer.parseInt(s);

i++;


double d=Double.parseDouble(s);

d+=5;

System.out.println(d);

short s1=Short.parseShort(s);

s1+=10;

System.out.println(s1);

255

s=Integer.toString(i);

s+=1;

System.out.println(s);

s=Double.toString(d);

s+=12;


s=Short.toString(s1);

s+=2;


}

}

Auto boxing and Auto unboxing:

J2SE 5 supports auto boxing process by which a primitive type is

automatically encapsulated into its equivalent type wrapper class object.

There is no need to explicitly construct a wrapper class object. This

technique is popularly known as autoboxing in java. Whereas unboxing is

required to convert Wrapper class Object into subsequent primitive data

types. In general, autoboxing and unboxing take place whenever a

conversion into an object or from an object is required.

256

Example-2

public class Auto

{

Boolean b1=new Boolean("yes");

boolean b=b1;

void show()

{

if(b){

System.out.println("You Need Money");;

}else{

System.out.println("You Need Knowledge");

}

}


{

Auto a=new Auto();

a.show();

}

}

Output:

257

Chapter-17

Taking Input from keyboard

In java you can take the input from keyboard in three ways.

1st: Through command line

In any java program the signature of main method is as follows


Here args is an array of strings. This string array is capable of storing

various string elements that is passed to the program from command line

during the execution of java program. Lets have an example

Demo1.java

class Demo1{


{

System.out.println(args[0]);

}

}

Compile this program by javac Demo1.java

During the execution phase you are going to provide the command line

argument which is of string type. This can be done by

java Demo1 Hello

& the out put will be Hello. In java the zeroth argument is the string supplied

by the user as in this case Hello is the zeroth argument. But, always

remember that the arguments or the input supplied to the java program

258

from the command prompt are always in the form of string. So you have to

use different method & techniques to get it converted to desired type. And

one thing strings are objects in java. In command line 1st argument 0th

argument is separated by space. To access the 1st argument you to use

args[1] & so on.

e.g.

Demo2.java

class Demo2 {

public static void main (String args[])

{

String s=args[0]+args[1];


}

}

Input java Demo hello world

Output

helloworld

Whatever the argument we pass from the command line are in String format

as every arguments are stored in array of String argument. When we extract

the element then we extract the element through the array indexes. If the

array index cross the range then the program is terminated at the runtime

by generating ArrayIndexOutOfBoundsException.

e.g.

public class Demo3

{


259

{

int i=0;

while(i++<args.length)

{

System.out.println(args[i]);

}

}

}

Compile the application by javac Demo3.java

Execute it by java Demo3 A B C

Output

B

C

Program is terminated by throwing

java.lang.ArrayIndexOutOfBoundsException.

2nd: by the use of readLine() method

The readLine () method is available in the java.io package. So you have to

import that package. The syntax of the method is

public String readLine()throws IOException

{

}

This method present in BufferedReader and DataInputStream class. Both the

class present in java.io package. As the method return type is String then

the given input is in the string format. But the programmer is bound to

260

handle IOException as the method throws IOException. Lets have an

example:

import java.io.*;

class Demo{

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

{

InputStreamReader is=new InputStreamReader(System.in);

BufferedReader br=new BufferedReader(is);

System.out.println(“Enter The Data From Keyboard”);

Stsring s=br.readLine();

System.out.println(“Output Is ”+s);

}

}

Compile the application by javac Demo.java

Execute it by java Demo

Output is:

Enter The Data From Keyboard

Hello World

Output Is Hello World

Here notice the additional phrase attached to main method. throws

IOException this phrase is added to main method because signature of

readLine () method has throws IOException. Till now remember that when

ever you are going use a method which has signature of throwing any

261

Exception then, with in which such a method is called, that method must

have throws Exception_Object.

Another way is that invoke the method readLine () inside a try catch block.

import java.io.*;

class Demo{


InputStreamReader is=new InputStreamReader (System.in);

BufferedReader br=new BufferedReader(is);

String s;

try{

s=br.readLine();

}catch(IOException e)

{

}


}

Input: Hello World

Output: Hello World

System.in is the keyboard. InputStreamReader behaves like a channel

connected to it. readLine() method reads the data & store it in the string s.

3rd(By using Scanner class)

Scanner is a class present in java.util package. Scanner reads formatted

input and converts it into binary form. Scanner class is used to read all types

of numeric values, String and other types of data from any input sources.

262

Scanner can be used to read input from the console, from a file, from a

String or any source that implements Readable interface.

Constructor:

FileReader fr=new FileReader (“a.txt”);

Scanner s1=new Scanner (fr);

Scanner s2=new Scanner (System.in);

String s=”Interface Software”;

Scanner s3=new Scanner(s);

Method Description

boolean hasNext() Returns true if another token of any

type is available to be read.

boolean hasNextBoolean() Returns true if a boolean value is

available to be read.

boolean hasNextByte() Returns true if a byte value is


boolean hasNextShort() Returns true if a short value is


boolean hasNextInt() Returns true if a int value is available

to be read.

boolean hasNextFloat() Returns true if a float value is


boolean hasNextLong() Returns true if a long value is


263

boolean hasNextDouble() Returns true if a double value is


boolean hasNextLine() Returns true if a line of input is

available.

String next() Returns the next token of any type

from the input source.

boolean nextBoolean() Returns the next token as a boolean

value.

byte nextByte() Returns the next token as a byte

value.

short nextShort() Returns the next token as a short

value.

int nextInt() Returns the next token as a int

value.

long nextLong() Returns the next token as a long

value.

float netFloat() Returns the next token as a float

value.

double nextDouble() Returns the next token as a double

value.

String nextLine() Returns the next line of input as a

String.

Procedure of using Scanner

Determines if a specific type of input is available by calling one of

Scanner‟s hasNextXXX method.

If input is available, read it by calling one of Scanner‟s next() method.

Repeat the process until the input is exhausted.

How to take an integer from key board

264

import java.util.*;

class Demo

{ public static void main(String[] args)

{ Scanner sc=new Scanner(System.in);

System.out.println(“Enter A Number”); int i=sc.nextInt();

System.out.println(“Output Is :”+i); sc.close();

} }

Enter A Number

5

Output Is :5

How to take a float variable

import java.util.*;

class Demo {


{ Scanner sc=new Scanner(System.in);

System.out.println(“Enter A Floating point value”); float i=sc.nextFloat();

System.out.println(“Output Is: ”+i); sc.close();

} }

Enter A Floating point value

10.123

Output Is: 10.123

To use the Scanner class & the methods those belongs to scanner class you have to import the java.util package. System.in represents keyboard. After

265

taking the input you have to close the scanner by the invocation of close

method.

To take boolean value as input

import java.util.*;

class Demo {


Scanner sc=new Scanner(System.in); System.out.println(“Enter a boolean value”);

boolean i=sc.nextBoolean(); System.out.println(“Output Is :”+i);

sc.close();

} }

Enter a boolean value

true Output Is :true

To take byte from key board

import java.util.*;

class Demo

{


Scanner sc=new Scanner(System.in); System.out.println(“Enter A Byte”);

byte i=sc.nextByte(); System.out.println(“Output Is :”+i);

sc.close(); }

} Enter A Byte

23 Output Is :23

266

To read a string from keyboard

import java.util.*;

class Demo {


Scanner sc=new Scanner(System.in); System.out.println(“Enter The Text”);

String i=sc.nextLine(); System.out.println(“Output Is ”+i);

sc.close(); }

}

Enter The Text

hello world Output:hello world

267

Chapter-18

JAVA NATIVE INTRFACE

Overview:

In JAVA native is a modifier. The native modifier can refer

only to methods. Like the abstract keyword, native indicates that the body of

a method is to be found elsewhere. In the case of the abstract methods, the

body is in a subclass but in case of native methods, the body lies entirely

outside the java virtual machine, in a library. People who port java to new

platform implement extensive native code to support GUI components,

network communication and a broad range of platform specific functionalities

.However it is rare for applet and application programmers to use the native

codes. JNI never imposes any restriction to the JVM. This is one of the vital

importance of JNI. Therefore, Java VM vendors can add support for the JNI

without affecting other parts of the VM. Now let‟s discuss what are the

situations when java programmer needs the native method.

1: If client requires platform dependent features in java but the standard

java class library supports the platform independent feature. In this situation

programmer required JNI for supporting platform dependent feature in java.

2: When the programmer already develops the code in C and C++ and wish

to make it accessible to Java code then the programmer must required JNI.

3: When the programmer wants to develop small portion of time-critical

code by using a lower-level language such as assembly then the programmer use JNI.

By programming through the JNI, Programmer use native methods to:

Create, inspect, and update Java objects. Call Java methods.

catch and throw Exception. Load classes and collects class information.

Perform runtime type checking.

268

JNI can be used with Invocation API to embed any native application in JVM.

Drawback of native code is that it violates java‟s platform independent

features and since binary files are generated during native implementation

therefore this procedure has less security.

Java native interface allows java byte-codes to communicate with foreign

methods like C/C++. Advantage of such a technique is that byte-codes can able to communicate with executable files which execute faster, hence

increases the performance. In java native code or native method accesses JVM features by calling JNI functions. In java JNI functions are available by

using an interface pointer. An interface pointer is a pointer to a pointer to a structure. This structure pointer points to a set of pointers to

function which is inside the structure Java Native Interface

The best way to grasp the concept is through an example.

JAVA - C COMMUNICATION

//Java - C Communication

public class p {

int i; public static void main(String args[])

{ p x=new p();

x.i=10; System.out.println(x.i);

x.fun();

//Native method calling. System.out.println(x.i);

} public native void fun();

269

//Native method declaration.

static{ System.loadLibrary("p");

} }

Step 1: Compile it with javac p.java

This will generate the class file as p.class

Step 2: Create the header file by the command javah p

This will generate the header file p.h .

p.h

/* DO NOT EDIT THIS FILE - it is machine generated */

#include <jni.h> /* Header for class p */

#ifndef _Included_p

#define _Included_p #ifdef __cplusplus

extern "C" { #endif

/* * Class: p

* Method: fun * Signature: ()V

*/

JNIEXPORT void JNICALL Java_p_fun (JNIEnv *, jobject);

#ifdef __cplusplus

} #endif

#endif

The above two steps are same for WINDOWS and LINUX

270

For LINUX:

Step 3: create the .C file p.c

Note that: For LINUX the .C file name should be same as that of the java

file name otherwise run time error will arise.

p.c

#include"p.h"

#include”jni.h”

#include"stdio.h"

JNIEXPORT void JNICALL Java_p_fun

(JNIEnv *env, jobject obj)

{

jclass cls;

jfieldID fid;

jint i;

printf("Hello");

cls=(*env)->GetObjectClass(env,obj);

fid=(*env)->GetFieldID(env,cls,"i","I");

i=(*env)-> GetIntField(env,obj,fid);

printf("%d",i);

}

271

Step 4: create the object file by

gcc –O –fpic -c p.c

Note that: In case you are using multithreading in your programs you have to use the –D_REENTRANT attribute along with the command to create the

object file.

gcc -O -D_REENTRANT -fpic -c p.c

Step 5: create the libp.so(shared library) file by

gcc -shared -o libp.so p.o

Step 6: get the output by

java –Djava.library.path=. p

On windows platform:

Step 3: CL/LD p.c

To create dynamic linking library

java p

to execute java program

p.java file is a usual java file. Header file p.h is generated by JVM, it

contains the prototype declaration of the native method. Native methods are loaded when the programmer call a static method of System

class,

public static void loadLibrary()

272

JNIEXPORT void JNICALL Java_p_fun

(JNIEnv *, jobject)

Signature: V() inside the comment line indicates that the return type of

native method is void. The signature of other return types are listed below

Type Signature

Java Type

Z boolean

B byte

C char

S short

I int

J long

F float

D double

L fully-qualified-class ; fully-qualified-class

[ type type[ ]

( arg-types ) ret-type method type

Consider the p.c file. It takes the argument JNIEnv *env & jobject obj.

typedef const struct JNINativeInterface *JNIEnv;

JNIEnv is a pointer to the structure JNINativeInterface which contains

function pointers. Lets understand the concept through an example.

Consider the C program below

void fun()

{

273

printf(“Hello World”);

}

struct xxx

{

void(* p)();

} ;

typedef struct xxx *struct_ptr ;

int main()

{

struct_ptr *pointer ;

struct xxx a,*ptr1;

a.p=&fun;

ptr1=&a;

pointer=&ptr1;

(*pointer)->p();

}

The out put will be Hello World.

You can see that JNIEnv *env is similar to that of struct_ptr *pointer &

struct xxx is similar to that of JNINativeInterface .

Now consider the second argument jobject obj, obj holds the value of the

this pointer that points to the current object that is x here. GetObjectClass(JNIEnv *,jobject); is a function pointer inside the structure

JNINativeInterface. While java is communicating with C jobject & jclass both are same. jclass is typedef as jobject(typedef jobject jclass).

GetOBjectClass returns the reference of the current object which is stored in

274

cls. GetFieldID reurns the reference held by cls to access the various class

member present in the class. Prototype of GetFieldID is

jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig);

Here name parameter holds the name of the class element to be accessed

by the native method & sig parameter holds signature of the class element. Both these parameter are pointer to character constant. In the program,

„name‟ holds the name of the class element that is „i‟ & „sig‟ holds I, signature of „i‟ to indicate that i is of integer type. GetIntField(env,obj,fid);

rturns the value of i. Similarly if the class contains a float variable then to

access that variable the function will be GetIFloatField(env,obj,fid);

Example 2:

p1.java

//Get Your Native Interface Version.

class p1{ public native void fun();


new p1().fun(); }

static{ System.loadLibrary("p1");

} }

p1.h /* DO NOT EDIT THIS FILE - it is machine generated */

#include <jni.h> /* Header for class p1 */

#ifndef _Included_p1

#define _Included_p1 #ifdef __cplusplus

extern "C" { #endif

/*

275

* Class: p1

* Method: fun

* Signature: ()V

*/ JNIEXPORT void JNICALL Java_p1_fun

(JNIEnv *, jobject);

#ifdef __cplusplus }

#endif #endif

p1.c #include"p1.h"

#include"stdio.h" JNIEXPORT void JNICALL Java_p1_fun

(JNIEnv *a, jobject b) {

jint i=(*a)->GetVersion(a); printf("%x",i);

}

Both these examples have i‟s data type as jint. In JNI int is typedef as jint.

Similarly the typedef version of other java data types are listed below.

Java Type Native Type Description

boolean jboolean unsigned 8 bits

byte jbyte signed 8 bits

char jchar unsigned 16 bits

short jshort signed 16 bits

int jint signed 32 bits

long jlong signed 64 bits

276

Java Type Native Type Description

float jfloat 32 bits

double jdouble 64 bits

void void N/A

Example 3:

//Static native method

p2.java

class p2{ public native static void fun();

static{ System.loadLibrary("p2");

} public static void main(String aegs[])

{ p2.fun();

}}

p2.h

/* DO NOT EDIT THIS FILE - it is machine generated */ #include <jni.h>

/* Header for class p2 */

#ifndef _Included_p2

#define _Included_p2

#ifdef __cplusplus

277

extern "C" {

#endif

/*

* Class: p2 * Method: fun

* Signature: ()V */

JNIEXPORT void JNICALL Java_p2_fun (JNIEnv *, jclass);

#ifdef __cplusplus

} #endif

#endif

p2.c

#include"stdio.h"

#include"p2.h" JNIEXPORT void JNICALL Java_p2_fun

(JNIEnv * a, jclass b) {

printf("Hello C, From JAVA"); }

Since the native method is static therefore second argument to the function

JNIEXPORT void JNICALL Java_p2_fun (JNIEnv * a, jclass b) is of jclass type. I have already told that when java communicate with C, jclass &

jobject are exactly the same thing so you can replace jclass with jobject.

278

Chapter 19

Multithreading

Introduction

Thread!!!! What is a thread? Threads, processes, context-switch, scheduler

these are the closely associated terms belongs to the Operating System

fundamentals. Multi threaded programming approach is one of the powerful

feature of Java. To grab the concept of multithreading you have to

understand the fundamental aspects of operating system mentioned above.

So let‟s start our voyage.

What happens when you click on the icon (Or shortcut) of Project IGI

(a computer game)? Its executable file is loaded in to the RAM of your PC

from secondary storage device & the game starts. You can say that Project

IGI is in execution phase. Any computer program in its execution phase is

known as process. A program will be termed as a process till it is located

inside RAM. You people have definitely come across the names of Unix,

Linux, Windows Xp, Windows Vista as multi tasking operating system. So

what is multi tasking operating system? Operating systems those can

perform multiple tasks at a particular instant of time is known as multi

tasking OS. “Multiple tasks at a single instant of time” is it really possible?

Whatever PCs you are using, those have only one processor. At any instant

of time only one task or one process can be executed by the processor. The

definition of multitasking OS does not provide the clear picture. Actually in

case of multi tasking OS, multiple tasks are submitted to the processor for

execution & processor keeps switching between different tasks. Got it!!! If

not just think about yourself. If multiple tasks are given to you what do you

do? Say in a Sunday morning you have planed to do these following tasks

1: Complete the novel White Tiger (a 1000 page book)

2: watch the TV show Office-Office at 9.30 a.m.

3: Meet to a friend at 11 a.m.

So what should be your way to complete these things? Definitely if you try

to complete the novel 1st then do the tasks in a sequence then you cannot

complete all of your planed tasks. In the early versions of OS, they do the

tasks in the order of their arrival. Next task is performed only when one task

279

is completed. These types of OS are known as single tasking operating

system. So what I mean to say is you can not behave as single tasking OS

to complete all of your scheduled jobs. What you will do start the novel say

at 8.30 a.m. At 9.30 a.m. put a mark on the book & watch the T.V show.

After your show is completed you will start the book from where you have

left. Again at 11 a.m. you will put a mark on the book & go to meet to your

friend & when you will back again start the book from where you have left.

Multitasking OS simply follow your procedure to complete their assigned

tasks. They just keep switching between different tasks (from OS

prospective tasks are known as processes). The process of switching

between different processes are known as context switch. This technique

improves the efficiency. The switching of process is so fast that it pretends

the user as multiple tasks are done at a single instant of time. The normal

question that comes in mind is that how this concept improves the

efficiency. Let me give an example

You all know that IO devices of your system are quite slow as

compared to the speed of the processor. If process needs a data from IO

device, it has to wait until the data is available. In single tasking OS,

processor will remain ideal until the data is available in IO device. The

processor time is wasted. But, in case of multitasking OS processor switch to

another process & when the data is available in the IO device it will again

switch back to the previous process. Just like you multitasking OS keeps the

mark to track the correct path of execution when context switch is

performed. These marks are maintained in a component of OS known as

Task Control Block. Another component of OS known as scheduler is

responsible in determining which task has to be performed. But, what is

thread? Definition of thread is: Thread is a light weight process. If you have

multiple

related tasks then it is always better to create threads then to create a new

process. Creating a new process involves 30% more over head instead of

creating new process.

Benefits of Multithreading :

in a multi threaded application different parts of the application is executed

by different threads. If any of the thread is blocked during the execution of

the application then the entire application never halts. e.g. A multithread

280

web browser could still allow user interaction in one thread while an image

was being loaded in other thread.

Incase of multiprocessor architecture, different threads are allocated to

different processors. Each thread is executed in different processors in

parallel.

Three main thread libraries are use in today.

a) POSIX Pthreads.

b) Win32.

c) Java.

Creation of thread in java

Thread is created in java by implementing the Runnable interface available

in java.lang package. The Runnable interface contains only the run method

which has to be over ridden. Now let‟s write a program to create the thread

class MyThread implements Runnable {

public void run() {

System.out.println("hello"); }

} class Thread1{


MyThread x=new MyThread();

Thread t=new Thread(x); t.start();

}

}

Output:

hello

Steps to create thread:

281

You have to implement the Runnable interface & override the run method.

Just by implementing runnable interface thread is not created. I would

rather say that by implementing the runnable interface you have created the

task object & the code for the task is embedded inside the over ridden run

method. Inside the main method thread class reference points to the task

object by calling the thread class constructor which takes the task object as

its argument. Here you can say that job is attached to the thread. Then the

start method is invoked through the thread class reference variable. It is the

entry point of the thread for execution. Start method tells to the JVM that

thread is ready for execution. Then thread will wait until it is called by

scheduler. I have seen in many java books that threads are created by

extending thread class. There is absolutely no problem at all syntactically,

but from OOP prospective the programmer can extend a class only when he

has to increase its functionality. So I will suggest that be a nice Object

Oriented Programmer & implement the Runnable interface to create the

thread.

Determination of name of currently running thread

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

System.out.println(Thread.currentThread()); }

}

Output:

Thread[main,5,main]

Here the method currentThread() is used to determine the name of the

currently running thread. It is a static method. It returns the name of the

thread where it is invoked. Check the out put Thread indicates the currenly

executing thread is a Thread class object, main is its name, 5 is its priority,

main is its group. When ever you create a thread in java a priority is always

associated with it. Priority value is varied from 1 to 10. 1 is the minimum

priority & 10 is the maximum priority. Thread having maximum priority is

preferred over thread having minimum priority by the scheduler of JVM.

Each thread in java has a default priority level 5. The next main indicates

the name of the group to which thread belongs.

Thread Priorities

282

Every thread has a priority, which is an integer from 1 to 10; threads with

higher priority should get preference over threads with lower priority. The priority is taken in to account by the thread scheduler when it decides which

ready thread should execute. The thread having highest priority is choosen by the scheduler to be executed first . The default priority is 5. To set a

thread‟s priority, call the setPriority() method, passing in the desired new priority. The

getPriority() method returns a thread‟s priority. The Thread class also has constants to define the priority of the thread.

MIN_PRIORITY (which is= 1), and NORM_PRIORITY (which is= 5) the MAX_PRIORITY (which is=10)

Program to determine the priority of current thread

class X implements Runnable{

public void run()

{ System.out.println(Thread.currentThread()+"Hello X");

}

}


X o=new X(); Thread t1=new Thread(o,"1st");

System.out.println(t1.getPriority());

t1.start(); }

} Output:

5 Thread[1st,5,main]Hello X

Setting the priority of a thread class X implements Runnable{

public void run()

{ System.out.println(Thread.currentThread()+"Hello X");

283

}

} class Demo {

public static void main(String[] args){ X o=new X();

Thread t1=new Thread(o,"1st"); t1.setPriority(8);

t1.start();

} }

Output: Thread[1st,8,main]Hello X

I have already told that thread priority plays vital role when comes to be

selected by scheduler for execution. See the program below


public void run()

{ System.out.println(Thread.currentThread());

}

} class Demo {


X p=new X();

Thread t1=new Thread(o,"1st"); Thread t2=new Thread(p,"2nd");

t1.setPriority(3); t2.setPriority(9);

t1.start(); t2.start();

} }

Output: Thread[2nd,9,main]

Thread[1st,3,main]

284

Process of yielding

Yielding is the process through which currently executed thread goes to

ready state from running. If any other thread is waiting for execution then

that thread might get chance for execution.


public void run() {

System.out.println(Thread.currentThread()); Thread.yield();

System.out.println(Thread.currentThread());

}

} class Demo {


X p=new X(); Thread t1=new Thread(o,"1st");

Thread t2=new Thread(p,"2nd"); t1.start();

t2.start();

}

}

Output:

Thread[1st,5,main] Thread[2nd,5,main]

Thread[1st,5,main] Thread[2nd,5,main]

See the output 1st t1 starts running when yield method is called t1 goes to

wait state & t2 starts running. Then t2 goes to wait state because yield()

method is invoked within it & t1 again starts executing. But story is different

if you set the priorities.


public void run()

285

{

System.out.println(Thread.currentThread()); Thread.yield();

System.out.println(Thread.currentThread());

} }


X o=new X(); X p=new X();

Thread t1=new Thread(o,"1st"); Thread t2=new Thread(p,"2nd");

t1.setPriority(3); t2.setPriority(9);

t1.start();

t2.start(); }

}

Output:

Thread[2nd,9,main]

Thread[2nd,9,main] Thread[1st,3,main]

Thread[1st,3,main]

The sleeping process of thread

sleep() method is a starting method belongs to Thread class so it is invoked by its class name. it causes the thread to sleep for a particular time period

as given by the programmer in its parameter in which it is called. Its

signature is public static void sleep(long milliseconds) throws InterruptedException

public static void sleep(long milliseconds, int nanoseconds) throws InterruptedException

When a thread completes its sleeping it directly does not enter to execution state or running state rather it goes to ready state till it is called by thread

scheduler of JVM. The Thread class also contains a method called interrupt(). A sleeping thread upon receiving an interrupt call immediately moves to

ready state when it gets to run, it will execute its InterruptedException handler.

286


public void run()

{ try{

Thread.sleep(2000);

}catch(InterruptedException e) {

System.out.println("I am mhandling it"); }

System.out.println(Thread.currentThread()); }

} class Demo {


Thread t1=new Thread(o,"1st"); t1.start();

t1.interrupt(); }

} Output:

I am mhandling it Thread[1st,5,main]

Context switch between no. of threads by the use of sleep() method

Multiple numbers of threads can be created by creating multiple no of thread objects and allocating different task object to it. But, the issue is how to use

them such that they will keep switching among them self. The solution is the invocation of sleep() method. Let me give an example


public void run()

287

{

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

try{ Thread.sleep(500);


}

System.out.println(Thread.currentThread()+"Value="+i); }

} }

class ThreadDemo {

public static void main(String[] args){

X o=new X(); Thread t1=new Thread(o,"1st");

X p=new X(); Thread t2=new Thread(p,"2nd");


} }

Output:

Thread[1st,5,main]Value=1 Thread[2nd,5,main]Value=1

Thread[2nd,5,main]Value=2 Thread[1st,5,main]Value=2

Thread[2nd,5,main]Value=3

Thread[1st,5,main]Value=3 Thread[2nd,5,main]Value=4

Thread[1st,5,main]Value=4

Inside main method we have created two task

objects o &p. Two threads t1 & t2 is created & two tasks are allocated to

them. Inside the for loop of run method sleep(500) method is invoked. Since

it is a static method it is invoked by its class name. The argument inside the

sleep method makes the thread sleep for that much millisecond in which it is

invoked. 1st main thread starts execution, when t1.start() method is

invoked, t1 is ready for execution. When t1 gets it turn for execution inside

288

it sleep is called & JVM t pauses the thread t1 & control jumps back to main

thread. Now t2 is ready for execution. During the execution of t2 when sleep

method is encountered t2 again goes to sleep & control jumps back to main.

When t1 completed its sleep control jumps to t1. In this way control jumps

or switches between main thread , t1 & t2.

Use of join method

The signature of join method is final void join() throws InterruptedException.

This method waits until the thread upon which is called is terminated that

means calling thread waits until the specified thread joins it. Different forms

of join() method is available in the Thread class which can be used in

specifying the time period up to which you want a thread to wait for specific

thread. I must say that this method is useful in developing multi threading

programming approach. Let me give an clear picture through an example

class X implements Runnable {

public void run()

{ System.out.println("Inside X");

} }

class Thread1 {

public static void main(String []args) {

X job=new X(); Thread t=new Thread(job,"job");

t.start();

System.out.println("Inside main"); }

}

Output:

Inside main

Inside X In multi threading programming it may so happen that main thread exits

but the

289

created thread is still alive. You can invoke the sleep method in main thread

& forced the main thread to sleep for a particular time period you expect

that in that time period the thread you have created completes its task.

These things are just your expectations may happen may not happen. So

what we need a concrete method that will ensure that main thread is going

to wait till the create thread expires. join() method solves your problem. I

have illustrated the thing below through an example.

package demo; class X implements Runnable

{ public void run()

{ System.out.println("Inside X");

} }

class Thread1 {

public static void main(String []args)

{ X job=new X();

Thread t=new Thread(job,"job"); t.start();

try{ t.join();


}

System.out.println("Inside main"); }

}

Output:

Inside X

Inside main

Thread Synchronization

When multiple numbers of threads need to access a common resource, then

care must be taken by the programmer that only one thread can access the

shared resource at a particular instant of time. The technique through which

290

we achieve the mentioned goal is known as synchronization. Let me explain

some terms associated with synchronization technique.

Monitor(or you can say semaphore)

I will use the term semaphore instead of monitor as semaphore is quite a friendly term in OS. Semaphore is an object having mutual exclusive lock.

One thing often mutual exclusive lock is known as mutex. At a particular

instant of time one thread can be the owner of semaphore. When on thread owns the semaphore it is said that the thread has acquired the lock &

entered in to the monitor. All other thread out side the monitor or you can all threads except the owner of the semaphore wait until the owner of

semaphore releases its owner ship or you can say exit from monitor. If you have done a bit system level programming in C then synchronization is quite

familiar for you. But, one thing implementation synchronization in C involves system calls. It is not directly supported by C language. But java directly

support synchronization technique by the use of synchronize key word. Synchronized key word is used as block or method. In java all the objects

have implicit monitor or you can say semaphore associated with them. To own the semaphore, you just have to invoke a method using synchronize

key word. While a thread is inside a synchronized method or block, all other threads that try to call it (or any other synchronized method) on the same

instance have to wait. To release the control of shared object the thread has

to return from synchronize method or block.

Without use of synchronized block

package demo; class Y

{ int bal=100;

} class X implements Runnable

{

Y p; int r;

int sleepValue;

X(int a,int b, Y g) {

r=a; sleepValue=b;

p=g; }

291

public void run()

{ if(p.bal>r)

System.out.println("Fund is available");

try{ Thread.sleep(sleepValue);

}catch(InterruptedException e){} if(p.bal>r)

{ p.bal=p.bal-r;

System.out.println("Got it!!"+Thread.currentThread()); }

else{

System.out.println("Insufficient "+Thread.currentThread());

} }

} class Thread1

{ public static void main(String []args)

{ Y n=new Y();

X job1=new X(50,1000,n); X job2=new X(80,0,n);

Thread t1=new Thread(job1,"job1"); Thread t2=new Thread(job2,"job2");


} }

Output: Fund is available

Fund is available Got it!!Thread[job2,5,main]

Insufficient Thread[job1,5,main] Use of synchronized block

292

package demo;

class Y {

int bal=100; }

class X implements Runnable

{

Y p; int r;

int sleepValue; X(int a,int b, Y g)

{ r=a;

sleepValue=b;

p=g; }

public void run() {

if(p.bal>r) System.out.println("Fund is available");

synchronized(p){ try{

Thread.sleep(sleepValue); }catch(InterruptedException e){}

if(p.bal>r) {

p.bal=p.bal-r; System.out.println("Got it!!"+Thread.currentThread());

}

else{ System.out.println("Insufficient

"+Thread.currentThread()); }

} }

}

class Thread1 {

public static void main(String []args) {

Y n=new Y();

293

X job1=new X(50,1000,n);

X job2=new X(80,0,n);

Thread t1=new Thread(job1,"job1"); Thread t2=new Thread(job2,"job2");


} }

Output: Fund is available

Fund is available Got it!!Thread[job1,5,main]

Insufficient Thread[job2,5,main]

In the first case I have not used the synchronized block therefore job1

suffers although request to access the bal variable of Y is 1st made by it. But

by the use of synchronized key word in the second program job1 is not

suffered. I have always given priority to use synchronized block rather than

synchronized method because the prior one improves performance due to

atomic level synchronization.

Lifecycle of a thread

Life cycle of a thread includes

1:Ready

2:Running

3:Blocked state

4:Dead

When the start() method is called, the thread does not start running

immediately. It goes into a ready state and stays there until the task

scheduler or you may say thread scheduler select it for execution. When a thread starts execution, it to the running state. Then the run() method is

called. During its execution state, the thread may temporarily give up the CPU. This is because of various reasons it may goes to a sleep or it is waiting

for some event to be happened. This is known as blocked state. Finally when the thread completes its execution it goes to dead state. From the blocked

state thread goes to ready state when it wakes up or by the invocation of resume method.

294

Stop() method is called

sleep() or suspend() method is

Or task of the thread is completed

called

Start() method

Is called

resume() is called or

The thread wakes up after

Sleep.

When thread is dead

When the execution of codes in side run() method is completed, the thread

has finished its task and is considered as dead. Once a thread become dead it can not go to any other state. It cannot be started again; if you invoke the

start method then time exception is thrown by JVM.


public void run() {

System.out.println(Thread.currentThread()+"Hello X"); }

}

Running (Run

method is in

execution)

Ready

Blocked Dead

295

class Demo {


Thread t1=new Thread(o,"1st"); t1.start();

t1.start(); }

} Output

Exception in thread "main" java.lang.IllegalThreadStateException at java.lang.Thread.start(Unknown Source)

at demo.Demo.main(Demo.java:20) Thread[1st,5,main]Hello X

The dead thread is an object of Thread class & therefore it is possible to

access its data and call its methods. Always remember that

You can’t restart a dead thread. You can call the methods of a dead thread.

That‟s all about threading in java folks

296

Chapter-20

GENERICS

INTRODUCTION

Generics is a powerful feature of java. It is introduced by JDK 5. It is said to

be powerful because using it we can create classes , interfaces , and

methods that will work for various types of data in a type safe manner.

Using generics we can define a single algorithm which is independent of data

,then apply the same algorithm for various data types without any changes.

Why we need Generics?

We generally create classes , interfaces and methods which are type specific

but using generics it is possible create classes , interfaces and methods

which are type independent.

Previously we do this things using Object class, because Object class is the

super class of other classes, an Object reference can refer to any type of

object . to get the actuall data we have to explicitly type cast it to the

required type. Generics overcomes this overhead, in generics all type casts

are done implicitly. This makes the use of generics more secure.

A simple example

// Defination of the generic class Gener

class Gener<S>

{

S obj;

Gener(S o)

{

obj =o;

297

}

void showClass()

{

System.out.println("Type of S is "+ obj.getClass().getName());

}

void showData()

{

System.out.println("Data is "+obj);

}

}

public class GenericDemo

{


{

// Create a Gener reference for Integer

Gener<Integer> ob1 = new Gener<Integer>(100);

// prints the type of data hold by it

ob1.showClass();

298

// prints the data hold by it

ob1.showData();

// Create a Gener reference for Sting

Gener<String> ob2 = new Gener<String>("SAMITA ,

LORY");


ob2.showClass();


ob2.showData() ;

}

}

Output :

Type of S is java.lang.Integer

Data is 100

Type of S is java.lang.String

Data is SAMITA , LORY

In the above example S is the name of a type parameter. S holds the type

parameter of which the Gener class object is created. S is written inside

299

<>. Whenever we specify the type of class object we want to create we

specify it inside <>. And everywhere in the class definition S behaves like

the type specified for that object.


Here we created the object of Gener class, of Integer type. We also have

specify the type inside <> while calling the constructor. Here the S holds

Integer , so for ob1 S behaves as Integer. So we have passed the argument

according to the type.

Gener<String> ob2 = new Gener<String>("SAMITA , LORY");

Here we created the object of Gener class ,of String type. Here S holds

String , so for ob2 S behaves as String. So we have passed the argument

according to the type.

Generics works only on objects. That means the type argument passed

to type parameter must be a class type but it cannot be any primitive

type.

e.g

Gener<int> ob1 = new Gener<int>(100); // Error

The above example will result in an error because primitive type ( int ,

char,... etc) cannot be used .

One thing we have to understand is that a reference of one specific

type of generic type is different from another type of generic type.

e.g

ob1 = ob2 ; // wrong

the above is wrong because although ob1 and ob2 both are of type

Gener<T> but they are references of different types because of their

type parameters.

300

A Generic class with two type parameters

We can use more than one type parameter in a generic type. If we want

specify two or more type parameters , we just have to separate them with

commas. Let‟s consider the example below.


class Gener<A , B>{

A ob1;

B ob2;

Gener(A o1 ,B o2 )

{

ob1 =o1;

ob2 =o2;

}

void showClass()

{

System.out.println("Type of A is "+ ob1.getClass().getName());

System.out.println("Type of B is "+ ob2.getClass().getName());

}

void showData()

{

System.out.println("Data in ob1 "+ ob1);


301

}

}

public class GenericDemo {


// Create a Gener reference for Integer and String

Gener<Integer,String> obj1 = new

Gener<Integer,String>(100,"SAMITA , LORY");


obj1.showClass();


obj1.showData();

}

}

Output :

Type of A is java.lang.Integer

Type of B is java.lang.String

Data in ob1 100

Data in ob2 SAMITA , LORY

302

Here two type parameters T and V are separated by comma . so now if we

want to create a refrence of Gener we have to pass two type arguments.

Bounded Type Generic class

This is a feature of generics in which we can restrict the type argument

passed to the type parameter of genericlass to a particular type. Let,see the

example below.


class Gener<A extends Integer >{

A ob1;

Gener(A o1 )

{

ob1 =o1;

}

void showClass()

{


}

void showData()

{


}

303

}




Gener<Integer> obj1 = new Gener<Integer>(100);


obj1.showClass();


obj1.showData();

}

}

Output :

Type of A is java.lang.Integer

Data in ob1 100

The above will work well but not the below program. let‟s see .

304


class Gener<A extends Integer >{

A ob1;

Gener(A o1 )

{

ob1 =o1;

}

void showClass()

{


}

void showData()

{


}

}



305

// Create a Gener reference for String

Gener<String> obj2 = new Gener<String>("SAMITA ,

LORY");


obj2.showClass();


obj2.showData();

}

}

Output :

Exception in thread "main" java.lang.Error: Unresolved compilation

problems:

Bound mismatch: The type String is not a valid substitute for

the bounded parameter <A extends Integer> of the type Gener<A>

Bound mismatch: The type String is not a valid substitute for

the bounded parameter <A extends Integer> of the type Gener<A>

at GenericDemo.main(GenericDemo.java:27)

The above program will result in an error because we have bounded the type

of A to Integer so if we will try to give it any other type except the child

classes of Integer then it will result in an error.

We can also declare interfaces as bound for A .

Web can also declare one class and multiple interfaces as bound for A.

e.g

class Gener<A extends Myclass & Myinterface>

306

here Myclass is a class and Myinterface is a interface and & operator is

used to connect them.

Wildcard Arguments

Wildcard arguments are a special feature of generics . suppose we want to

define a method inside the generic class which compares the value of

different type of generic class object and returns the result irrespective of

their types. Previously it was not possible because a method defined inside

the generic class can only act upon the data types which is same as that of

the object calling it. But using wildcard arguments we can do this. To know

about the use of Wildcard arguments let‟s see the example below.


class Gener<T>{

T ob1;

Gener(T o1 )

{

ob1 =o1;

}

// wildcard argument is used

void Equalls(Gener<?> o2)

{

if(ob1 == o2.ob1)

307

System.out.println("TRUE");

else

System.out.println("False");

}

}




Gener<Integer> obj2 = new Gener<Integer>(100);

// Create a Gener reference for Double

Gener<Double> obj1 = new Gener<Double>(100.0);

// Create a Gener reference for String

Gener<String> obj3 = new Gener<String>("100");

obj2.Equalls(obj1);

obj2.Equalls(obj3);

obj1.Equalls(obj3);

}

}

Outpurt :

False

False

False

308

In the above program we have used the wild card argument , <?>

represents the wildcard argument i.e it will work irrespective of types. we

can see that the Equalls method checks the value of different objects

irrespective of their types and prints the result .

Wild cards can also be bounded. Suppose we want that in the above

example the Equalls method only execute for Numbers otherwise

results in an error. So we just have to change a little bit in the method

definition i.e

void Equalls(Gener<? extends Number> o2)

{

if(ob1 == o2.ob1)

System.out.println("TRUE");

else

System.out.println("False");

}

Now if we are going to execute the statements

obj2.Equalls(obj3);

obj1.Equalls(obj3);

it will result in an error because we can create a object reference of Genr

class for String type but we cannot use the Equalls method for the String

type.

Creating Generic Method and Generic Constructor

Now we will see how to define a generic method and generic class. A

generic method can be created inside a non-generic class which acts on

multiple types of data independently. We can also define a generic

constructor inside a non-generic class which can act on multiple types

independently. Let‟s see the below example.

309


double db;

// Generic constructor

<T extends Number> GenericDemo(T o1)

{

db= o1.doubleValue();

}

// Generic Method

static < V > void Display(V o2)

{

System.out.println(o2);

}

void show()

{

System.out.println(db);

}


GenericDemo g1 = new GenericDemo(100);

g1.show();

GenericDemo g2 = new GenericDemo(1025.54);

g2.show();

GenericDemo g3 = new GenericDemo(103.9F);

310

g3.show();

Display(100);

Display(125.56);

Display("SAMITA , LORY");

}

}

Output :

100.0

1025.54

103.9000015258789

100

125.56

SAMITA , LORY

From the above example we can observe the output. The Generic

constructor is taking the numbers of different type of argument as type

parameters and storing it‟s double value in the variable db of each

reference.like that the Display method is taking different type of arguments

as type parameters and displaying the value.

Erasure or Raw Types

A raw type is a parameterized type stripped of its parameters. The official

term given to the stripping of parameters is type erasure. Raw types are

necessary to support legacy code that uses non-generic versions of classes .

Because of type erasure, it is possible to assign a generic class reference to

a reference of its nongeneric (legacy) version. Therefore, the following code

compiles without error:

Gener ob1 ;

Gener<Integer> ob2 ;

ob1=ob2; // valid

311

ob2=ob1 ; // will cause a unchecked warning

Remember during compilation all types parameters are erased only raw

types actually exists.


class Gener<T>{

T obj;

Gener(T o)

{

obj =o;

}

void showClass()

{

System.out.println("Type of T is "+ obj.getClass().getName());

}

void showData()

{

System.out.println("Data is "+obj);

}

}



312


Gener ob1 = new Gener(100);

System.out.println("Type of ob1 is "+

ob1.getClass().getName());


ob1.showClass();


ob1.showData();

// Create a Gener reference for Sting

Gener<String> ob2 = new Gener<String>("SAMITA ,

LORY");

System.out.println("Type of ob2 is "+

ob2.getClass().getName());


ob2.showClass();


ob2.showData();

}

}

Output :

Type of ob1 is Gener

Type of T is java.lang.Integer

Data is 100

Type of ob2 is Gener

313

Type of T is java.lang.String

Data is SAMITA , LORY

From above example we can see that ob1 and ob2 are both of Gener class,

they are not of Integer class or String class. But according to the parameters

the variables inside ob1 and ob2 are type casted accordingly. When we

write the below code


int i = ob1.obj;

it is compiled as if it is written like this :

Gener ob1 = new Gener(100);

int i = (Integer)ob1.obj;

Some Restrictions While Using Generics

Type parameters cannot be instanciated :

class Gener<T>{

T obj;

Gener(T o)

{

obj =newT(); // error

}

}

The above code will result in an error because T doesn,t exist at runtime so

how compiler will know what type of object to create.

Restrictions on Static Members :

Below are some facts we should care of while using static keyword.

314

class Gener<T>{

// error , cannot make a static reference to a nonstatic type static T obj ;

// error, no static method can use T

Static T show() {

// error , no static method can acces T type object System.out.println(obj);

} }

Java Generics vs. C++ Templates

While generics look like the C++ templates, it is important to note that they

are not the same. Generics simply provide compile-time type safety and

eliminate the need for casts. The main difference is encapsulation: errors are

flagged where they occur and not later at some use site, and source code is

not exposed to clients. Generics use a technique known as type erasure as

described above, and the compiler keeps track of the generics internally, and

all instances use the same class file at compile/run time.

A C++ template on the other hand is just a fancy macro processor;

whenever a template class is instantiated with a new class, the entire code

for the class is reproduced and recompiled for the new class.

315

Chapter-21

Files and Streams

Files are located in the secondary storage of the system. When it

is opened for any purpose first it is loaded in to the primary memory, then the

operation is performed. After any write operation the changes are reflected

according to the implementation of either write through or write back protocol.

Files are normally of two types; binary file & text file. Java provides two ways to

handle files. One through various streams provided in java.io package & other

through File class which does not required streams to operate.

The File class

By the use of File class you can directly deal with the files, directory & file system of

the platform. Actually java does not provide crystal clear view of how the things

are done in background when the programmer uses the File class. Programmer has

to create the file object through the constructors provided by File class. Then, using

those objects programmer can perform manipulation with the files & directory. File

class constructors are used for the creation of the object of the File class. These

constructors are overloaded. Various forms of these constructors are given below.

File f1 = new File (“c: / Minerva / ravenX”);

Here I have shown how to open the existing file in window platform.

File f2 = new File (“c: / Minerva “, “rian” );

Here 1st parameter is the absolute path & the second parameter is the file that has

to be opened.

File f3 = new File (“java”, “temp”);

Here the first parameter is a directory name in which the existing file temp has to

be opened.

One question may arise in the minds of novice programmer is that why files are

required & the answer is files are required to have a persistent storing of data.

Sometimes it is required to read the data from files rather than standard input

device like keyboard. Another thing I want to say is that in java, directories are also

treated as files. If you are dealing with directory, then you have to use the list ()

method provided by java to list out all the files residing in the directory.

316

Java is quite smart when it comes to deal with path separator. In windows you can

use both /. If you are quite loyal to Microsoft & want to use \ then, you have to use

the escape sequence \\. In UNIX & Linux you can use /.

Methods of the File Class

By the help of the predefined methods of File class programmer can retrieve the

properties of a file.

String getName( ) Method

This method returns the name of the file through which this method is invoked

String getPath( ) / String getAbsolutePath ( ) method

These two methods are used to get to get the absolute path of the file through

which it is invoked.

String getParent ( ) method

This method returns the name of the parent directory of the file through which it is

invoked.

boolean exists ( ) method

this methods checks whether the file exists or not through which it is invoked.

boolean isFile ( ) / boolean isDirectory ( ) method

these two methods are used to determine whether the file object through which it is

invoked is a directory or file.

import java.io.File;

//you need to import this package to have various methods to deal with file

object.

class Demo

{


{

317

File myfile=new File(“/dir1/pex”);

System.out.println(“Name: ”+myfile.getName());

System.out.println(“Path: ”+myfile.getPath());

System.out.println(“My absolute path: ”+myfile.getAbsolutePath());

System.out.println(“My parent : ”+myfile.getParent());

System.out.println(“Name: ”+myfile.getName());

if(myfile.exists())

System.out.println(“file do exists!!!”);

else

System.out.println(“File does not exists”);

if(myfile.canRead())

System.out.println(“file is readable ”);

else

System.out.println(“file is not readable”);

if(myfile.canWrite())

System.out.println(“file is writeable ”);

else

System.out.println(“file is not writeable”);

if(myfile.isFile())

System.out.println(“It is a normal file”);

else

System.out.println(“It is not a normal file might be system file like

device driver.”);

System.out.println(“File was last modified”+myfile.lastModified());

318

System.out.println(“size of the file is in bytes”+myfile.length());

}

}

boolean canRead ( ) / boolean canWrite ( ) methods

These methods are used to check if we can read from the specified file or write into

the specified file respectively. These methods return a boolean value depending on

their readability/ writability.

Use of long lastModified( ), canWrite() & canRead() methods

This method returns the modification time the file.

Example 3

import java.io.*;

public class File2

{


{

File f1 = new File ("c:/java","abc.txt");

if(f1.canRead())

System.out.println ("we can read from this file") ;

else

System.out.println ("we cannot read from this file" ) ;

if(f1.canWrite())

System.out.println("we can write to this file");

else

System.out.println("we cannot write to this file");

319

System.out.println("The file was last modified

at"+f1.lastModified()+"seconds after January 1 1980");

}

}

The file I have used has both read & write option. Therefore that is the output. But,

the interesting one is the output of lastModified() method. It shows the time period

in millisecond after which the file is modified with respect to 1st January

How to rename a file:

renameTo() method is used to rename an existing file.

Example 4

class Demo {


{

File myFile=new File (“/dir1/pex”);

boolean b1=myFile.renameTo(“Minarva”);

if(b1)

System.out.println(“Rename operation is success full”);

else

System.out.println(“File cannot be renamed”);

}

}

renameTo() method returns boolean true value upon if rename is done successfully

otherwise false is returned.

320

Deleting an existing file

Example 5

class Demo{


{

File myFile=new File(“/dir1/pex”);

boolean b1=myFile.delete();

if(b1)

System.out.println(“file is deleted”);

else

System.out.println(“File cannot be deleted ”);

}

}

delete() method returns true if file is deleted successfully else it will return false.

There is another method dleteOnExit() deletes the file when you complete the

operation exit from the execution phase of the program.

File class also provides some other useful methods like: public long length( )

This method is used to know the file size in bytes.

Let‟s have another example to fix ideas concretely.

Example 6

import java.io.*;

public class File3

321

{


{

File f=null;

for(int i=0;i<args.length;i++)

{

f=new File("c:/java",args[i]);

}

File f1=new File("c:/java/renfile");

if(f.exists())

{

System.out.println(f+" exists");

System.out.println("its size is "+f.length()+" bytes");

f.renameTo(f1);

System.out.println("Renamed file name :"+f1);

System.out.println("deleting the file "+f);

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

f.delete();

}else{

System.out.println(f+" does not exist");

}

}

}

322

Space available in a specified partition

J2SE 6 provides three methods to get various attributes associated with the

particular partition where the file resides. See the example blow

Example 7

class Demo{


{


if(myFile.exist()==false)

{

System.out.println(“The specified file does not exist”);

return ;

}

long x=myFile.getfreeSpace();

x=x/1000;

System.out.println(“Amount of space available in MB: ”+x);

x=myFile.getTotalSpace();

x=x/1000;

System.out.println(“total space in MB: ”+x);

323

}

}

Output, easily you can guess. Methods like getFreeSpace() & getTotalspace() when

invoked on the specific file, then it checks the free space available & total space

available respectively in terms of bytes. I have divided the returned value of these

two methods by 1000 to get the things in MBs.

How to make a file read only

Example 8

class Demo{


{


if(myFile.exist()==false)

{

System.out.println(“file doe snot exist”);

return;

}

boolean b1=myFile.setReadOnly();

if(b1)

System.out.println(“Operation is success full”);

else

System.out.println(“Operation failed”);

}

}

setReadOnly() method is used to make a file readonly.

324

Dealing with directories

A directory is a collection of files and directories. In java directories are also treated

as files. If you wish to deal with the directories then you can use the list() method. When list() method is invoked by the directory object(created through File class

constructor) then list of other files and directories extracted from it. This method is over loaded. One of them is String [ ] list( ). Let‟s have program!

Example 9

import java.io.File;

class DirectoryList {


{ String directory_name = "/Minerva";

File myFile = new File(directory_name);

if (myFile.isDirectory()==true)

{

System.out.println ("Directory of” + directory_name); String s1[] = myFile.list ();

for (int i=0; i < s1.length; i++)

{

File f1 = new File(directory_name + "/" + s1[i]);

if (f1.isDirectory()) {

System.out.println(s1[i] + " is a directory");

}

else

325

{

LIBRARY System.out.println(s1[i] + " is simply a file!!");

}

}

} else

{

System.out.println(directory_name + " is not a directory");

}

} }

Output is straight forward. Method names clearly indicate what are their task. boolean mkdir ( ) Method

This method is used to create a directory and returns a boolean indicating the

success of the creation. The following example the usage of this method.

Example 10

import java.io.*;

public class File5

{

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

{

File myFile=new File("c:/Alice/wondeLand");

if(myFile.mkdir()==true)

System.out.println("created a directory");

else

System.out.println ("Unable to create a directory");

326

}

}

If the mkdir() method is executed successfully the boolean true value is returned

else the method is going to return false.

The other over loaded form of public String[ ] list(FienameFilter FilterObj)

method

In this form of list() method, it is used to filter out the required files from a

directory. Actually often we feel that a particular set of files has to be opened or list

out instead of all the files present in the directory.

Example-11

import java.io.*;

public class File4 implements FilenameFilter

{

String w;

public File4(String w)

{

this.w="."+w;

}

public boolean accept(File dir,String name)

{

return name.endsWith(w);

}


327

{

for (int p=0;p<args.length;p++)

{

File f1 = new File("e:/cobra/applet");

FilenameFilter only=new File4(args[p]);

String s[]=f1.list(only) ;

System.out.println ("printing files with "+args[p]+" extesion in the

"+f1.getPath()+" directory") ;

for(int i=0;i<s.length;i++)

System.out.println(s[i]);

}

}

}

In this program when I have invoked the overloaded list() method, this method

implicitly invoke the accept() method. In side accept() method endsWith() method

is invoked. Entire operation performs only one thing i.e. filter out the required files.

Use of Streams

What is a stream?

Stream means a channel or pipe. Like water flow in a pipe, data flows from source

to destination through the channels in java.

Diagram 1

328

329

These channels are the object of various stream classes provided by Java. Java

provides two types of streams input stream & output stream. By the use of input

streams we receive the data from source & by the use of output streams we write

the data at the desired destination. Java provides two ways to perform read & write

operations. Reader class objects reads and Writer class writes the data in the form

of characters. Stream class objects read & write in the form of bytes. Classes those

end with the term “reader” deals with characters & classes those end with the term

“stream” deals with bytes.

Let‟s have a hierarchy structure of stream class.

330

With the help of the table you see various InputStream and their functions.

By the help of these InputStream system directly read the data from file and buffer

in byte format.

Class Function Supported methods

ByteArrayInputStream Allows a buffer in

memory to be used as

an Input Streams

available( ), mark( ),

mark Supported( ), read(

), insert( ), skip( )

FileInputStream For reading information

from a file.

available( ),

close(),finalize(), read( ),

skip()

FilterInputStream Abstract class providing

an interface for useful

functionality to the

other Input Stream

classes.

available ( ), close( ),

mark( ), markSupported(

), read( ), reset( ), skip( )

331

With the help of this table you see various OutputStream and its methods through

which data is written in targeted output sources like file and buffer in byte format.

Class Function Supported methods

ByteArrayOutputStream Creates a buffer in

memory

All the data we send to

the streams is placed in

this buffer.

reset( ), size( ),

toByteArray( ),

toString( ), write( ),

writeTo( )

FileOutputStream Abstract class providing

an interface for useful

functionality to the

other Output Streams

classes

close( ), flush( ),

write( )

Low-Level Stream

Low-level input streams have methods that read input and return the input

as bytes. Whereas Low-level output streams have methods that are passed

bytes and write the bytes as output.

FileInputStream

FileInputStream is a class that helps to read the data from a file. When the

programmer wants to read the data from the file by using FileInputStream and file

is not present then program is terminated at the runtime by throwing

FileNotFoundException. There are two types of constructors available with this

class.

The first constructer takes the name of the file as a String argument

FileInputStream f = new FileInputStream( “c:/java/temp.exe” );

332

The second constructor takes the File class object as an argument

File f = new File ( “c:/java/temp.exe”);

FileInputStream f1=new FileInputStream(f);

FileOutputStream

The FileOutputStream class helps to create a new file and write data into in byte

format. The two types of constructors are applicable to this class.

The first constructer takes the filename as a string argument

FileOutputStream f = new FileOutputStream( “c:/java/temp.exe” );

The second constructor takes File class object as an argument

File f = new File ( “c:/java/temp.exe”);

FileOutputStream f1=new FileOutputStream(f);

In case of FileOutputStream if the programmer writes the data into a read-only file

then the program generates IOException.

Example -12

import java.io.*;

public class ReadWriteFile

{

public static byte get( )[] throws Exception

{

333

byte in[]=new byte[50];

System.out.println("enter the text.");

System.out.println("only 50 bytes of data is stored in the array ");

System.out.println ("press enter after each line to get input into the

program");

for (int i=0;i<50;i++)

{

in[i]=(byte)System.in.read( );

}

return in;

}


{

byte input []=get( ) ;

FileOutputStream f=new FileOutputStream("c:/java/write.txt");


{

f.write(input[i]);

}

f.close ( ) ;

int size;

FileInputStream fl=new FileInputStream("c:/java/write.txt");

size=fl.available ( ) ;

System.out.println("reading contants of file write. Text");

for(int i=0;i<size;i++)

{

334

System.out.print((char)fl.read ( )) ;

}

f.close( ) ;

}

}

ByteArrayInputStream

This class uses a byte array as its input source. It has two types of constructors.

The first one takes a byte array as its parameter.

ByteArrayInputStream b = new ByteArrayInputStream(byte buf[])

through this constructor programmer takes the input from the specified array of

bytes.

ByteArrayInputStream b=new ByteArrayInputStream (byte buf [], int off,

int len)

In this constructor Off is the offset of the first byte to be read and len is the number

of bytes to be read into the array.

ByteArrayOutputStream

ByteArrayOutputStream class implements a buffer, which can be used as an OutputStream. The size of the buffer increases as data is written into the stream.

335

The data is retrieved using the methods toByteArray() and toString(). Two types of constructors exist. They are given below:

ByteArrayOutputStream o = new ByteArrayOutputStream ()

This creates a buffer of 32 bytes to stroke the data.

ByteArrayOutputStream o=new ByteArrayOutputStream (int size)

The above constructor creates a buffer of size int. These methods return void and

throw an IOException on error conditions.

Example-13

import java.io.*;

public class ByteArray

{


{

ByteArrayOutputStream f=new ByteArrayOutputStream(12);

System.out.println("enter 10 characters and press the enter key");

System.out.println("These will be converted to uppercase and

displayed");

while(f.size( )!=10)

{

f.write(System.in.read( ));

}

System.out.println("Accepted characters in the array");

byte b[]=f.toByteArray( );

System.out.println("displaying characters in the array");

for(int i=0; i<b.length;i++)

{

336

System.out.println((char)b[i]);

}

ByteArrayInputStream inp=new ByteArrayInputStream (b);

int c;

System.out.println("Converted to upper case characters");


{

while ((c =inp.read( )) != -1)

{

System.out.print(Character.toUpperCase ((char)c));

}


inp.reset();

}

}

}

337

SequenceInputStream

SequenceInputStream is the child class of InputStream. This class is used to

sequentially read the data from two input sources.

Constructor:-

SequenceInputStream (new InputStream, new InputStream) ;

Methods available:-

public int read()throws IOException

public int read(byte b[],int buffer, int size)throws IOException

public void close()throws IOException

public int available()throws IOException

final void nextStream()throws IOException

Example:-14

import java.io.*;

public class Sequence

{


{

try{

FileInputStream fis1=new FileInputStream("c:/a.txt");

FileInputStream fis2=new FileInputStream("c:/b.txt");

SequenceInputStream s =newSequenceInputStream(fis1,fis2);

int ch;

while((ch=s.read())!=-1)

{

338

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

}

fis1.close();

fis2.close();

s.close();

}catch(FileNotFoundException fe)

{

fe.printStackTrace();

}

catch(IOException ie)

{

ie.printStackTrace();

}

}

}

Output:-

339

FilterInputStream class having the child classes named as :-BufferedInputStream,

DataInputStream, PushbackInputStream.

FilteredOutputStream class having the child classes named as:-

BufferedOutputStream, DataOutputStream, PrintStream .

Class Function Supported Methods

DataInputStream Used in context with

DataouputStream. Hence

we can read

read(), readBoolean(),

readByte( ), readFloat (

),

Primitives (int, char, long,

etc.) from a stream in a

portable fashion.

readFully ( ), readInt(

),

readLine ( ), readLong (

),

readShort( ), skipBytes(

)

BufferedInputStream Use this to prevent a

physial read every time

more data is needed


markSupported( ), read(

), reset( ), skip( ),

PushbackInputStream Has a one-byte pushback

buffer, so the last

character read can be

pushed back.


reset( ), read( ), unread(

), markSupported( )

Class Function Supported Methods

DataOutputStream Used in context with

DataInputStream.

Hence we can write

primitives (int, char,

long, etc.) to a stream

flush( ), size( ), write( ),

writeBoolean(boolean

b), writeDouble(double

d), writeFloat(float f ),

writeInt(int i ),

writeLong( long l),

340

in portable fashion. writeShort( short s)

PrintStream For producing formatted

output. While

DataOutputStram

handles the storage of

data, PrintStream

handles display.

checkError( ), close( ),

flush( ), print( ), println

( ), setError( ), write( ),

BufferedOutputSteam This is used to prevent a

physical write every

time we send a piece of

data. flush( ) can be

called to flush the buffer

flush( ), write( )

High Level Stream Classes

High-level input streams takes their input from other input streams where as High-

level output streams direct their output to other output streams. High-level input

streams are BufferedInputStream, DataInputStream and ObjectInputStream etc.

High-level output streams are BufferedOutputStream,

DataOutputStream, ObjectOutputStream, PrintStream etc.

BufferedInputStream

The BufferedInputStream class accepts input by using a buffered array of bytes that

acts as cache and it utilizes the mark ( ) and reset ( ) method. Chunks of bytes

from the buffered array can be chosen and read. The BufferedInputStream class

maintains an internal array of characters in which it buffers the data it reads from

its source. The default size of the buffer is 2048 bytes. A BufferedInputStream is

beneficial in certain situation where reading a large number of consecutive bytes

from a data source is not significantly more costly than reading a single byte. This

class Constructor is overloaded.

BufferedInputStream bis = new BufferedInputStream (InputStream is);

Creates a buffered input stream with a 2048 byte buffer.

BufferedInputStream bis=new BufferedInputStream(InputStream is,int bufsize);

341

Creates a buffered input stream with an internal buffer of bufsize bytes. If

the bufsize is less than 0 then it throw IllegalArgumentException.

BufferedOutputStream

The output is stored in a buffered array of bytes, which acts as a cache for writing.

Data written in the buffered output stream will continue until unless the buffer is

full. This class Constructor is overloaded.

BufferedOutputStream b= new BufferedOutputStream (OutputStream os);

Creates a buffered output stream with a default 512 byte buffer.

BufferedOutputStream b=new BufferedOutputStream(OutputStream os, int

bufsize);

Creates a buffered output stream with a buffer of bufsize bytes. If the bufsize

is less than 0 then the program is terminated by throwing

IllegalArgumentException.

DataInputStream

The DataInputStream class reads bytes from another stream and translate them

into java primitives, char array and String by the help of some predefined methods.

byte readByte()throws IOException

boolean readBoolean()throws IOException

short readShort()throws IOException

char readChar()throws IOException

int readInt ( ) throws roException

float readFloat()throws IOException

long readLong()throws IOException

double readDouble()throws IOException

String readLine ( ) throws IOException

Constructor Is

DataInputStream dis=new DataInputStream(InputStream is);

342

DataOutputStream

DataOutputStream class supports the writing of java‟s primitive data types to an

output sources. A set of methods exists in this class to write the data to the output

source in any primitive data types format.

void writeByte(byte b)throws IOException

void writeBoolean(boolean b)throws IOException

void writeShort(short s)throws IOException

void writeChar(char c)throws IOException

void writeInt (int i) throws roException

void writeFloat(float f)throws IOException

void writeLong(long l)throws IOException

void writeDouble(double d)throws IOException

Constructor is

DataOutputStream dos=new DataOutputStream(OutputStream

os)

In order to create a simple text file I am going to use FileOutputStream. See the

example

Example 15

import java.io.*;

class Demo{

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

{

DataInputsteream din=new DataInputsteream (System.in);

FileOutputStream fout=new FileOutputStream(“myFile.txt”);

343

System.out.println(“Press # to save & quit the file”);

char ch;

while((ch=(char)din.read())!=‟#‟)

fout.write(ch);

fout.close();

}

}

System.in represents the standard input device i.e. is key board. din is an object of

DataInputStream class. This is what we call a channel or stream. Now din is

connected to keyboard. Next fout is an object of FileOutputStream class. It also

behaves like a channel. It is connected to the output file myFile.txt. Inside while

loop read() method is invoked through the object din. read() method reads the data

from keyboard through the channel named din & the returned character value is

saved in the character variable ch. Next the write() method is invoked & the stored

value in ch is moved to myfile.txt through the out put channel object fout. All these

operation continues till # is pressed by the user. Then finally close() method is

invoked to close the operation & save the file.

How to append a file.

If I am again use the file myFile.txt to write something more at the end then the

previous data will be lost. So I have to make some change in the above program to

append a file.

Example 16

import java.io.*;

class Demo{


{

DataInputsteream dIn=new DataInputsteream(System.in);

FileOutputStream fout=new FileOutputStream(“myFile.txt”,true);

System.out println(“Press # to save & quit the file”);

344

char ch;

while((ch=(char)din.read())!=#)

fout.write(ch);

fout.close();

}

}

See the extra parameter passed in the constructor of FileOutputStream. This

boolean true value opens the file in the append mode.

Use of BufferedOutputStream:

To improve the performance we have to use the buffered output stream. But, the

question how the performance is going to be improved? In the above program each

time when a character is read from keyboard, is written to the file & each time in

the back ground appropriate system call is made to do the operation. This involves

a lot of over head. What else we can do? We can create a buffer i.e. a temporary

storage area & store the data till the input operation is completed, and then write

the entire content of the buffer in to the file at once.

Example 17

import java.io.*;

class Demo{


{

DataInputsteream dIn=new DataInputsteream(System.in);

FileOutputStream fout=new FileOutputStream(“myFile.txt”);

BufferedOutputStream br= new BufferedOutputStream(fout);

System.out println(“Press # to save & quit the file”);

char ch;

while((ch=(char)din.read())!=#)

345

bout.write(ch);

bout.close();

}

}

br is an object of BufferedOutputStream. It is buffer or a chunk of memory

attached with fout. Now the read method is invoked through the br, so the

characters entered from keyboard is store in the temporary buffer br until the

buffer is filled or # is pressed. If the buffer is full & user still entering the data, then

IOException will be generated. Once input operation is completed then write()

method is invoked by bout to write the entire data in to the file at once. Yes, one

thing if the programmer does not mention the size of the buffer explicitly then the

default size id 512 bytes.

Steps to be remembered:

1:Create an input stream object & connect it to keyboard by DataInputsteream

dIn=new DataInputsteream(System.in);

2: create an output stream object & connect it to the file where you are going to

write some thing by FileOutputStream fout=new FileOutputStream(“myFile.txt”);

3: create a buffer & attach it to output stream object by

BufferedOutputStream br= new BufferedOutputStream(fout)

4: read from key board by the din.read() method;

5:write to the file by bout.write() method.

Reading a file

Data stored in a file can be read by the use of FileInputStream object.

Example 18

import java.io.*;

class Demo{


{

346

FileInputStream fin=new FileInputStream(“myFile.txt”);

int ch;

while((ch=(char)fin.read())!=-1)


fin.close();

}

}

Java detects the end of file when it encounters -1. At the end of every file to

indicate the end of file OS stores -1. fin is an object of FileInputStream. It is simply

an input channel connected to myFile.txt. When read method() is invoked by fin,

data is read from the file through the channel fin, stored it in ch & then displayed

on the monitor. This process continues till -1 is encountered.

Coping the content of one file to another.

Example 19

import java.io.*;

class Demo{


{

FileInputsteream dIn=new FileInputsteream(“myFile1.txt”);

FileOutputStream fout=new FileOutputStream(“myFile2.txt”);

int ch;

while((ch=fin.read())!=-1)

fout.write((char)ch);

fout.close();

}

}

347

Codes are straight forward through fin data is read from myFile1.txt 7 through fout

data is written in to myFile2.txt.

Use of BufferedReader to improve performance

Example-20

import java.io.*;

class Demo{


{

try{

FileInputStream fin=new FileInputStream(“myFile.txt”);

}catch(FileNotFoundException e){

System.out.println(“file does not exists.”)

return;

}

BufferedReader br=new BufferedReader(fin);

int ch;

while((ch=br.read())!=-1)


fin.close ();

}

}

Here in this program I have used the BufferedReader to improve the

performance.

348

Example-21

import java.io.*;

public class DataStream

{


{

BufferedReader d=new BufferedReader(new InputStreamReader(new

FileInputStream("c:/temp.txt")));

DataOutputStream o=new DataOutputStream (new

FileOutputStream("C:/temp1.txt"));

String line;

while ((line = d.readLine())!=null)

{

String a =(line.toUpperCase ( ));

System.out.println(a);

o.writeBytes(a+"\r\n");

}

d.close();

o.close();

}

}

Suppose the “temp.txt” file contains the line “Learn java as it is an object oriented

language” as its content. The output appears as shown below:

349

PushbackInputStream

This class is used to read a character from the InputStream and return the same.

This is done without disturbing the InputStream. This class allows the most recently

read byte to be put back into the stream, as if it had not yet been read.

Constructor:-

PushbackInputStream(InputStream is)

PushbackInputStream(InputStream is,int size)

PrintStream

This class is used to write text or primitive data types. Primitives are converted to

character representation. This methods of this class are widely used in Java

applications. The two methods that are very familiar to us system.out.println( ) and

system.out.print ( ).

Constructor:-

PrintStream(String s)

PrintStream(OutputStream os)

PrintStream(OutputStream os,boolean b)

Serializalization

Serialization is the process of writing the state of an object to a byte stream.

Serialization is a technique that is required when the programmer want to save the

state of the object in a persistent storage area. Later on programmer restore the

objects by using the process deserialization. In other wors serialization is a

technique of storing object contents into a file.Serializable interface is an empty or

marker interface without any members in it. Marking interface is useful to mark the

object of a class for special purposes. Static and transient variables are not

serialized. Deserialization is the process of reading back the object from the file. By

the help of the ObjectInputStram programmer read the object from a stream.

350

Constructor is

ObjectInputStream(InputStream in) throws IOException

Through the object in the serialized objects should be read.

Methods Description

int available() Returns the number of bytes that are

available in the input sources.

void close() Closes the invoking String.

int read() Return the integer representation of

the next available byte of input.

Object readObject() Returns the Object from the invoking

Stream.

long skip(long n) Skip n number of bytes from the

input sources.

ObjectOutputStream class is used to write objects to a stream.

Constructor is

ObjectOutputStream(OutputStream out)throws IOException

Through the out object the serializable objects are written in the Output sources.

351

Method Description

void close() Closes the invoking stream.

void flush() Finalizes the output sources.

void write(byte b[]) Writes an array of bytes to the

invoking Stream

void writeObject(Object obj) Writes Object obj to the invoking

stream.

Example-22

import java.io.*;

class Ex1 implements Serializable

{

int i,j;

transient int k;

void show(int i,int j,int k)

{

this.i=i;

this.j=j;

this.k=k;

}

}

public class Serial

{


352

{

try{

Ex1 e1=new Ex1();

e1.show(20,30,40);

FileOutputStream fos=

new FileOutputStream("c:/s1.txt");

ObjectOutputStream oos=

new ObjectOutputStream(fos);

oos.writeObject(e1);

FileInputStream fis=new FileInputStream("c:/s1.txt") ;

ObjectInputStream ois=new ObjectInputStream(fis) ;

Ex1 e2=(Ex1)ois.readObject();

System.out.println("Data Is "+e2.i+"\t"+e2.j+"\t"+e2.k);

}catch(Exception e)

{

e.printStackTrace();

}

}

}

Output:-

353

StreamTokenizer

Java provides in built method for pattern matching from the data those

extracted from input stream. The pattern matching is done by breaking the

Inputstream in to tokens which are later delimited by a set of characters.

Example-23

import java.io.*;

public class wordcounter

{

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

{

FileReader fr=new FileReader("c:/temp.txt");

StreamTokenizer input=new StreamTokenizer(fr);

int tok;

int count=0;

while((tok=input.nextToken())!=input.TT_EOF)

{

if(tok==input.TT_WORD)

System.out.println("word found :" +input.sval);

count++;

}

System.out.println ("found "+count + " words in temp.txt");

}

}

354

StringTokenizr define four integer fields named TT_EOF, TT_EOL, TT_NUMBER &

TT_WORD. There exists another variable ttype, the token recognizing variable. Ttype is equal to TT_WORD if nextToken() method recognizes the element as word. If the element is a nuber then ttype is equal to TT_NUMBER. If the token is a

simple character then ttype contains the value of that character. If the element is end of line then ttype is equal to TT_EOL. Similarly when end of file is reached

ttype is equal to TT_EOF. Reader and Writer Classes

The difference between readers and input stream is that while readers are able to

read characters. Input streams read bytes. This increases the power of the java iosteream classes by being able to read any character and thus enabling internalization. To say it in simple terms, it is possible to write Java programs in

languages like German, French, Japanese, etc.

The functionality of the writers is writers is similar to the output streams and it is possible to write one block of bytes or characters.

Following section deals with a few subclasses of reader and writer classes. Reader Class

Some of the subclasses of reader class are:

355

FileReader

The FileReaer class enables reading character files. It uses default character

encoding. FileReader class usage is similar to FileInputStream class and its constructors are identical to those of FileInputStream class. The constructors are identical to those of FileInputStream class. The constructor is given below;

public FileReader(File f)

This constructor can throw a FileNotFoundException.

CharArrayReader

The CharArrayReader Allows the usage of a character array as an InputStream. The usage of CharArrayReader class is similar to ByteArrayInputStream. The constructor is below:

CharArrayReader(char c[])

CharArrayReader(char c[], int start, int num) InputStreamReader

The InputStreamReader class reads bytes from an input stream and converts them

to characters according to a mapping algorithm. The default mapping identifies bytes as common ASCII characters and converts them to Java‟s Unicode characters. The constructor is given below:

public InputStreamReader (InputStream istream)

FilterReader

Reader

BufferedReader CharArrayReader FilterReader InputStreamReader

PipedReader FileReader StringReader

PushbackReader LineNumberReader

356

The FilterReader class allows the reading of filtered character streams. There is one

instance variable in, which is a protected reference to the reader that is being filtered.

Protected FilterReader (Reader r)

BufferedReader

BufferedReader class accepts a Reader object as its parameter and adds a buffer of characters to it. This class is mainly useful because of its readLine ( ) method.

public BufferedReader(Reader r)

Writer Class A few of the subclasses of the Writer class are:

Reader work exclusively with 16-bit chars, designed for Unicode:

FileWriter

The FileWriter allows wrting character files. It uses the default character encoding

and buffer size. The usage of FileWriter class is similar to that of FileOutputStream class. The constructor is given below and it can throw an IOExeception.

public FileWriter (File f)

Example-24

import java.io.*; public class FileRead

{ public static void main(String ars[])

Writer

BufferedWriter CharArrayWriter FilterWriter OutputStreamWriter

PipedWriter FileWriter StringWriter PrintWriter

357

{ try{

BufferedReader br=new BufferedReader( new InputStreamReader(System.in));

System.out.println("Enter The Text"); String s=br.readLine(); char c[]=s.toCharArray();

FileWriter fw=new FileWriter("File1.txt");

fw.write(c); fw.close();

System.out.println("Read The Data From The File"); FileReader fr=new FileReader("File1.txt");

int ch; while((ch=fr.read())!=-1) {

System.out.print((char)ch); }

fr.close(); }catch(Exception e)

{ e.printStackTrace(); }

} }

Output:-

CharArrayWriter

This class uses character array as the OutputSource. The constructor of the class is

overloaded. CharArrayWriter() CharArrayWriter(int num)

PrintWriter

358

The PrintWriter class contains methods that makes the generation of formatted output simple. It can be used instead of PrintStream. The constructor is:

public PrintWriter ( OutputStream ostream )

The stream is not flushed each time the printIn( ) method is called.

FilterWriter

The FilterWriter class is used to Write filtered character streams. It has one instance variable out, which is a protected reference to the Writer that is being filtered.

protected Filter(Writer w)

BufferedWriter

The BufferedWriter class buffers data to the character output stream. BufferedWriter class functionality is the same as BufferedOutputStream class The

constructor is:

public Buffered (Writer w)

Example-25

import java.io.*; public class ReadWrite

{ public static void main (String arge [])

{ try { BufferedReader in=new BufferedReader(new FileReader(arge[0]));

String s1=""; String s2="Learn Java";

while((s1=in.readLine())!=null) System.out.println(s1); StringReader in2=new StringReader(s2);

int c; System.out.println("printing individual1 charcters of the

File"+arge[0]); while((c=in2.read())!=-1) System.out.print((char)c);

BufferedReader ind=new BufferedReader(new StringReader(s2)); PrintWriter p=new PrintWriter(new BufferedWriter(new

FileWriter("demo.txt"))); while((s1=ind.readLine())!=null)

359

p.println("output "+s1); in.close();

in2.close(); ind.close();

p.close(); }catch(Exception e) {

e.printStackTrace(); }

} }

Use of FileReader & FileWriter class.

FileReader & FileWriter class is performs the read & write operation by characters.

Program to write something in to a file.

Example-26

import java.io.*;

class Demo{


{

String data=”On this planet\n Life is like ships in the harbor!!! ”

360

FileWriter fw1=new FileWriter(“myFile.txt”);

for(int i=0;i<data.length();i++)

fw1.write(data.charAt(i));

fw1.close();

}

}

Reading from a file by FileReader

Example-27

import java.io.*;

class Demo{


{

try{

FileReader fr1=new Filereader(“myFile.txt”);

}catch(FileNotFoundexception e)

{

System.out.println(“file does not exist”);

return;

}

int ch;

while((ch=fr1.read())!=-1)

System.out.println((char)ch);

fr1.close();

}}

-

361

Chapter-22 Exploring The java.lang Package

java.lang is the fundamental package that is available to the programmer by default. You do not import this package to use the classes, interfaces & methods available in this package. In fact this is the package that is widely used all java

programmer.

Various classes present in java.lang package

Java.lang package has following classes: Boolean,, Byte, Character, Character.Subset, Character.UnicodeBlock, Class,

ClassLoader, Compiler, Double, Enum, Float, InheritableThreadLocal, Integer, Long, Math, Number, Object, Package, Process, ProcessBuilder, Runtime, RuntimePermission, SecurityManager, Short, StackTraceElement, StrictMath,

String, StringBuffer, StringBuilder, System, Thread, ThreadGroup, ThreadLocal, Throwable, Void.

Interfaces present in java.lang

Appendable, Comprable, Runnable, CharSequence, Iterable, Cloneable, Readable. It is not possible to explain each class & methods present in java.lang package & it

is also beyond the scope of this book. I am going to explain the most frequently used & important classes their methods

present in this package. Boolean

This is a wrapper class. This class is used to create the object of primitive data-type boolean. This class is explained in the chapter Wrapper class.

Byte This is another Wrapper class. This class is used to create the object of primitive

data-type byte. This class is explained in the chapter Wrapper class.

Character This is another Wrapper class. This class is used to create the object of primitive data-type byte. This class is explained in the chapter Wrapper class.

Charcter.Subset

This class is static inner class. This class extends the Object class. This class is enclosed by the Wrapper class Character. The signature of this class is public static class Charcter.Subset extends Object.

Character.Unicode

362

This class is also a static inner class. Its outer class is Character. This class can not be extended since it is declared with final keyword. This class extends the

Character.Subset class.

Class The class Class extends the object class & implements the Serializable interface.

This class is a final class, hence can not be extended. It does not contain any public constructor. In java all the arrays including arrays of primitive data types are created by the invocation of the new operator, just like creation of object. Actually

java implements these arrays as the reflection of the object of class Class. This class is instantiated only by Java Virtual Machine during the process of class loading

by the invocation of the defineClass() method. This class is generic in nature. You can create the object of this class by the invocation of getClass() method. This method getClass() originally belongs to the Object class & is over-ridden in this

class Class.

The getClass() & getName() methods: the two methods are invoked together to determine the class name of an object.

Let‟s have an example class Demo { public static void main(String[]args)

{ Class cl="Hello World".getClass();

System.out.println("The string is an object of "+cl.getName()); cl=System.out.getClass(); System.out.println("out is an object of "+cl.getName());

} } Output:

The string is an object of java.lang.String out is an object of java.io.PrintStream

In this above program cl is a refernce of class Class. As I have said object of the class Class can not be created directly.

The getClass() method returns the name the class, whose object has invoked it. First the getClass() method is invoked by he String object. Hence cl holds the String

class. now getName() method simply shows the name of the class that is held by cl. There is another method getSuperClass(), which is used to determine the current super class of the class held by the reference variable of class Class.

Now lets find out what is the class name to which arrays of primitive data types in

java belongs to class Demo {

363


float mak[]=new float[8]; Class cl=mak.getClass();

System.out.println(cl.getName()); }

} Output: [F

Foxed! With the out put. The „[„ indicates that mak is an array. If mak would be two dimensional array then initial symbol would be ‟[[„. Next symbol „F‟ indicates mak is an array of float of single dimension. For other primitive data types the symbols are

Boolean Z byte B

char C class or interface Lclassname double D

float F int I

long J short S

The forName() method & the newInstance() method.

package demo;

class X{ int i=10;

} class Demo {

int i=10; public static void main(String[]args) throws InstantiationException,IllegalAccessException,ClassNotFoundException

{

X b=new X(); Class cl=Class.forName("demo.X"); X a=(X)cl.newInstance();

System.out.println(a.i);

} }

Output: 10

forName() method is a static method, there fore it has to be invoked by it‟s class name Class. It‟s signature is

364

public static Class forName(String className) throws ClassNotFoundException

Hence it has to be invoked inside try block or throws keyword has to be used. This method returns the Class object that holds the class supplied as a string argument

to this method. Previous to this you know that to create an object of a class you need to call the constructor of this class through new operator. But, the method newInstance() can invoked to create the object of the class that is held by cl. The

signature of newInstance() method is public Object newInstance()

throws InstantiationException, IllegalAccessException Therefore this method has to be invoked inside a try block followed by a catch

block or by the use throws keyword.

ClassLoader ClassLoader is a abstract class which extends the Object class. in java a class is loaded in to the memory either by boot strap class loader or by user defined class

loader. Boot strap class loader is an component of Java Virtual Machine. When a class file is executed by javac command, the boot strap class loader is responsible

for loading the class in to the memory. The class ClassLoader is used to create the user defined class loader. Rarely a java programmer requires an user defined class

loader. Compiler class

When you compile a java source file .class file is created. By the use compiler class native executable files can be generated from java source file. This class can not be

extended. This class extends the Object class. This cass is rarely used by the java programmer.

Double This is another Wrapper class. This class is used to create the object of primitive

data-type byte. This class is explained in the chapter Wrapper class. Enum class This class is used to create the Enum object. Enum members are simple constants.

Float This is another Wrapper class. This class is used to create the object of primitive

data-type byte. This class is explained in the chapter Wrapper class. Integer This is another Wrapper class. This class is used to create the object of primitive

data-type byte. This class is explained in the chapter Wrapper class. Long

This is another Wrapper class. This class is used to create the object of primitive data-type byte. This class is explained in the chapter Wrapper class.

Process class & Runtime class These two classes are closely entangled with each other. Java programmer use

these two classes frequently to develop system level applications.

365

First of all Process is an abstract class. All the methods present in this class is abstract class. The signature of the Process class is : public abstract class Process

extends Object. Since it is an abstract class you can not directly create the object of Process class. For this purpose normally the exec() method of Runtime is used. A

Process object embeds a process in to it. The object of a Runtime class contains the current system environment. To instantiate Runtime class you have to invoke the getRuntime() method. It is a static

method. Hence it is invoked by the class name Runtime. package demo;

class X{ int i; }


{ Runtime rt=Runtime.getRuntime();

long Initial,Final; Initial=rt.freeMemory();

//This method retuns the amount of free memory available. System.out.println("Available memory initially: "+Initial);

X mak[]=new X[10000]; Final=rt.freeMemory(); System.out.println("Available memory after the creation of object: "+Final);

long s=(Initial-Final)/10000; System.out.println("Available free memory: "+s);

rt.gc(); //gc () method is used to invoke the garbage collector. System.out.println("Available free memory:"+rt.freeMemory());

} } Output:

Available memory initially: 1872280 Available memory after the creation of object: 1832264

Available free memory: 40016 Available free memory:1875168

One question may arise in your mind is why such a large array? This is because by creating a large array appreciable change in the free memory is reflected.

Normally while training new comers in java a usual question from their side is how to measure the size of an object in java. Since they all are migrated from C/C++,

they do miss the sizeof operator quite a lot. Java does not provide the sizeof operator but, you can determine the size of an object through various methods

available in Runtime class. Determining the size of primritive data type char

366


{

Runtime rt=Runtime.getRuntime(); long Initial,Final; Initial=rt.freeMemory();

char mak[]=new char[10000]; Final=rt.freeMemory();

long s=(Initial-Final)/10000; System.out.println("Size of the object is "+s); }

} Output: Size of the object is 2

Similarly to determine the size of int class Demo { public static void main(String[]args)

{

Runtime rt=Runtime.getRuntime(); long Initial,Final;

Initial=rt.freeMemory(); int mak[]=new int[10000]; Final=rt.freeMemory();

long s=(Initial-Final)/10000; System.out.println("Size of the object is "+s);

} } Output: Size of the object is 4

To get the size of double class Demo {


Runtime rt=Runtime.getRuntime(); long Initial,Final;

Initial=rt.freeMemory(); double mak[]=new double[10000]; Final=rt.freeMemory();

long s=(Initial-Final)/10000; System.out.println("Size of the object is "+s);

} } Output: Size of the object is 8

Use of exec() method to execute system dependent application. Suppose we are in

a window system then the bellow codes will open ms paint for you. package demo;

367

class Demo { public static void main(String[]args)throws Exception

{

Runtime rt=Runtime.getRuntime(); Process p=rt.exec("mspaint");

} }

Output:

The System class

368

This class contains a large number static methods & variables. You can not crate the object of System class. You can not create the sub class of System class.

The getProperty() method This method takes various types of environment properties defined by the java.lang

package. Some of the examples will fix your idea. This method is a static method. Hence can only be invoked through class name

Determining the Os in which you are working package demo;

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

String S=System.getProperty("os.name");

System.out.println(S); }

} Output: Windows XP

This particular method can be used to create single class file which will operate in different plat form differently.

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

{ String s=new String( System.getProperty("os.name"));

Runtime r=Runtime.getRuntime(); Process p=null; try

{ if(s.equals("Linux"))

{ p=r.exec("gedit"); }

if(s.equals(“Windows XP”)) {

p=r.exec("notepad"); } }

catch(Exception ie) { }

} } If you run this program in windows plat form, it will open the note pad & if in Linux

platform it will open the gedit. I have run this program in windows platform see the output:

369

The arrayCopy() method

When you copy an array, you do it by loop. This process can be completed by the use of arrayCopy() method in a more efficient way. package demo;

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

{ char mak[]={'r','o','o','t',' ','l','e','s','s',' ','a','g','g','r','e','s','s','i','o','n'}; char arr[]=new char[mak.length];

System.arraycopy(mak, 0,arr, 0, mak.length); for(int i=0;i<arr.length;i++)

System.out.print(arr[i]);

370

}} Output: root less aggression

this method takes the source array as its 1st argument, next argument is the position from which the source has to be copied, 3rd one is the name of the

destination array, 4th one is the position of the destination array from which the copy process begins & final one is the length of the source array up to which the data has to be copied.

The ThreadLocal class

The ThreadLocal variables are typically declared as private and static. Whenever

programmer feels that some data should be unique for the thread and the data

should not be shared, then ThreadLocal variables are used. Every individual thread

has a separate copy of the variable that means any change done to the

ThreadLocal variable by a thread is totally private to it . It is not going to reflect in

any other thread.

Below given is the structure of ThreadLocal<T> class defined in java.lang

public class ThreadLocal<T> {

protected T initialValue( );

public T get( );

public void set(T value);

public void remove( );

}

protected T initialValue()

it returns the intial value for the ThreadLocal variable of the current thread .

whenever we access the variable with the get() method for the first time the initialValue() method is called implicitly. If the set() method is invoked prior to the get() method then the initial value method will not invoked.

public T get()

it returns the value of the copy of the thread-local variable present in the current thread. Creates and initializes the copy if it is called for the first time by the thread then it creates and initializes the copy of the variable.

public void set(T value)

371

it sets the copy of the thread-local variable of the current thread to the specified value.

public void remove()

it removes the value of the ThreadLocal variable.after removing the value if we will again invoke the get method then it will again call the initialValue method and will intialise the value of the ThreadLocal variable.

class ThreadLocalDemo1 extends Thread {

private static int number = 0; private static ThreadLocal threadnumber = new ThreadLocal() {

protected synchronized Object initialValue() {

return number++; }

};

public void run(){

System.out.println("Thread " + Thread.currentThread().getName() + " has thread number " + threadnumber.get());

number++; System.out.println("Thread " + Thread.currentThread().getName() +

" has thread number " + threadnumber.get()); threadnumber.set(5); System.out.println("Thread " + Thread.currentThread().getName() +

" has thread number " + threadnumber.get()); threadnumber.remove();

System.out.println("Thread " + Thread.currentThread().getName() + " has thread number " + threadnumber.get());

threadnumber.remove(); System.out.println("Thread " + Thread.currentThread().getName() +

" has thread number " + threadnumber.get());

}


372

Thread t1 = new ThreadLocalDemo1(); Thread t2 = new ThreadLocalDemo1();


}

}

Output :

Thread Thread-0 has thread number 0

Thread Thread-0 has thread number 0 Thread Thread-0 has thread number 5 Thread Thread-0 has thread number 2

Thread Thread-0 has thread number 3 Thread Thread-1 has thread number 4



Cloneable interface:-

The Cloneable interface is present inside the java.lang package, is used to create

the clone of an object. The signature of Cloneable interface is:

public interface Cloneable

{

}

The Cloneable interface does not contain any method of its own.To clone an object,

a class must implement the interface Cloneable and then invoke the clone ()

method of object class. The signature of the clone () method is:

protected native Object clone() throws CloneNotSupportedException

According to the specification, the clone () method returns the reference of the

Object class.

373

Example:-

public class LetsClone implements Cloneable

{

int roll;

String name=new String();

F(int i, String c)

{

roll=i;

name=c;

}

public static void main(String ar[]) throws CloneNotSupportedException

{

F obj=new F(10,"pinku");

F ob=(F)obj.clone();

System.out.println(ob.roll);

System.out.println(ob.name);

}

}

Output: 10

pinku

374

The Cloneable interface is a marker interface. A marker interface is an interface,

which does not have its own method. But for certain operations, their

implementation is a must. Actually implementing the marker interface programmer

implicitly let the JVM to know that a specific operationnis going to be performed.

The marker interfaces present inside java are:

Java.lang.Cloneable Java.io.Serializable

Java.util.EventListener

To clone one object, the clone() method of the Object class is needed. But, we need

to implement the Cloneable interface (i.e. a marker interface) to facilitate the class

with the ability for cloning it objects.

Object class:-

In java Object class is the super class of all the classes. Many of its methods are over ridden in different java in built classes according to their purpose.

Methods present in Object class:-

Object clone()

I have used this method in creating clone of an object. This method belongs to Object class.

boolean equals(Object eq) this method is explained in detail in String chapter.

void finalize()

This method is called before an object is garbage collected from heap. This is

explained in detail in class fundamental.

Class getClass() Already explained earlier in this chapter.

int hashCode() Explained in detail in object reference & string chapter.

Most of the methods of this class is explained in detail in various chapters of

this book. Reader can go through them.

Math class The Math class contains various methods that are usefull scientific & engineering applications. It contains two double constansts: E(the exponential

c constant) (~2.72) and PI (~3.14).

375

Methods in Math class:-

public static double sin(double dbl) This method is a static method; hence can only be invoked by class name. It takes

a double variable as its argument. This argument is the measurement of an angle in radian. It returns the sine value of the supplied angle

public static double cos(double dbl) This method is a static method; hence can only be invoked by class name. It takes

a double variable as its argument. This argument is the measurement of an angle in radian. It returns the cosine value of the supplied angle. public static double tan(double dbl)

This method is a static method; hence can only be invoked by class name. It takes a double variable as its argument. This argument is the measurement of an angle in

radian. It returns the tangent value of the supplied angle. See the below exapmple

public class Arithm1

{ public static void main(String arg[])

{ double dbl1= 30; double dbl2 = Math.toRadians (dbl1);

System.out.println(" The angle in radians is : " + dbl1);

System.out.println(" sine of “+dbl1+” is : "+ Math. sin(dbl2) ); System.out.println(" cosine of “+dbl1+” is : "+ Math. cos(dbl2) ); System.out.println(" tangent of “+dbl1+” is :"+ Math.tan(dbl2));

} }

Output: The angle in radians is : 30.0 sine of “+dbl1+” is : 0.49999999999999994

cosine of “+dbl1+” is : 0.8660254037844387 tangent of “+dbl1+” is :0.5773502691896257

public static double asin (double dbl) This method is a static method; hence can only be invoked by class name. It takes

a double variable as its argument. This argument is the sine value of an angle. It returns the angle in radian. Range is in between –π/2 to π/2

public static double acos (double dbl) This method is a static method; hence can only be invoked by class name. It takes

a double variable as its argument. This argument is the cosine value of an angle. It returns the angle in radian. Range is in between 0 to π

376

public static double atan (double dbl) This method is a static method; hence can only be invoked by class name. It takes a double variable as its argument. This argument is the tangent value of an angle.

It returns the angle in radian. Range is in between 0 to π

public class Arithm2{ public static void main(String arg[])

{ double dbl=0.5; System.out.println("Enter Value is :"+dbl);

System.out.println("The angle for which the sine value is 0.5 is :"+Math.asin(dbl)); System.out.println("The angle for which the cosine Value is : " + Math. acos(dbl) );

System.out.println("The angle for which the tangent Value is : " + Math.atan(dbl) );

} } Output: Enter Value is :0.5

The angle for which the sine value is 0.5 is :0.5235987755982989 The angle for which the cosine Value is : 1.0471975511965979

The angle for which the tangent Value is : 0.4636476090008061

public static double toRadians(double dbl) This method is a static method; hence can only be invoked by class name. It takes

a double variable as its argument. This argument is the measurement of an angle in degree. It returns the equivalent angle in radian.

public static double toDegrees(double dbl) This method is a static method; hence can only be invoked by class name. It takes

a double variable as its argument. This argument is the measurement of an angle in degree. It returns the equivalent angle in degree.

class Demo { public static void main (String arg[]) {

System.out.println("the radian value is :"+Math. toRadians(90.0)) ; System.out.println("Degree value is:"+Math.toDegrees(1.571)) ;

System.out.println("Tangent value of two parameters is: "+Math. atan2(30.00,30.00));

377

System.out.println(" The log value is :"+Math. log(35.0)); System.out.println("The Exponent value is :"+Math.exp(30.00));

}

}output: the radian value is :1.5707963267948966

Degree value is:90.01166961505233 Tangent value of two parameters is: 0.7853981633974483

The log value is :3.5553480614894135 The Exponent value is :1.0686474581524463E13

public static double exp(double dbl)

This method is a static method; hence can only be invoked by class name. It takes a double variable as its argument. This argument is the tangent value of an angle. It returns the angle in radian. Range is in between 0 to π

public static double log (double dbl)

The log method has only one double value i.e.‟ dbl‟ as the parameter. This method returns the natural logarithm (base e) of a double value.

public static double sqrt (double dbl)

Here, the sqrt method has only one double value ‟dbl‟ as the parameter and it returns the square root of the given value „dbl‟. When the argument is NaN or less

than zero , the result is NaN.

public static double IEEEremainder(double dbl1, double dbl2) This method used to calculate the remainder operation on two arguments. This

method having two parameters i.e. dbl1(the dividend) and dbl2(the divisor).Here it returns the remainder when dbl1 is divided by dbl2.

public static double ceil(double dbl)

This ceil method has only one double value i.e.‟dbl‟ which is taken as parameter.

According to this method the given double value returns the smallest double value which is not less than the argument and is equal to a mathematical integer.

public static double floor(double dbl)

378

This floor method having only one double value „dbl‟ as the parameter. This method returns the largest double value which is not greater than the argument and is

equal to a mathematical integer.

public static double rint(double dbl)

This rint method containing only one double value „dbl‟ as the parameter. It returns the closest double value to that „dbl‟ and is equal to a mathematical integer. If two

double values that are equally close to the value of the argument, it returns the integer value that is even.

public static double atan2 (double dbl1, double dbl2)

Here there are two double values dbl1 and dbl2.These are the parameters for this method. The given rectangular coordinates (dbl2, dbl1) is converted to polar (r, theta) by this method. This method also computes the phase theta by computing

an arc tangent of dbl1/dbl2 in the range of –pi to pi.

public static double pow(double dbl1,double dbl2)

Here two double values dbl1 and dbl2 which are taken as the parameters for this method. This method returns the value of the first argument which is raised to the power of the second argument. if

(dbl1==0.0) ,then dbl2 must be greater than 0.0, Otherwise it throws an exception . An exception can also arise if(dbl1<=0.0) , dbl2 not equals to a whole number.

class Arithm4 { public static void main (String arg[] ) {

System.out.println("The square root value is :"+Math.sqrt( 25)); System.out.println("\ nThe remainder of 5 divided by 2

is:"+Math.IEEEremainder(5,2)); System.out.println("\ n The ceil value is : "+Math. ceil(5.6)); System.out.println("\ n The floor value is:"+Math. floor(5.6));

System.out.println("\ n The power value is :"+Math. pow (5.0,2.0)); System.out.println("\ n"+"The rint value is :"+Math.rint(30.6));

} }

Most of the methods of math class is static in nature. Their name clearly indicates their task. I hope reader can google through them & can get them quite easily.

Conclusion: Java.lang package is the only package that is available to the programmer by

default. java.lang provides quite a lot utility tools to the programmer. Recently added interfaces like Instrumentation has increased the scope of this package. This

package is going to be the premier package of java programming language forever.

379

Chapter-23

The collection frame work

Introduction

I must say this is the most important package & extensively used by java developer. If you are familiar with C++, as you go through the chapter you

can feel that Collection Frame work of java shows similarity with the Standard Template Library (STL) of C++. But things are entirely not the

same. Java Collection Frame Work is quite rich.

The Collection class object is used to store, manipulate & retrieve objects by the implementation of various data structures like normal array,

linked list, trees, stack, queue, hash-table etc.

Advantages of the Collection framework:

By the help of useful data-structures and algorithms provided by this

framework we can effectively reduce the effort of programming. Increases program speed and quality since the implementation of

each interface are interchangeable. It allows inter operability among unrelated APIs.

Extending or adapting a collection is easy. It reduces the effort in designing new APIs.

Encourage software reuse since the Interfaces and algorithms are reusable.

It can interface the core Collection Interfaces which will be effective to achieve different operations on Collections and we can also pass them

from one method to another effectively.

By the help of the aforesaid interfaces we can manipulate the collections independently irrespective of their underlying

representations.

Here in most of the programs I have used the generic constructor of the corresponding class since generic provides type safety.

The for-each loop

Before starting our voyage in to the util package it‟s the time now to explain another version of looping the for each loop. This loop is particularly use full

when you deal with arrays or in general you might say when you deal with collection of object.

Lets have a simple program:

380

class Demo {

public static void main (String arg[]) {

int mak[]=new int[8]; for(int i=0;i<8;i++)

{ mak[i]=i;

} for(int j:mak)

{ System.out.println(j);

} }

}

Output: 0

1 2

3 4

5 6

7 The statement that troubles you

for(int j:mak) {

System.out.println(j); }

Let me explain. mak is the array name & the array is the array of integers.

Each element stored in mak is of primitive data type int. when 1st time the statement int j:mak is encountered in side for loop, java assigns the 1st

element present in mak to j, 2nd time when the same statement is encountered in side for loop 2nd element is assigned to j. this process

continues until the last element assigned to j. after that the loop automatically terminates. This loop maintains a higher level of abstraction.

You can try this for an array of user defined class.

Set interface The Set interface extends the Collection interface. But, the Set interface

never gives permit to have duplicate element with in the set object. The set interface does not define any method of its own. It uses only the methods of

the Collection interface. It adds restriction on the add ( ) method since it

381

returns false if the user tries to include duplicate elements added to a Set. It

also adds restriction on the equals( ) and hashcode( ) methods.

SortedSet Interface The SortedSet interface extends to the Set interface. Java defines a

natural ascending order principle for this interface.If the current set does not contain any element, then most of the methods present in this interface

throws the NoSuchElementException. If any object is not compatible with the elements that are present in Set then an exception known as

ClassCastException is thrown. Null object can not be used in this interface other wise NullPointerException will be generated.

Comparator comparator():-

This method returns the comparator of the current SortedSet. This method returns null if the set using the default ordering principle of

Java.

Object first( ):- This method is used to return the first element of the current

SortedSet to the caller of the method. SortedSet headSet(Object ss ):-

This method returns a SortedSet that contains elements less than the object ss from the current SortedSet.

Object last ( ):- The purpose of using this method is to return the last element of the

current SortedSet to the caller. SortedSet subSet(Object ss1, Object ss2 ):-

The job of this method is to return a SortedSet reference consisting of elements between the object ss1 and the object ss2, which behave like

two end points.

SortedSet tailSet(Object element):- This method is used to return a SortedSet reference. Which contain

elements those are greater than or equal to the current SortedSet object through which it is invoked.

List Interface:-

The List interface extends the Collection Interface. It is an ordered Collection. This Collection has the permission to contain duplicate elements.

Elements can be inserted into the list or accessed from it through their integer index in the list.

Including the methods of Collection interface, the List interface has some of its own methods. Brief descriptions of the methods are given below:

382

void add(int index, Object l):-

This method inserts the Object l into the current list at the position specified by index. The preceding elements(if any) are shifted up in

the list. boolean addAll(int index,Collection cls):-

This method is used to add the elements of the given Collection cls to the current list at the position specified by index. The preceding

elements(if any) are shifted up in he list. Object get(int index):-

This method is used to return the object stored at the position specified by the index, within the current collection.

int indexOf(Object li) This method is used to find out the object li in the current list and

returns the index of its first instance. If the object li is not found to be an element of the concerned list, then -1 is returned.

int lastIndexOf(Object li):-

This method is used to search for the object li in the current list and returns the index of its first instance. If the object is not found in the

concerned list, then -1 is returned to the caller. ListIterator listIterator( ):-

It returns an iterator to the start of the current list. ListIterator listIterator( int index):-

By the help of this method an iterator for current list is returned, that begins at the position specified by the given index.

Object remove(int index):- This method is used to erase the element found at the position as

specified by index, from the current list. Object set(int index,Object a):-

It assign a to the position specified by index in the current list. List subList(int starting, int ending):-

It returns a list that includes elements from the position specified by

starting to the position specified by ending -1 in the current list. The methods of the interface can be categorized into methods used

for Positional Access, Search, List Iteration and Range-view. The get(), set(), add(), remove() and addAll() methods are the methods used for

Positional Access. The indexOf and lastindexOf methods are used for search. The two listIterator methods are used for iteration. The sub-

list method is the Range-view method.

Implementations

383

Implementation (or classes) is the actual objects used to store the

collections. Some of these classes provide the full implementation and can be used right away, whereas, the others are abstract and are used as

starting points for creating concrete collections. The important standard collection classes are as follows:-

AbstractCollection : AbstractCollection is a class which helps to provide a skeletal

implementation of the Collection interface. In order to implement an un-modifiable collection, we have to extend the

AbstractCollection class and provide the implementation logic for the methods like Iterator() and size().

On the other hand, if we need to implement a modifiable collection, the add() method has to be overridden. In this case, the remove method is

implemented by the Iterator returned by the iterator() method. AbstaractList :

The AbstaractList class extends the AbstractCollection class and provides

a skeletal implementation of the List interface.

The implementation of an un-changeable list requires the extension of this class and then we have to provide implementations for the get and size

methods. To implement a modifiable list, the set and remove methods are to be

overridden.

AbstractSequentialList :-

AbstractSequentialList is a class which extends to the AbstractList class. It is an implementation of the List interface. By the help of this class a

sequential access can be carried over the collection elements. In order to implement a list, we have to extend the AbstractSequentialList

class and define the implementations for the listIterator() and size()

methods.

LinkedList :

LinkedList is a class which extends the AbstractSequentialList class and implements the interface List. All the optional list operations are to be

implemented by this class.

For the implementation of the List interface, similar named methods have been provided for the operations like get, remove and insert an element at

the beginning and at the end of the list.

ArrayList:

https://www.ithenticate.com/report/1524661/similarity?source=2399315577&dsc=1&id=17210&node=0&dn=2070d757e880bd9e5908681c4de2dba76a194e42307eefe9480792b3be1d4ffe97bfe02aef3b4b2a3121ba16ebc2706fec84013c7006e04932219168a987cb13

https://www.ithenticate.com/report/1524661/similarity?source=2399315577&dsc=1&id=17210&node=0&dn=2070d757e880bd9e5908681c4de2dba76a194e42307eefe9480792b3be1d4ffe97bfe02aef3b4b2a3121ba16ebc2706fec84013c7006e04932219168a987cb13

384

ArrayList is a class which extends the AbstractList class and implements

the List interface. ArrayList is serializable. In addition to that, there are methods with which we can manipulate the size of the array that is used to

store the list internally.

AbstractSet : AbstractSet is a class which extends the AbstractCollection class and

provides the skeletal implementation of the Set interface.The implementations from the AbstractColllection class are not overridden in this

class. It only used to add implementations for equals and hashcode methods.

HashSet :

HashSet is a class which extends the AbstractSet class and implements the

Set interface. HashSet class have a hash table associated with it. The time

complexity for various operations to be performed on the HashSet is almost constant.

The ArrayList class

ArrayList class is used to create dynamic arrays that means the object of this class grows & shrinks as you add new elements to it or you remove

elements from it respectively. This class is a generic class. This class implements the List interface & extends the AbstractList class.

package demo; import java.util.*;

class X{ int i;

} class Demo {


ArrayList<X> arrX=new ArrayList<X>(); System.out.println("Initially size of the array:"+arrX.size());

for (int j=0;j<5;j++)

385

{

X a=new X(); a.i=j;

arrX.add(a); }

System.out.println("now size of the array "+arrX.size()); for (int j=0;j<5;j++)

{ X a=new X();

a.i=j+5; arrX.add(a);

} System.out.println("Finally the array size "+arrX.size());

for(X a:arrX){ System.out.println(a.i);

}

}

} Output:

Initially size of the array:0 now size of the array 5

Finally the array size 10 0

1 2

3 4

5

6 7

8 9

I have already said ArrayList class is a generic class. It‟s signature is

Class ArrayList<Claass_Nmae>. Programmer specifies the name of the class whose ArrayList has to be created. Here arrX is an object which can contain

the object of class X. In the above program I have supplied the class name X to create the ArrayList of class X. To get the number of elements that is

stored in the ArrayList, the size() method has to be invoked by the corresponding of ArrayList class. Object of ArrayList is some thing like

container. Here arrX is an object which can contain the object of class X. So

386

how to add a new element to this container? 1st create an object X. call the

add() method through the object of ArrayList & pass the object of X to be added. The signature of add() method is boolean add(A object). If add()

method is successfully executed then boolean true value is returned else false will be returned. Actually this add() method belongs to List interface

which is implemented in ArrayList class, hence add() method is over-ridden there. To determine the length of arraylist the size() method is used, which

returns the size of ArrayList object. Its return type is integer. ArryList constructors are

1:ArrayList()a zero argument constructor to create an empty array & the array grows as you add new element to it.

2:ArraList(int initial_size) this constructor is used to create an array having length of initial_size supplied by the programmer & the size grows as new

element is added to it. 3:ArryList(Collection<? Extends T>c) this constructor used to create an

array which can hold the object of T or the object of the subclass of T. lets

have an example


class X{ int i;

void show() {


} class Y extends X{

int j; void show()

{


} class Demo {



for (int j=0;j<5;j++) {

X a=new X(); a.i=j;

arrX.add(a);

387

}

System.out.println("now size of the array "+arrX.size()); for (int j=0;j<5;j++)

{ Y a=new Y();

a.j=j+5; arrX.add(a);


for(X a:arrX){ a.show();

}

}

} Output:



1 2

3 4

5 6

7 8

9

If you have got the concept of inheritance then the output here is straight forward.

Deletion an Object from ArrayList

In order to remove an object from ArrayList you have to invoke the remove() method. Just pass the index number of the element that you want

to remove from the ArrayList. Program below will fix your idea. package demo;

import java.util.*; class X{

int i; void show()

{

388


} }

class Y extends X{ int j;

void show() {


} class Demo {



for (int j=0;j<5;j++)

{ X a=new X();

a.i=j; arrX.add(a);

} System.out.println("now size of the array "+arrX.size());

arrX.remove(4); for (int j=0;j<5;j++)

{ Y a=new Y();

a.j=j+5; arrX.add(a);


for(X a:arrX){

a.show(); }

}

} Output:



1

389

2

3 5

6 7

8 9

Another version of remove() method: here you can directly pass the object to be removed from ArrayList as an argument of remove() method. see the

example below. package demo;

import java.util.*;

class Demo { public static void main (String arg[])

{

ArrayList<String> arrX=new ArrayList<String>(); arrX.add("Eureca");

arrX.add("Dasvidania"); arrX.add("Minerva");

arrX.add("HitMan"); arrX.add("Vendeta");

for(String s:arrX) {

System.out.println(s); }

arrX.remove("Dasvidania"); System.out.println("After deletion");

for(String s:arrX) {


} }

Output: Eureca

Dasvidania Minerva

HitMan Vendeta

After deletion Eureca

Minerva HitMan

Vendeta

390

See that the string object that is to be removed from the ArryList passed as

an argument remove() method.

The LinkedList Class First of all LinkedList is a generic class. It provides the linked list data

structure to store & manipulate the data. package demo;

import java.util.*;

class X{ int i;

} class Demo {

public static void main (String arg[])

{ LinkedList<X> linkedL=new LinkedList<X>();


X a=new X(); a.i=i;

linkedL.add(a); }

X a=new X();

a.i=100; linkedL.addFirst(a);

for(X b:linkedL)

{

System.out.println(b.i); }

} }

Output:

100 0

1 2

3

391

4

To add a new element at the beginning of LinkedList object you have to invoke the addFirst() method which takes the argument of the object that is

to be added at the beginning of the list. Similar is the job of another method offerFirst(). See the use of for each loop to extract the elements present in

the LinkedList object. The remove() method discussed in ArrayList class can be invoked in LinkedList to perform the similar task. See the for-each loop

used here to retrieve the element from LinkedList object.

Retrieving particular element from the LinkedList object.

get() method is used to get the stored elements. This method takes index

number as its argument & returns the object stored at that postion in the LinkedList object.

import java.util.*;

class X{ int i;

} class Demo {


LinkedList<X> linkedL=new LinkedList<X>(); for(int i=0;i<5;i++)

{ X a=new X();

a.i=i; linkedL.add(a);

}


X a=linkedL.get(i); System.out.println(a.i);

} }}

Output:

0 1

2 3

4

392

Here get() method is invoked by the object of LinkedList & returns the object

of class X. Some other methods

addLast() or offerLast() method is used to add an element at the end of LinkedList object.

To add a particular element at a specific location you can use add(int,E) method. The position where to insert an element is supplied as the first

argument to this method. set() method is used to change an entity stored in the LinkedList object in

the specified location.

Now lets have an example

import java.util.*;

class X{

int i; }


{ LinkedList<X> linkedL=new LinkedList<X>();


X a=new X(); a.i=i;

linkedL.add(a); }

X a=new X();

a.i=100; linkedL.set(1,a);

for(X b:linkedL) {


}} Output:

0 100

2 3

4

393

See the out put, the change is reflected there.

The HashSet Class

The HashSet class of this util package use has table data structure in back ground to store the data. What is a hash table? Hash table is a data

structure to store data, which contains key value for each data present in the hash table. This key value is unique for each element present in the hash

table. The key field is closely associated with a pointer or a memory address. When a data is to be retrieved from a hash table the user provides the key

value. The data is retrieved from the hash table by the memory address associated with the key value.

HashSet in java extends the AbstractSet & implements the set

interface. Remember one thing that when you store data in an object of HashSet there is no guarantee that the data is going to be stored in the

order it has been entered. Just check it out here. The HashSet class does not

provide the key value to the programmer to access the objects stored with in it. But, the HashMap class do provide the key.

package demo;

import java.util.*;

class X{ int i;

} class Demo {


HashSet<X> hashS=new HashSet<X>(); for(int i=0;i<5;i++)

{

X a=new X(); a.i=i;

hashS.add(a); }

for(X b:hashS)

{ System.out.println(b.i);

}

}}

394

Output:

3 4

2 1

0 Got it!! Fine!!

In order to add an element you have to call the add() method along with the object to be added through the object of HashSet class. but you cannot

determine where the data is going to be added. package demo;

import java.util.*;

class X{

int i; }


{ HashSet<X> hashS=new HashSet<X>();


X a=new X(); a.i=i;

hashS.add(a); }

X z=new X(); z.i=100;

hashS.add(z);

for(X b:hashS) {


}}

Output: 3

100

395

4

2 1

0 See where 100 is added.

The TreeSet class

In a TreeSet class in java uses tree data structure to store the data. Data in TreeSet class always stored in ascending order. Since this class maintains

tree structure to store data, searching is done quite efficiently.


class Demo {


TreeSet<Integer> treeS=new TreeSet<Integer>(); int j=5;


System.out.println("Added element:"+j); treeS.add(j);

j--;

}

for(Integer b:treeS) {

System.out.println("Stored element"+b);

}

}} Output:

Added element:5 Added element:4

Added element:3 Added element:2

Added element:1 Stored element1

Stored element2 Stored element3

Stored element4

396

Stored element5

See the out put although the elements are supplied in descending order, still they are stored in the TreeSet in ascending order.

The Iterator

The Iterator is an interface which is similar to Enumeration interface, except

these two differences. Iterator as the name suggest is used to traverse through the elements stored in the set. Through Iterator programmer can

remove the elements stored in the set. But, Enumeration (explained latter in this chapter) does not support the removal of elements present in the set.

Method names have been improved in Iterator as compared to Enumeration

The methods of the Iterator interface are:- boolean hasNext( ):-

If the iteration has more elements then it returns true, else, it

returns false. Object next( ) :-

This method is used to iteratively extract the next element from the iteration. If there will be no more elements in the iteration, then it throws

the NoSuchElementException void remove ( ):-

This method is used to remove the last element returned by the iterator, from the current collection. We can call this method only once

per call to the next method.

Till now to loop through the various elements stored in Collection object I have used the for-each loop. Alternative to for-each loop is Iterator. Steps to

use Iterator: 1: create an Iterator object corresponding to the elements stored in the

Collection frame work. 2: loop through the Collection object to retrieve the elements by the use of

hasNext() method 3:extract the element by next() method

package demo;


int i;

397

}


{ ArrayList<X> arrX=new ArrayList<X>();

for (int j=0;j<5;j++) {

X a=new X(); a.i=j;

arrX.add(a); }

Iterator<X> iteR=arrX.iterator(); while(iteR.hasNext()){

X a=iteR.next(); System.out.println(a.i);

}

}

Output: 0

1 2

3 4

The hasNext() method, each time when it is invoked check whether an

element existed in arrX or not in its next place, if not it returns false. The next() method return the element stored in arrX(). The way the Iterator is

used in case of object of ArrayList class can also be used in LinkedList, HashSet, TreeSet calss.

The ListIterator The object ListIterator provides a way to loop through the elements stored in

the Collection object bidirectionally. Like Itrator it is also a generic class. steps are same to use the ListIterator object. Just see the program below

package demo;


int i; }


{

398

ArrayList<X> arrX=new ArrayList<X>();

for (int j=0;j<5;j++) {

X a=new X(); a.i=j;

arrX.add(a); }

System.out.println("Fore ward traversing"); ListIterator<X> LiteR=arrX.listIterator();

while(LiteR.hasNext()){ X a=LiteR.next();


System.out.println("Back ward traversing"); while(LiteR.hasPrevious()){

X a=LiteR.previous();


}

}

Output: Fore ward traversing

0 1

2 3

4 Back ward traversing

4

3 2

1 0

hasPrevious() & previous() method behaves in the opposite way the hasNext() & next() behaves. ListIterator object can also be used in

LinkedList, HashSet, TreeSet to perform the similar to that of ArryList.

Map interface

Map is an interface by the help of which, we can establish a mapping between keys to the corresponding element. We cannot have any duplicate

399

values in a map. In the process of mapping each key is mapped to one &

only one unique element. This interface consists of methods for basic operations, bulk operations and

Collection view. The different operations that can be made on a map are: put, get, remove,

containsKey, containsValue, size and isEmpty. The bulk operations are putAll and clear methods. The Collection views are keySet and entrySet methods.

void clear ( ) This method removes all the mappings from the current map.

boolean containsKey (Object keyused) This method returns true or false accordingly, whether the current

map is mapping one or more keys to the value or not. boolean containsValue (Object v ):-

This method returns a boolean true when the current map maps one or more keys to the value v. Otherwise, it returns a boolean false.

Set entrySet( )

This method returns a Set interface reference which specifies a view of the mappings established in the current map.

boolean equals (Object mp ) The return type of this method is boolean. It returns true when the

object mp is equal to the current map, else it returns false.

Object get(Object mp):-

This method is responsible to return the value to which the current map maps the key key

int hashCode( ):- This method returns an integer representing the hash code value of

this map boolean IsEmpty( ):-

Checks whether the current map key value mappings. If the map does

not contain any mapping then it returns true, else it returns false Set keySet( ):-

The return type of this method is the Set interface reference which gives the representation of the keys in the map.

Object put(Object mapkey,Object mapvalue ) The job of this method to associate the mapvalue with the mapkey in

the current map. Object remove(Object mapkey)

When there is an already existing mapping present for key in the current map, Then it is removed by the provided mapkey.object a is equal to the

current map,else it returns false Object get(Object keyused)

400

We can get the available value to which the mapping has been

established using the key keyused.

int hashCode( ) Every map has a hashcode value. We can avail the value by using this

method. boolean IsEmpty( )

Checks whether the current map key value mappings. If the map does not contain any mapping then it returns true, else false.

Set keySet( ) The total no of keys used for mapping inside the Map can be returned

using this method. Object put(Object keyused,Object valueused )

To attach the value valueused with the key keyused in the map, this method is used.

Object remove(Object keyused)

This method removes the mapping which is present in the map for the key keyused.

Int size( ) This method is used to get the total number of mappings established

inside the Map. Collection values( )

This method returns a Collection reference which represents the view of the values contained in the map.

StoredMap interface

SortedMap is an interface which also extends the Map interface. The

elements are maintained in an ascending order in case of StoredMap interface.

The sorting may be done in two ways. According to the default ordering principle provided by Java.

According to a user defined Comparator provided by the programmer explicitly.

The methods of SortedMap interface are

Comparator comparator( ):- This method returns the comparator which is associated with the

SortedMap. If the SortedMap keys follows default ordering principle provided by Java,

the method returns null.

401

Object firstKey( )

From the ascending ordered SortedMap, this method returns the lowest key.

SortedMap headMap(Object keyused ):- This method is used to return a reference of the portion of the

currently stored map elements whose keys are less than keyused. Object lastKey( ):-

From the ascending ordered SortedMap, this method returns the highest key.

SortedMap subMap(Object sm1, Object sm1 ) It returns a reference of the portion of the SortedMap whose keys are

ranging from the key specified by sm1, to the key specified by sm2, the range

includes sm1 and excludes sm2. SortedMap tailMap(Object sm )

This method is used to return reference of the portion of the

SortedMap whose keys are greater than or equal to the key as specified by sm1

The HashMap class

This class uses the hash table data structure. It has both key & a value and data associated with the key. How it is used can be understood through a

program. HashMap does not implement Iterable interface. This means programmer

can not traverse a HashMap neither by Iterators nor by for-each loop. package demo;

import java.util.*; class K {

int key;

} class V{

int data; }


{ HashMap<K,V>hashM=new HashMap<K,V>();

K keyArr[]=new K[5]; for(int i=0;i<5;i++)

{ K key1=new K();

key1.key=i;

402

keyArr[i]=key1;

V val=new V(); val.data=i+5;

hashM.put(key1,val); }

for(int i=0;i<5;i++){ V a=hashM.get(keyArr[i]);

System.out.println(a.data); }

}

}

Output: 5

6

7 8

9 Data is sored in the HashMap along with the key value. Just see the put

method, it keeps inserting data in the HashMap with the key value. To extract data from HashMap key is required. Therefore I have declare an

array to store the key value. Then each key value stored in the array is used to extract data from the HashMap. The get() method only requires the key

to extract the data.

The entrySet() method

HashMap is not a part of collection frame work, since it does not implement the Collection interface. How ever, java provides an entrySet() method to

have collection format of HashMap. This method returns Set object which

contains the element of the HashMap. Lets have an example


class K { int key;

} class V{

int data; }


{

403

HashMap<K,V>hashM=new HashMap<K,V>();


K key1=new K(); key1.key=i;


hashM.put(key1,val); }

Set<Map.Entry<K, V>> s=hashM.entrySet(); for(Map.Entry<K, V> x:s)

{ K z=x.getKey();

System.out.print("For key: "+z.key+" Value:"); V c=x.getValue();

System.out.println(c.data);

} }

} Output:

For key: 2 Value:7 For key: 4 Value:9

For key: 3 Value:8 For key: 1 Value:6

For key: 0 Value:5 Here the object of Set s is going to hold the entries of HashMap in set format

by the invocation of setEntry() method through hashM the object of HashMap. The setEntry() method returns the return the object of Set

containing all the stored in HashMap. Remember that each element present

in s is a reference of of Map.Entry. Entry is a inner class of Map. That is why I have created a reference of

Map.Entry in for each loop. The getKey() method returns the reference of class K & the getValue() method returns the reference of class V. Now the

output is straight forward.

The Comparators You must have noticed while explaining the treeSet, the programming

example I have given used a wrapper class instead of user defined class. treeSet stores the object in a sorted order. Java defines a natural ordering

principle like „B‟ comes after „A‟ or „2‟ comes after „1‟ for treeSet & only for

404

the predefined class. when it comes to deal with user defined classes, then

programmer must explicitly define ordering principle by the use of Comparator interface. The Comparator interface defines two method

compare() & equal(). The signature of the Comparator interface is interface Comparator<genR>. Yes this is a generic interface. The signature of

compare() method is int Compare(genR X,genR Y). If X equals Y then 0 is returned

If X>Y then positive value is returned If X<y then negative value is returned

Now lets use the concept. package demo;

import java.util.*; class X {

int i; }

class userComp implements Comparator<demo.X>

{ public int compare(X a, X b){

return a.i-b.i;

}

}


{ TreeSet<X> treeS=new TreeSet<X>(new userComp());


X a=new X();

a.i=i; treeS.add(a);

} for(X a:treeS)

{ System.out.println(a.i);

} }

}

Output:

0

405

1

2 3

4 TreeSet<X> treeS=new TreeSet<X>(new userComp()); this

statement tells the compiler to use the user defined comparator rather than default comprator. Java implicitly invokes the compare() method of

userComp class. The object for which the compare() method returns a positive value is stored next to the previously stored object.

How to reverse this user defined comparator


class X { int i;

}

class userComp implements Comparator<demo.X> {

public int compare(X a, X b){

return -a.i+b.i;

} }

class Demo {


TreeSet<X> treeS=new TreeSet<X>(new userComp()); for(int i=0;i<5;i++)

{

X a=new X(); a.i=i;

treeS.add(a); }

for(X a:treeS) {


}

}

Output:

406

4

3 2

1 0

The Collection Algorithm

Java defines various methods to be operated on Collection objects for

repositioning of the elements, extracting a particular element say minimum or maximum value, sorting the elements in the specified manner, coping the

elements & various other operations. These methods in together constructs the collection algorithm.

Lets have an example


class Demo {


LinkedList<Integer>linkedL=new LinkedList<Integer>(); linkedL.add(-100);

linkedL.add(99); linkedL.add(-99);

linkedL.add(100); Comparator<Integer>revC=Collections.reverseOrder();

// creation of a reverse comparator Collections.sort(linkedL,revC);

// sorting the list according to reverse comparator

System.out.println("Descending order:"); for(Integer i:linkedL)

System.out.println(i); Collections.shuffle(linkedL);

// shuffling the elements present in the list System.out.println("After shuffling");

for(Integer i:linkedL) System.out.println(i);

System.out.println("Maximum element:"+Collections.max(linkedL)); System.out.println("Minimum element:"+Collections.min(linkedL));

}

407

}

Output:

Descending order: 100

99 -99

-100 After shuffling

99 100

-100 -99

Maximum element: 100 Minimum element:-100

The out put is straight forward & simple. All the method names used in this

program define their task.

The Vector class The Vector class is much similar to that of ArrayList class used to generate

the dynamic array. Vector class is synchronized. package demo;

import java.util.*;

class X{ int i;

} class Demo {


Vector<X> vect=new Vector<X>();


X a=new X(); a.i=i;

vect.add(a); }

X a=new X(); a.i=100;

vect.addElement(a); for(X x:vect)

System.out.println(x.i); }

}

408

Output: 0

1 2

3 4

100 addElement() method behaves similar to that of add() method. you can see

that Vector is much similar to that of ArrayList. Here you can Iterators to traverse various elemrts present in Vector object


class X{ int i;

}


{ Vector<X> vect=new ArrayList<X>();

for (int j=0;j<5;j++) {

X a=new X(); a.i=j;

vect.add(a); }

Iterator<X> iteR=vect.iterator(); while(iteR.hasNext()){

X a=iteR.next(); System.out.println(a.i);

}

}

Output: 0

1 2

3 4

Vector class & the Enumeration interface

Enumeration interface contains various methods by which you can loop through various elements stored in Vector, just like Iterator. This is a legacy

interface can only be operated on Vector object.

409


class X{

int i; }


{ Vector<X> vect=new Vector<X>();

for(int i=0;i<5;i++)

{ X a=new X();

a.i=i; vect.add(a);

} Enumeration en=vect.elements();

while(en.hasMoreElements()){ X a=(X)en. nextElement();


} }

Output:

0

1 2

3 4

Enumeration is an interface. Vector implements this interface. The element()

method returns the enumerations of elements present in Vector which is stored in „en‟. Then „hasMoreElements()‟ method is invoked by „en‟. This

method returns true until the last element is encountered. Each invocation of „hasMoreElements()‟ method just fore ward the implicit pointer to point to

the next element. The method nextElement() extracts the element that is pointed by the implicit pointer. Its return type is object type; hence proper

type casting is required.

410

The Stack class Stack class extends the Vector class. This class uses the stack data structure

to store various elements. The principle to retrieve the data from stack class is last in first out principle.

package demo;

import java.util.*;

class Demo {


Stack<Byte> s=new Stack<Byte>();

System.out.println("Initially the Stack:"+s); for(int i=0;i<10;i++){

byte b=(byte)i; s.push(b);

System.out.println("Initially the Stack:"+s); }

while(!s.empty()){ System.out.println("pooped:"+s.pop());

System.out.println(s); }

} }

Output:

Initially the Stack:[] Initially the Stack:[0]

Initially the Stack:[0, 1] Initially the Stack:[0, 1, 2]

Initially the Stack:[0, 1, 2, 3] Initially the Stack:[0, 1, 2, 3, 4]

Initially the Stack:[0, 1, 2, 3, 4, 5] Initially the Stack:[0, 1, 2, 3, 4, 5, 6]

Initially the Stack:[0, 1, 2, 3, 4, 5, 6, 7] Initially the Stack:[0, 1, 2, 3, 4, 5, 6, 7, 8]

Initially the Stack:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] pooped: 9

[0, 1, 2, 3, 4, 5, 6, 7, 8]

411

pooped: 8

[0, 1, 2, 3, 4, 5, 6, 7] pooped: 7

[0, 1, 2, 3, 4, 5, 6] pooped: 6

[0, 1, 2, 3, 4, 5] pooped: 5

[0, 1, 2, 3, 4] pooped: 4

[0, 1, 2, 3] pooped: 3

[0, 1, 2] pooped: 2

[0, 1] pooped: 1

[0]

pooped: 0 []

push() method pushes a new element in to the stack & increases the stack size by 1. pop() method pops the last element present in the stack &

decreases the capacity of the stack by 1. Output clearly shows the performance of these two methods.

Hashtable

Hashtable is another powerful feature of Collection Frame Work. This class implements the hash table data structure to store the element with in the

hash table object. Actually objects are not stored in fact their reference is

stored. Hashtable class is much similar to that of HashMap class but, Hashtable is synchronized. Hashtable implements the Dictionary. Lets have a

program for the implementation of Hashtable.


class K { int key;

} class V{

int data; }

class Demo {

412

public static void main (String arg[])

{ Hashtable<K,V>hashT=new Hashtable<K,V>();

K keyArr[]=new K[5]; for(int i=0;i<5;i++)

{ K key1=new K();

key1.key=i; keyArr[i]=key1;


hashT.put(key1,val); }

for(int i=0;i<5;i++){ V a=hashT.get(keyArr[i]);

System.out.println(a.data);

} }

} Output:

5 6

7 8

9 See the Hashtable behaves similar to that of Hashmap.

Important Methods Of Collection Frame work and their Descriptions

boolean add(Object cls):- This method adds the given object to the existing collection. If

the addition of the object is successful, then this method returns true. But, if the object is already there inside the collection, then this method

returns false. This method invoked by the collection object to which the addition of element has to be performed.

boolean addAll(Object cls):- This method is use to add all elements of the Collection which is

passed as argument to the existing collection. This method returns true when the elements are added successfully. Otherwise, it returns

false.

413

void clear( ):-

This method is used to erase all the items from the collection object through which it is invoked.

boolean contains(Object cls) :- This method is used to confirm whether the given object cls is

present inside the current collection or not. If it is present, then the method returns true, else it returns false.

boolean containsAll(Collection cls):- This method is used to check whether the provided Collection

elements are contained in the current Collection. If the elements are found, then the method returns true. Otherwise it returns false.

boolean equals(Objecct cls):- This method checks whether the object a and the current

collection are equal and returns true ar false appropriately.int hashCode( )Returns the hash code of the current collectionboolean

isEmpty( )Checks whether the current Collection is emptyIterator

iterator( )Returns an iterator for the current collectionboolean remove(Oblect a) Removes an instance of the object a from the

current collection. If successful, it returns true, else it returns false. boolean removeAll ( Collection cn):-

This method is used to erase all the items that are present in the provided Collection cn from the existing collection. If successful, it

returns true, else it returns false. boolean retainAll ( Collection cn):-

This method is used to retain all the items of the Collection cn in the current Collection and removes all the other elements from it.

int size( ):- This method returns the number of elements of the current

collection Object[] toArray() :-

This method returns a copy of all the elements of the current

collection to an Object array. Object[] toArray(Object oa[]):-

This method returns a copy of only those elements of the current collection where the type of the elements will match to that of

the object array oa, to an object array.

414

Conclusion:

Collection Frame Work is a powerful addition to the java language. This

frame work provides various data structures to store & retrieve the data. It‟s up to the programmer to implement the desired data structure according to

the situation. By the introduction of generics in java, most of the constructors, methods are reengineered. It has enhanced scope & efficiency

of Collection Frame Work because of generic implements the type-safety principle. In most of the programs I have used generic constructors &

methods available. Most of the fundamental classes their most frequently used methods are discussed here. Apart from them a rich library of methods

is available in Collection Frame Work. After having these fundamental ideas, your navigation through other methods will be bread & butter for you.

415

Chapter-24

java.util package part II

StringTokenizer

Parsing is quite familiar term in Compiler Design. What exactly

meant by parsing? When you write a program in any high-level language, say java, it is the task of the compiler to convert the source to some

intermediate language like byte code or directly to machine readable language. During this process first compiler checks the syntactical

correctness of the program. This checking is done by dividing the text entered by the programmer in to number substrings according to some

parsing protocol or rule & this is what we call parsing. Java provides the StringTokenizer class to divide the entered text in to number of sub-string or

tokens. StringTokenizer implements the Enumeration interface for which we

can traverse through various sub-strings present in the entered text.


class Demo { static String str1="Past, Present & future is nothing special, they are

just Clock Time!!"; public static void main(String arg[])

{ StringTokenizer sTokenizer=new StringTokenizer(str1,",");

while(sTokenizer.hasMoreTokens()) {

String keyused = sTokenizer.nextToken();

System.out.println(keyused ); }

}

} Output:

Past Present & future is nothing special

they are just Clock Time!!

sTokenizer is a object of StringTokenizer class. see the constructor of the

StringTokenizer class it takes two argument. 1st argument is the string

416

meant for parsing. The 2nd argument is the string according to which the 1st

argument has to be divided in to number of sub-strings. Methods and their Description

int countTokens( ):- This method determines the number of tokens left to be parsed and

returns the result. boolean hasMoreElements ( ):-

This method returns true if one or more tokens remain in the string and returns false if there are none.

boolean hasMoreTokens ( ):- This method returns true if one or more tokens remain in the string

and returns false if there are none. Object nextElement( ):-

This method returns the next token as an Object. String nextToken (String delimiters):-

This method returns the next token as a String and sets the delimiters

of the string.

StringTokenizer class provides another two constructors. They are

1. StringTokenizer (String string) 2. StringTokenizer (String string, String delimiters, boolean delim)

Lets have another program

package demo;

import java.util.*;

class Demo {

static String str1="Past, Present & future is nothing special, they are


{ StringTokenizer sTokenizer=new StringTokenizer(str1);

String arr[]={",","&","is",","}; int i=0;

while(i<4) {

String keyused = sTokenizer.nextToken(arr[i]); System.out.println(keyused );

i++; }

}

417

}

Output: Past

, Present & future

is nothing special The output here is quite simple & straight forward.

BitSet

Java provides the BitSet class to store the bit values. The array created by BitSet class is dynamic in nature i.e. the array can grows & shrinks

according to the given input. The constructors available in BitSet class are:

1:BitSet( ) 2:BitSet(int capacity) this constructor is used to initial capacity of the BitSet

class object. package demo;

import java.util.*;

class Demo { static String str1="Past, Present & future is nothing special, they are


{ BitSet bSet1=new BitSet(32);

BitSet bSet2=new BitSet(32); for(int i=1;i<=32;i++)

{

if(i%2==0) bSet1.set(i);

if(i%3==0) bSet2.set(i);

} System.out.println(bSet1);

System.out.println(bSet2); //Anding of Bits

bSet2.and(bSet1); System.out.println("After ANDING:"+bSet2);

// The OR operation bSet1.or(bSet2);

System.out.println("After OR:"+bSet1);

418

//XOR operation

bSet2.xor(bSet1); System.out.println("After XOR:"+bSet2);

}

} Output:

{2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32} {3, 6, 9, 12, 15, 18, 21, 24, 27, 30}

After ANDING:{6, 12, 18, 24, 30} After OR:{2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32}

After XOR:{2, 4, 8, 10, 14, 16, 20, 22, 26, 28, 32} set() method sets the particular bit on for the BitSet object through which it

is invoked. For example when this statement if(i%2==0) bSet1.set(i); is encountered, 2nd bit, 4th bit, 6th bit, 8th bit & so on of bSet1 is turned on. The

and() method performs the „and‟ operation & the result is stored in the

invoking object bSet2.

The Observable class & the Observer interface

The Observable class & the Observer interface is closely entangled with each

other. Seldom will you ever find a programmer using only one of the classes to develop an application in java. Java provides a unique tool through these

class & interface to keep track of the changes that happens to various objects during the course of execution of the program.

The class which is going to keep track of the changes has to

implement Observer interface & the class which under the focus must implements the Observable interface. A program will fix the ideas


class X implements Observer{ public void update(Observable obs,Object obj)

{ System.out.print("Object of Y is changed:");

}

}

class Y extends Observable {

419

int i;

void fun() {

i++; this.setChanged();

notifyObservers(this); try{

Thread.sleep(100); }catch(InterruptedException e){}

show(); }

void show()

{ System.out.println(i);

}

}

class Demo {

public static void main(String arg[]) {

Y a=new Y(); X b=new X();

a.addObserver(b); for(int i=0;i<10;i++)

{ a.fun();

} }

}

Output:

Object of Y is changed:1 Object of Y is changed:2





420

class X implements Observer interface. This tells to JVM that the object of X

will behave as observer. Class Y extends the Observable interface that means changes made to the object of Y is going to be monitored. Now have

a look at class Y. It has an instance variable i. inside main method fun method is invoked by the object of Y. fun method manipulates the object a

by performing i++. The statement a.addObserver(b); registers the object b as observer to observe the changes made in object a. Now in side fun

method I have invoked the setChanged() method. One thing the observer object & the object to be observed runs in different threads. The

setChanged() method made the observer thread in ready state. If you do not invoke this method then observer thread is not going to be executed,

because for a thread to run 1st it must go to ready state. The setChanged() method has to be invoked by the object which is to be observed. The

notifyObservers(this) method informs the observer when the object is

manipulated. This method actually implicitly invoke the update() method & sends the object „a‟ to update() method implicitly. Now since the observer &

the object to be observed runs in different threads therefore the context switch is required to transfer the control to observer. This is done by the

sleep() method. Once the control is transferred, the change is monitored & the message inside the System.out.println() is dispalyed.


class X implements Observer{ public void update(Observable obs,Object obj)

{

System.out.println("Object of Y is changed:"+(Integer)obj); }

} class Y extends Observable {

Integer i ;

void fun() {


notifyObservers(this.i);

421

try{

Thread.sleep(100); }catch(InterruptedException e){}

}

}

class Demo {


Y a=new Y(); a.i=new Integer("0");

X b=new X();

a.addObserver(b); for(int i=0;i<10;i++)

{ a.fun();

} }

}

Output: Object of Y is changed:1



Object of Y is changed:6



An object having multiple observers

package demo;

import java.util.*;

class X implements Observer{

public void update(Observable obs,Object obj)

422

{


}


Integer i ;

void fun() {


notifyObservers(this.i); try{

Thread.sleep(100);

}catch(InterruptedException e){}

}

}

class Demo { public static void main(String arg[])

{ Y a=new Y();

a.i=new Integer("0"); Y c=new Y();

c.i=new Integer("100");

X b=new X(); a.addObserver(b);

c.addObserver(b); for(int i=0;i<10;i++)

{ a.fun();

c.fun(); }

} }

Output:


423












Two Objects monitored two different Observers


class X implements Observer{

public void update(Observable obs,Object obj) {


} class Z implements Observer{

public void update(Observable obs,Object obj) {


}


424

Integer i ;

void fun()

{ i++;

this.setChanged(); notifyObservers(this.i);



}

}

class Demo {


Y a=new Y(); a.i=new Integer("0");

Y c=new Y(); c.i=new Integer("100");

X b=new X(); Z d=new Z();

a.addObserver(b); c.addObserver(d);

for(int i=0;i<10;i++) {

a.fun();

c.fun(); }

} }

Output:





425








Task Scheduling

Task scheduling is another excellent feature provided by this premier programming language. You can schedule your job at any future time & you

can set the time interval after which you want the task to be repeated. All these things can be achieved by the Timer & TimerTask method. 1st lets

have an example then I will explain all in detail


class X extends TimerTask{ public void run()

{

System.out.println("Hello World!!!"); }

}

class Demo { public static void main(String arg[])

{ X a=new X();

Timer tm=new Timer(); tm.scheduleAtFixedRate(a, 1000, 250);



426

tm.cancel();

} }

Output: Hello World!!!

Hello World!!! Hello World!!!





Hello World!!!



Hello World!!!

Here class X extends the TimerTask class. TimerTask class implements the Runnable interface due to which run() method is available there. Codes

inside the run method is the task to be executed. Inside main method the task object is created by the statement X a=new X();.You required timer to

set the time & the frequency of the task. Timer or you can say scheduler is created by Timer tm=new Timer(); this statement. Next scheduler invokes

the scheduleAtFixedRate method. this method takes the task object a, time at which the task is going to be started & the time interval after which the

task is going to be repeated. Task executed as separate thread. So to

transfer the control context switch is required, which is done by the sleep() method. As long as main thread is sleeping the task is done at a particular

interval of time. When the main thread resumes tm.cancel() is invoked to terminate the task.

Conclusion:

Apart from the discussed classes & interfaces util package contains a huge number of collections of classes. Almost all of them are simple can easily be

understood by the reader. Something like Date class, Calendar class, TimeZone class is there to play with date, month & year. My aim is to made

reader comfortable with the things like observer & task scheduling. These classes I have discussed are not part of Collection Frame Work.

427

Chapter-25

java.applet package

Applet

Generally java programs can be classified into two groups namely applications and applets.

Unlike applets, Java applications do not require a browser to run. They can be created like any

normal programming language programs. Applets are executed in the browser. Applet is a class

file that displays graphics application in the web browser and you can embed applet codes in

the web pages by HTML tags. Briefly we can say that applet is a java byte code embedded in a

HTML page. The program structure of applets differs from the other java applications we have

done till now. Applets have made java a web enabled languase.

Definition

An applet is a dynamic and interactive program that can run inside a Web page displayed by a

java-capable browser such as HotJava Browser, Internet Explorer browser is a World Wide Web

Browser used to view Web pages. Applet is a class present in java.applet package.

A special HTML tag is embedded in the applet to make it run on the web browser .

appletviewer application is used to run and check the applets , it is present in the jdk. Applets

has added advantages such as frame, event-handing facility, graphics context and surrounding

user interfaces.

Java applets have some restrictions to ensure full security and to make them virus free . Some

of these are wriiten below.

Applets have no read or write permisson to the file system.

Applets can communicate with the server in which they were stored originally but not with the others.

Applets can’t execute any programs on the system.

Life cycle of Applet:

Applets don’t have any main method or constructors.so we can compile a applet code but we

cannot run it.now let’s see how a applet gets executed what are the different states of a applet.

428

stop()

start()

paint()

Newborn state.

Running state (display).

Idle or stop state.

Dead state or Destroyed state.

Newborn state

Running state Idle state

Dead state

start()

destroy()

init()

Begin or entering

(By typing URL,

address).

Exit or End

(Transition diagram of applet life cycle)

429

Every java Applet when loaded undergoes a series of state changes. There are four

Applet state.

Whenever the init() method is called the applet is created or we can say that it gets life.

When the start() method is called the execution of the applet gets started.

All the changes in the applet are reflected by the paint method().

Whenever we call the stop() method the applet goes to ideal state that means we have to

call the start method again to bring the applet to the ready state.

The destroy() method is called to end the execution of the applet or to exit the applet.

There are many methods in the applet class but the methods init() , start(), paint(), stop() and

destroy() constitutes the life cycle of applet.

Public void init() Method

When the applet starts first the init() method is called and is called only once in the entire life

time of the applet. Initialization of all the variables, creation of objects and setting of the

parameters can be done in this method. Applet has no constructor but init () behaves as a

constructor.

public void start() Method

This method is executed after the init () method. whenever a user moves from the applet to

some other application and again comes back to the applet after some time then the applet

resumes execution from start() method .

The stop() Method

The stop () method is used to halt the running of an applet. When an applet is running in a Java

enabled browser, the stop () method is called when you move from to another Web page and

when you comes back, the start() method is called to resume the applet. You can call the stop()

and start() method repeatedly if you want to do it.

The destroy() Method

This method is called whenever we want to free the memory occupied by the variables and

objects initialized in the applet. Any clean up activity that needs to be performed can be done in

this method. we can free the resources held by the applet using the destroy() method. stop()

method is always called before the destroy() method is called. The destroy() method is different

from the finalize() method. The destroy() method applies only to applets where as the finalize()

method is generally used to clean up a single object.

430

The paint() Method

Whenever it is needed to redrawn the output of the applet paint() method is called. This

method helps in drawing, writing and creating a colored background or an image onto the

applet. It takes an argument, which is an instance of the Graphics class. To use this method, it is

necessary to import the Graphics class as import java.awt.Graphics.

The repaint() Method

This method is used in case an applet is to be repainted. The repaint() method calls the update(

) method to clear the screen of an existing content. The update( ) method in turn calls the

paint( ) method which draws the contents of the current frame. repaint() can be called in future

by mentioning time interval in millisecond. If the time expires before update() can be called,

update is not summoned.

void repaint( int x_co, int y_co, int WIDTH, int HEIGHT)

repaint() takes four arguments to update only a part of the screen. The first to arguments are

the x and y coordinates, the next two arguments are the width and the height of the image.

This helps in faster updating of the screen.there are also other versions available they are given

below.

void repaint(long Delay)

void repaint(long Delay, int x, int y, int width, int height)

in the above syntax Delay specifies the time in milliseconds that it will wait before update( ) is

called.

The other methods available in Applet class are defined below

431

Method Describe

AppletContext getAppletContext() Determines the applet context and returns it.

String getAppletInfo() Gets the information about the Applet.

AudioClip getAudioClip(URL u) Collects the AudioClip object from the location

specified by the url.

AudioClip getAudioClip(URL u, String name) Collects the AudioClip object from the location

specified by the url having the name specified.

URL getCodeBase() Collects the base URL

URL getDocumentBase() Collects the document URL

Image getImage(URL u) Collects an Image that can painted in the

screen

Image getImage(URL u,String name) Collects an Image that can painted in the

screen

String getParameter(String name) Gets the value of the name parameter in the

HTML tag.

boolean isActive() Determines whether an applet is active or not.

void play(URL u) Plays the audio clip in the background of

applet.

void play(URL u, String name) Plays the audio clip in the background of

applet.

void resize(int width,int height) Resize the applet

void showStatus(String msg) Requests the String to be displayed in the

status window of Applet

HTML Tags

Some of the HTML tags used in the .html file are discussed below.

432

Applet Tags

The <applet> tag is used to start the applet from inside the HTML document as well as from the

appletviewer. Each <applet> tag is executed in separate windows by the appletviewer while the

Java capable browser is capable of executing numerous applets inside a single web page. This

code instructs the browser or the appletviewer to load the compiled Java applet, namely the

.class file. The size of display of the applet is initialized using the WIDTH and HEIGHT tags. To

indicate the end of the applet, < / applet> tag is used. It is essential to end the applet using this

tag, otherwise it will not be executed. Comment lins can be inserted below, above or at the side

of the applet within the HTML file. This is done by including those lines within the < applet >

and < / applet > tags.

CODE and CODEBASE Tags

CODE is a necessary attribute that gives the name of the file that contains the applet’s compiled

class. It assumes that both the .java file and the .html file are in the same directory.

If the .html file and the .class fill are stored in different directories, it is essential to mention it

specifically. To do this, the CODEBASE tag is used. The CODEBASE tag contains the pathname

where the .class file is stored. For example, if the .class file of an applet named Text Applet is

stored in the directory /test, the HTML file code will appear as indicated below:

<APPLET CODE = “TestApplet.class” CODEBASE = “ / test” WIDTH=400 HEIGHT=300></APPLET>

Passing Parameters to an Applet

We have discussed the passing of parameters to a Java application. To pass parameters to an

applet, two things are required – a special parameter tag in the HTML file and the code in the

applet to parse those parameters.

The special parameter tag in the HTML file is <PARAM>. This has two attributes namely NAME

and VALUE. The init () method of the applet, contains a method called getparameter ().

This method takes one argument – the string representing the name of the parameter being

looked for and returns a string containing the corresponding value of that promoter. If this

method is required to return types other than strings, it has to be converted explicitly.

The different methods we use to set the graphical enviorment

433

applets use the classes & methods of AWT to perform it’s input and output operations. To

display the output in the applet we use the drawstring() method present in the Graphics class .

It’s general form is :

void drawString(String msg, int x_co, int y_co)

msg holds the string to be written on the aplet screen starting from the coordinates specified

by x_cor and y_cor. In a Java window, the

upper-left corner is location 0,0.

setBackground( ) method is used to set the background color of the applet.

setForeground( ) method is used to set the foreground color of the applet means the color of

the texts to be written.

The above methods are defined in Component class , and their general forms are:

void setBackground(Color Color)

void setForeground(Color Color)

Color specifies the new color. The Color class defines the below constants that can be used to

specify colors:

Color.black Color.magenta

Color.blue Color.orange

Color.cyan Color.pink

Color.darkGray Color.red

Color.gray Color.white

Color.green Color.yellow

Color.lightGray

The below example sets the background color to pink and the text color to magneta:

setBackground(Color.pink);

434

setForeground(Color.magneta);

Let’s create our first applet

import java.awt.*;

import java.applet.*;

/*

<applet code="SimpleBanner" width=750 height=500>

</applet>

*/

public class abc extends Applet {

String mesg = " WELCOME TO APPLET";

public void init() {

setBackground(Color.cyan);

setForeground(Color.red);

}

public void start() {

mesg = mesg+" MISS SAMITA";

}

public void stop() {

}

public void paint(Graphics g1) {

g1.drawString(mesg, 50, 30);

}

}

Output :

435

Let’s see what are the steps to create a applet from the above example.

First we have to import both the packages java.applet and java.awt , it’s a must. After that

we have defined the html tag which is required to makes the applet to run in the web

browser. After that we defined the init() method , then the start() method and at last the

paint method. here we don’t need the stop() or destroy() method so we have not defined

them.

now from the above example we can see that first the init() method is called and the

background color and foreground color is set using the setBackground(Color.cyan) and

setForeground(Color.red) method. after that start method was called in which the msg

variables content is modified then the paint method is called in which the we have written the

code g.drawString(msg, 50, 30) to print the output on the applet.

Let’s see another example which will help to make clear the concepts

Example-2 helps in understanding the usage of passing parameters to an applet.

Example-2

import java.applet.Applet;

import java .awt .*;

public class Second extends Applet

{

Font f = new Font ("TimesRoman", Font.BOLD, 40);

436

String name;

public void init()

{

name = getParameter ("name") ;

if (name == null)

{

name = "Java" ;

name = "Have a nice day " + name ;

}

}

public void paint(Graphics g1)

{

g1.setFont (f);

g1.setColor (Color.blue);

g1.drawString (name, 50, 50);

}

}

/*<applet code="Second.class" width=200 height=200 align=TOP>

<param name="name" value="Sai">

</applet>*/

437

An instance of the Font class f is declared. This object has been initialized to contain

“TimesRoman” as font name, font size as 40 and font style as BOLD. The init () method declared

in line number 7, contains the getParameter () method, which accepts the name (a string) as its

parameter. The paint () method of the Component class is overridden to execute the paint ()

method in the class. This method contains the drawString () method apart form, two methods

namely setFont () and setColor (). These two methods are used to set the desired font and color

respectively.

Passing parameters to applets

We can set the parameter as we have shown above and to retrieve the value we have to use

the getParameter() method. which take the name of the parameter and returns the value

stored at the parameter.

import java.awt.*;


/*

<applet code="SimpleBanner" width=750 height=500>

<param name="param1" value ="SAI">

</applet>

*/

public class abc extends Applet {

String mesg ;

public void init() {

438

setBackground(Color.white);

setForeground(Color.red);

}

public void start() {

mesg = getParameter("param1");

}

public void paint(Graphics g1) {

g1.drawString(mesg, 50, 30);

}

}

Output :

HOW TO PLAY A Audio Clip

439

Let’s first see the example below . after that i will explain how it is done.


import java.awt.*;

public class player extends Applet {

AudioClip a1;

public void init()

{

a1=getAudioClip(getCodeBase(),"sai.au");

}

public void start()

{

a1.play();

}


{

g1.drawString(“playing music”,50,30);

}

}

/*<applet code="Play" width=200 height=200>

</applet>*/

440

Output :

This program will open a applet and the music file named sai.au will be played.

The getAudioclip() method returns the URL of the music file specified as it’s parameter value.

Then we call the play method to play the music file.

We can only play the *.au format music files.and the music file should reside in the same

directory in which the java file is present.

Below given is given a designer applet to play and stop the music files

import java.awt.*;

import java.awt.event.*;

441


public class Play extends Applet implements ActionListener

{

AudioClip a1;

Button b1,b2;

public void init()

{

b1=new Button("Start");

b2=new Button("Stop");

a1=getAudioClip(getCodeBase(),"sai.au");

b1.addActionListener(this);


add(b1);

add(b2);

}

public void actionPerformed(ActionEvent ae)

{

if(ae.getSource()==b1)

{

a1.play();

}else{

a1.stop();

}

442

}


{

g1.setColor(Color.red);

g1.setFont(new Font("Arial",Font.BOLD,40));

g1.drawString("This Is Music World",50,70);

}

}

/*<applet code="Play" width=200 height=200>

</applet>*/

AppletContext

443

AppletContext is an interface which is implemented by an object that represents the applets

environment . To use it we have to first create a object of AppletContext using

getAppletContext() method.it is shown below

Example

AppletContext context= getAppletContext( );

In AppletContext some interesting methods are defined like the getApplet() method ,it returns

the name of the applet and getApplets( ) method which returns all the applets in the document

base.

getApplet( )

getApplets( )

in AppletContext another method showDocument( ) is also defined which either takes a URL or

a URL and the file name in form of a string. it creates an HTML page in the web browser which

is showing the applet. It could be useful with HTML frames where the applet should reside in a

frame and the new HTML pages should be shown in another frame.

showDocument( )

showStatus( ) method shows the string passed to it as parameter on the status bar at the

button of the web browser. The example below shows the use of showDocument( ) and

showStatus( ) methods .

AppletContext Code Sample

444


import java.awt.*;

import java.net.*;

// <applet code="applet1.class" width=400 height=100></applet>

public class applet1 extends Applet{

public void init(){

try{

URL url1=new URL("http://wallpaper.net/pkomisar/Flowere.html");

getAppletContext( ).showDocument(url1);

}catch(MalformedURLException me){}

}

public void paint( Graphics g1){

g1.setFont(new Font("Monospaced", Font.BOLD, 22));

g1.drawString(" Hello World", 55, 65 );

getAppletContext( ).showStatus( "Puts the message in status bar" );

}

}

445

Now in the above program we get the current appletcontext using getAppletContext() method

then using the showDocument() method we just transferred the control to another html file

which is passed to it as parameter .the showStatus() method displays the string passed to it as

parameter at the buttom of the applet window .

Note :

We can use console output in applet like System.out.println() , the string passed to it will not

get displayed on the screen rather it will get displayed in the console. it is used generally for

debugging purpose otherwise use of these methods are discouraged.

Advantages

A Java applet has the following advantages:

An applet can work properly on "all" the versions of Java installed , excluding the latest plug-in version .

All most all web browsers support applet A user can permit it to have full access to the machine on which it is running. it can improve with use: after a first applet is run, the JVM is already running and starts

quickly, benefitting regular users of Java but the JVM will need to restart each time the browser starts fresh.

When we compare it’s speed of execution it executes slower than c++ codes but faster than JavaScript

Disadvantages

A Java applet has the following disadvantages:

Sometimes the Java plug-in is required and it isn't available on every web browsers by default.

Intially the loading time for a applet is noticeable but you will notice it further

http://en.wikipedia.org/wiki/Plug-in

http://en.wikipedia.org/wiki/Plug-in

http://en.wikipedia.org/wiki/Web_browser

446

Conclusion :

This is all about applet. Actually now you can observe that without applet java cannot get the

honour of a web enabled languase. The awt package present in java is a important package

which is needed to a devlop a sophisticated applet. We will discuss all about awt package in

the coming chapters.

447

Chapter-26

The java.awt package

Java facilitates the development of Graphical User Interface components

with the help of java.awt package. The awt stands for abstract window

toolkit.

The awt is an API, i.e. application programming interface. It should be

mentioned here, that an API provides libraries, which contains several

classes, data-structures and protocols for development of different

applications.

The java.awt package belongs to the Java Foundation Classes, i.e. JFC.

Inside the java.awt package, we can avail various GUI components, the

model for the event handling techniques, different tools for graphics and

images, and the LayoutManager. Also, it facilitates the mechanism for data

transfer by cut and paste process through clipboards.

The JavaBeans architecture can be supported by the AWT. The AWT

component can be treated as simple beans. The java.awt package provides

various classes for the development of user interfaces and for painting

graphics and images.

There are various subsystems under the java.awt package which enable the

development of Graphical User Interface (GUI) components. The subsystems

are:

Graphics primitives, for drawing and rendering lines and images.

Components, which include Label, Button and TextField.

Containers, which include Frame, Panel and Dialog. LayoutManager, to control the displaying in a portable fashion.

Event system, to respond to interactions between the Component and Container in the application.

The Graphics Class

Graphics is an abstract class present inside the java.awt package. The

signature of this class is:

public abstract class java.awt.Graphics extends

java.lang.Object

448

This class provides the declaration of various methods which are used for the

purpose of drawing lines, rectangles and several other shapes

For drawing different figures, the knowledge about the co-ordinate system is

required. The co-ordinate system provides the scheme for the identification

of all possible points on the screen.

For example, the co-ordinate of the upper left corner of the screen is (0, 0).

A coordinate pair is formed with a combination of x coordinate(i.e.,

horizontal coordinate) and y coordinate (i.e., vertical coordinate). The x

coordinate denotes the distance moving right from upper left corner. All

coordinates are expressed in integers.

Graphics Context and Graphics Object

Before drawing any shape on the screen, we need an environment that

enables the process of drawing. We can get that environment by the help of

GraphicsContext.

Also, with the help of the GraphicsContext only, we cannot perform the

operation of drawing. To achieve this we need the help of a graphics object.

The graphics object manages the graphics context, i.e. the graphics object

controls the process of drawing the information on the screen.

As Graphics class is an abstract class, it cannot be instantiated.But a type of

Graphics class (i.e., an object of graphics class) can be defined, by the help

of the Component class present inside the java.awt package.

The Graphics class makes use of three important methods of

Component class for the purpose of creating erasing and updating the

graphics. These methods are:

public void paint(Graphics gph)

This method is used at the time of creation of graphics.

public void repaint()

This method helps to erase the graphics.

public void update(Graphics gph)

449

By this method, we can update the graphics.

We will go in details about the aforesaid methods in the Component class.

Java.awt contains many methods to handle different operations related to graphics. Some of these methods are which are required for the basic

operations related to graphics are give below:

public void drawLine(int c1, int d1, int c2, int d2):

It is used to draw a line, from the starting co-ordinate (c1,

d1) to the ending co-ordinate (c2, d2).

public void drawRect(int c1,int d1,int c2,int d2)

It is used to draw a rectangle (the out lines only). Here

(c1, d1) is the coordinate from where the drawing of rectangle starts. C2

and d2 represents the width and height respectively.

public void fillRect(int c1, int d1, int c2, int d2)

This method is also used to draw a rectangle with its

body shaded. Here also, (c1,d1) represents the starting point from where the drawing of the rectangle starts and c2 and d2 represents

the width and height respectively.

public void drawOval(int c1, int d1, int c2, int d2)

To draw the outlines of an oval, this method of the Graphics class is used.

public void fillOval(int c1, int d1, int c2, int d2)

With the help of this method, a filled oval can be drawn

on the screen. (c1,d1) denotes the starting coordinate from where the drawing starts. c2 and d2 represents the width and height

respectively.

450

Public void drawRoundRect(int c1,int d1 ,int c2 ,int

d2 ,int c3 ,int d3)

It is used to draw a the outlines of a rectangle, whose corners are in rounded format.

Public void drawRoundRect(int c1,int d1 ,int c2 ,int d2 ,int c3 ,int d3)

It is used to draw a the outlines of a rectangle, whose corners are

in rounded format. public void fillRoundRect(int c1, int d1, int c2, int d2, int

c3, int d3)

It is used to draw a filled rectangle with its corners in rounded

shape.

public void drawstring(String message, int c1, int c2)

This method simply draws the specified string on the screen

starting from the coordinate (c1, c2).

public void drawPolygon(int c1[], int c2[], int pnt)

This method is used to draw a polygon on the screen. It takes

two arrays and a point of integer type as the argument.

public void fillPolygon(int c1[], int c2[], int pnt)

This method does the same operation of drawing a polygon, but

unlike drawPolygon, this polygon is filled with the current color.

public void drawArc(int c1, int d1,int c2,int

d2, int c3, int d3)

The job of this method is to draw an arc on the screen, which

covers a rectangle that would be formed according to the

parameters specified.

public void fillArc(int c1, int d1,int c2,int

d2, int c3, int d3)

451

This method does the same operation as of the drawArc, but

this time the arc will be filled with the current color.

Public void setColor(java.awt.Color RED)

This method takes the predefined color constants of the Color class

as the parameter and it is used to set the color of the object to be

drawn.

Example:-

import java.awt.*;


public class A extends Applet

{

public void init()

{

System.out.println("Applet is initialized");

}

public void paint(Graphics g)

{

g.drawLine(40,60,100,120);

g.setColor(Color.red);

g.fillOval(60,80,100,100);

g.setColor(Color.green);

g.fillRect(20,20,50,50);

g.setColor(Color.magenta);

g.fillRoundRect(120,120,80,80,10,12);

g.setColor(Color.cyan);

g.fillArc(150,150,98,98,40,60);

int x[]={10,20,90,100,34};

int y[]={17,90,25,67,27};

g.setColor(Color.cyan);

g.fillPolygon(x,y,5);

g.setColor(Color.blue);

452

g.setFont(new

Font("VERDANA",Font.BOLD+Font.ITALIC,25));

g.drawString("Hello GoodMorning",105,35);

}

}

/*<applet code="A.class" width=400 height=400>

</applet>*/

Output:-

Color class

Color is a predefined class present in the java.awt package. This class

facilitates the user to make use of different colors provided by this class to

color the graphics, set the background and foreground color of the

component.

The signature of this class is:

453

public class java.awt.Color extends java.lanag.Object implements

java.awt.Paint, java.io.Serializable

13 predefined colors are provided by this class. Each color is a constant as

specified by this class. These are:

public static final java.awt.Color white (or WHITE)

public static final java.awt.Color lightGray (or LIGHT_GRAY)

public static final java.awt.Color gray (or GRAY) public static final java.awt.Color darkGray (or

DARK_GRAY) public static final java.awt.Color black (or BLACK)

public static final java.awt.Color red (or RED) public static final java.awt.Color pink (or PINK)

public static final java.awt.Color orange (or ORANGE) public static final java.awt.Color yellow (or YELLOW)

public static final java.awt.Color green (or GREEN) public static final java.awt.Color magenta (or MAGENTA)

public static final java.awt.Color cyan (or CYAN)

public static final java.awt.Color blue (or BLUE)

we can also get different colors apart from using the above said color

constants , by the help of the Constructor of the Color class, which takes

three integer values within the range 0 to 255 values. These three integer

values are collectively known as RGB (i.e. red-green-blue values.):

Color(int red, int green, int blue )

For example,

We can get the color black by : new Color(0,0,0)

We can get the color red by : new Color(255,0,0)

We can get the color white by : new Color(255,255,255)

There are also some other constructors of the Color class. These are:

Color(int)

Color(int,boolean)

454

Color(float,float,float)

This constructor also takes three values in Red-Green-Blue

format. But the values are of float type and the value ranges

between 0.0 and 1.0.

Color(java.awt.color.ColorSpace,float[],float)

The Color class is used by the methods of the Component class for setting

the background and foreground colors.

The mathods of Component class which use the Color class are

public void setBackground(java.awt.Color)

public void setForeground(java.awt.Color)

The Color class is also used by the Graphics class to set the color of the

object to be drawn. The method is

public void setColor(java.awt.Color)

Methods of Color class:

public Color brighter()

It is used to get the brighter version of the current color.

public Color darker() It is used to get the darker version of the current color.

int getAlpha()

Every color in java has an alpha value which ranges from 0 to

255. This method helps to retrieve the alpha value of the current

color of the object.

Font class

The java.awt package contains Font class which provides the mechanism for

setting the attributes of the font used in the Graphics class or in the

Component class. The signature of this class is :

455

public class java.awt.Font extends java.lang.Object implements

java.io.Serializable

If the programmer does not want to use the Font class to manually handle

the font, then the operating system, by default, provides support for the

font. But if we want to manually adjust the font, then we have to use the

Font class.

The predefined constants provided by this class are

public static final int PLAIN;

public static final int BOLD;

public static final int ITALIC; public static final int ROMAN_BASELINE;

public static final int CENTER_ BASELINE; public static final int HANGING_ BASELINE;

public static final int TRUETYPE_FONT; public static final int TYPE1_FONT;

Apart from these constants, three other variables are used to set the name,

style and size of the font. These are

protected String name.

protected int style.

protected int size.

There are also four constants to define the layout of the font on the

screen. These are:

public static final int LAYOUT_LEFT_TO_RIGHT public static final int LAYOUT_RIGHT_TO_LEFT

public static final int LAYOUT_NO_START_CONTEXT public static final int LAYOUT_NO_LIMIT_CONTEXT

Constructors of the Font class:

Font(String ftype, int fstyle, int fsize)

The first parameter ftype refers to the name of the font. The availability of

Font varies from platform to platform. We can get the list of font available in

different platform through

String list_of_fonts [] = Toolkit.getDefaultToolkit().getFontList();

456

Here, the second parameter is used to specify the style of the font. This

parameter is a constant defined in the Font class.

The third parameter is used to specify the size of the font.

We can set the font of Graphics class and Component class by the following

method:-

public void setFont(Font fnt)


{

gph.setColor (Color.blue);

Font fnt=new Font(“Serif”,Font.BOLD+Font.ITALIC,20);

gph.setFont(fnt);

}

Out of many methods available in the Font class, one of the most important

methods is:

static Font getFont(String prop)

This method is used to get the font of the text having the system

property as of the property specified by prop. If the property does not

exists, then it returns null.

Image class

The java.awt package contains an abstract class, Image. This class provides

the mechanism to handle the operations that are related to image. The

signature for the Image class is:

public abstract class java.awt.Image extends java.lang.Object

The image class cannot be instantiated. Generally, we use the Image class

to draw an image on the applet.

457

Image class supports only two types of image files:

jpg format (Joint Photographic Expert Group format)

gif format (Graphic Interchange Format )

The Image class also provides some constants which are used to the set the

scale for the image. These are:

public static final int SCALE_DEFAULT

public static final int SCALE_FAST

public static final int SCALE_SMOOTH

public static final int SCALE_REPLICATE

public static final int SCALE_AREA_AVERAGING

We can create an empty image by the help of a predefined method of

Component class. The method is:

public Image createImage(int imgwidth, int imgheight)

Example: Image img1=createImage (200,200);

We can draw an image on the screen, by the help of one predefined method

of Graphics class. The method is:

public void drawImage(Image img, int i, int j, ImageObserver

imob)

We can retrieve the image from a desired location by the help of one

method, which is present in both the Applet and Toolkit class. The method

is:

public Image getImage(URL url)

public Image getImage(URL url, String imgpath)

Example:

public void init()

{

458

Image img1=getImage(getDocumentBase(),”ABCD.jpeg”);

}

Example:-1

import java.awt.*;


public class Image123 extends Applet

{

Image img;

public void init()

{

img=createImage(300,200);

Graphics gph=img.getGraphics();

gph.setColor(Color.orange);

gph.fillRect(150,100,120,120);

gph.setColor(Color.pink);

gph.fillOval(90,100,70,70);

}


{

gph.drawImage(img,25,100,this);

}

}

459

/*<applet code="Image123" width=300 height=300>

</applet>*/

Example-2

import java.awt.*;


public class Image123 extends Applet

{

Image img;

public void init()

{

img=getImage(getDocumentBase(),"CAKE.jpg");

}


{

gph.drawImage(im,30,50,this);

}

460

}


</applet>*/

Component class

The java.awt package provides an abstract class Component which is used

to represent the objects on the screen in a pictorial format. The signature of

this class is:

public abstract class java.awt.Component extends java.lang.Object

implements java.awt.image.ImageObserver,

java.awt.MenuContainer, java.io.Serializable

The Component class has many child classes and they are broadly classified

into two categories:

Visual Component

461

Menu Component

Visual Component

There are 11 classes, which comes in the category of the Visual Component.

These are:

Button

Canvas

Choice

Checkbox

List

Label

FileDialog

Scrollbar

ScrollPane

TextField

TextArea

Menu Component

There are 5 classes, which comes in the category of the Menu Component.

These are:

Menu

MenuBar

MenuItem

CheckboxMenuItem

PopupMenu

Button class

The java.awt package contains a predefined class Button to develop push

buttons, which can generate ActionListener on pushing upon it. The


public class java.awt.Button extends java.awt.Component

implements javax.accessibility.Acceessible

462

A button can be given a label. Upon clicking the button, an instance of the

ActionEvent is sent by the help of the method processEvent(), which

generates the ActionListener.

In order to achieve an action based performance on the button, the

application has to implement the ActionListener interface and then register

the listener, so that it can receive the events generated upon pushing the

button. The listener can be registered by the help of the addActionListener()

method.

Constructos of the Button class:

The Button class constructor is overloaded

Button()

We can create a button with this constructor. But the button

won‟t have any label. Here, the size of the button varies from

one operating system to other.

Button(String l)

With this constructor, a button is created having a label l on it.

Here, the button size depends on the label size.

Methods of Button class:

Out of various methods of the Button class, the commonly used methods

are:

public synchronized void

addActionListener(java.awt.event.ActionListener)

To receive the event generated upon pushing the button, the listener is

registered with the help of this method.

public java.lang.String getActionCommand()

When any event is fired upon pushing the button, the command name

of the event can be retrieved by the method.

public java.lang.String getLabel()

The label of the button can be retrieved by the help of this method.

protacted java.lang.String paramString()

463

The state of a button can be expressed by a parameter string. This

method helps to retrieve this parameter string.

public void setLabel(java.lang.String)

To set the label of an existing button, this method is used. The label

will be set according to the string parameter.

The Canvas class

Canvas refers to a drawing area, where the components can be drawn. The

drawing on the canvas is carried out by the paint() method.

The Constructors of the Canvas Class:

Canvas()

Canvas(java.awt.GraphicConfiguration)

Methods of the Canvas class:

Out of the various methods of the Canvas class, the commonly used ones

are:

public void addNotify()

a peer of the canvas is created with the help of this method.

public void paint(java.awt.Graphics)

a canvas can be repainted with the help of this method.

The Choice class

The java.awt package provides a Choice class by which we can have a popup

menu, and from that menu, we can select only one item and only that

selected item is visible to the user. Also we can have an arrow side to the

item, clicking on which we can avail the list of items. The signature of this

class is:

Public class java.awt.Choice extends java.awt.Component

implements java.awt.ItemSelectable, javax.accessibility.Accessible

The Choice class generates one listener known as ItemListener.

464

The constructor of the choice class is:

Choice()

It help to instantiate the choice class.

Methods of the Choice class:

The Choice class contains various methods. The most commonly used

methods are:

public void add(java.lang.String)

an item of String type can be added to the choice menu by this method.

public void addItem(java.lang.String)

This method is also used to add an item of String type to the choice

menu.

public java.lang.String getItem(int)

This method helps to return the string from the choice menu, at the

specified index.

public int getItemCount()

The total number of items present in the corresponding choice menu can

be retrieved by this method.

Public int getSelectedIndex()

By this method the index of the selected item can be retrieved.

public synchronized java.lang.String getSelectedItem()

With the help of this method the currently selected item can be retrieved

in String format.

Public synchronized java.lang.Objects[] getSelectedObjects()

This method returns an array of Object type having length 1. The array

contains the currently selected items.

public void insert(java.lang.String,int)

465

This method is used to insert the specified item at the specified position.

public void remove(int)

We can delete one item from the choice menu according to the specified

index by this method.

public void remove(java.lang.String)

This method is used to delete one item from the choice menu according

to the specified. If there are more than one item with the same name,

then the first occurrence of the item is deleted.

public void removeAll()

With the help of this method, we can erase all the items from the choice

menu.

public synchronized void select(int)

This method is used to set the selected item to be the item at the

specified position.

Checkbox class

The java.awt package provides a Checkbox class, which is used to

develop checkboxes. A checkbox provides the facility of multiple

selections. The signature of this class is:

public class java.awt.Checkbox extends java.awt.Component

implements java.awt.ItemSelectable,

javax.accessibility.Accesseible

The Checkbox class generates one listener known as ItemListener.

The constructor of Checkbox class

Checkbox()

This constructor develops a checkbox without having any label on it.

Checkbox(java.lang.String)

466

This constructor develops a checkbox with a label on it.

Checkbox(java.lang.String, boolean)

This constructor also develops a checkbox with a label on it. In addition to

it, the state of the checkbox is also specified.

Methods of Checkbox

The Checkbox class provides several methods to manipulate the checkbox.

The commonly used methods are:

public java.lang.String getLabel()

This method returns the name or label of the checkbox.

public boolean getState()

The state of the checkbox in terms of boolean value is returned by this

method.


A label is attached to the checkbox, by this method.

public void setState(boolean)

A state is assigned to the checkbox with the help of this method

We have another class that is related to the Checkbox class, i.e.

CheckboxGroup. This class is used to develop radio buttons. In case of radio

buttons, only a single item can be selected at a time. The signature of this

class is:

public class java.awt.CheckboxGroup extends java.lang.Object

implements java.io.Serializable

To generate radio buttons, we have to pass the object of the CheckboxGroup

class in the constructor of the Checkbox class.

467

For example,

CheckboxGroup cx=new CheckboxGroup();

Checkbox cb=new Checkbox(“Male”, cx, true);

FileDialog class

The java.awt class provides a class known as FileDialog. It is a child class of

Dialog class. The signature of this class is:

public class java.awt.FileDialog extends java.awt.Dialog

This class is to display a dialog box on the screen, so that the user can

choose a file from it. Until the dialog window is closed, rest of the application

goes to a blocked state. The FileDialog is known as a modal dialog.

A FileDialog has two modes:

LOAD mode

SAVE mode

Constructor of FileDialog

FileDialog(Frame)

For the purpose of loading a file, a File Dialog is constructed by this

constructor.

FileDialog(Frame, String)

This constructor also does the same action as of the above. But, here the

dialog window gets a label on it.

FileDialog(Frame, String, int)

With addition to the above action, here the mode for the file is specified,

i.e. either FileDialog.LOAD or FileDialog.SAVE.

Methods of FileDialog

The commonly used methods of the FileDialog class are:

public java.lang.String getFile()

468

This method is used to retrieve the file from the corresponding file dialog.

getFileNameFilter()

It is used to get the filtered file name from the file dialog.

public int getMode()

This method is used to get the mode of the concerned file dialog, i.e

whether LOAD or SAVE.

getDirectory()

It is used to get the directory name of the concerned file dialog

setDirectory(java.lang.String)

The directory name of the concerned file dialog can be set by this method

with the specified name.

public void setFile(java.lang.String)

We can set the specified file for the concerned file dialog by this method.

public void setMode(int)

We can set the specified mode for the concerned file dialog.

Label class

One of the simplest component in the java.awt package is the label. For

setting the label of different GUI objects, this class is used. The signature of

this class is:

public class java.awt.Label extends java.awt.Component implements

javax.accessibility.Accessible

The Label class does not generate any listener.

The constructors of the Label class are:

Label(java.lang.String)

This constructor is used to set the label with the specified name.

Label(java.lang.String, int)

469

This constructor set the label with the specified name and the alignment.

The alignment of the label can have three values which are constants

and provided by this class. These are:

Public static final int LEFT

Public static final int CENTER

Public static final int RIGHT

The methods of Label class

The commonly used methods of the Label class are:

public java.lang.String getText()

This method is used to retrieve the text of the concerned label.

public java.lang.String paramString()

A label can be represented by a parameter string. It is the job of this

method to return this parameter string.

public void setText(java.lang.String)

This method is used to set the text for the concerned label by the

specified string.

List class

The java.awt package provides one class List, which enables the user to

select more than one item. Also this class facilitates to visualize more than

one item at a time. The signature of this class is:

public class java.awt.List extends java.awt.Component implements

java.awt.ItemSelectable, javax.accessibility.Accessible

Constructors of List class

List()

It is used to develop a list of items, and the list can scroll.

List(int)

470

A list of items can be developed with the specified number of visible

line. The list can scroll.

List(int, boolean)

Here the lists with specified number of visible items are generated and

a mode can be set also.

The ActionListener and ItemListener are fired by the List.

Methods of the List class

The commonly used methods of the List class are:


We can attach one item, provided by the String parameter, at the end

of the list by their method.

Public void add(java.lang.String, int)

With the help of this method, we can attach the String as one item at

the specified position.

public void addItem(java.lang.String)

The jab of this method is same as that of the add() method.

public void removeAll()

This method is used to delete all the items from the list.

Scrollbar class

The java.awt package provides the Scrollbar class for the purpose of

adjustment of the window of any GUI components. The signature of this

class is:

471

public class java.awt.Scrollbar extends java.awt.Component

implements java.awt.Adjustable, javax,accessibility.Accessible

There are two constants declared in the Scrollbar class for setting the mode

of the scrollbar. These are:

public static final int HORIZONTAL

public static final int VERTICAL

The scrollbar generates one listener known as the AdjustmentListener.

The constructors of the Scrollbar class are:

Scrollbar(int)

This constructor develops one scroll bar with the specified mode, i.e.

either HORIZONTAL or VERTICAL.

Scrollbar(int, int, int, int, int)

This constructor takes five parameters of integer type. The one sets the

mode for the scrollbar. The second one decides the initial value for the

scrollbar. The third parameter determines the size of the scrollbar. And

the fourth and fifth parameters refer to the minimum and maximum

values respectively, upto which the scrollbar can slide.

Methods of the Scrollbar class

Some of the commonly used methods of the Scrollbar class are:

public int getMaximum()

This method is used to retrieve the maximum value of the concerned

scrollbar.

public int getMinimum()

This method is used to retrieve the minimum value of the concerned

scrollbar.

public int getOrientation()

This method is used to retrieve the current orientation of the concerned

scrollbar.

472

public int getPageIncrement()

This method is used to retrieve the increment in pages of by the

concerned scrollbar.

public int getUnitIncrement()

This method determines the increment in unit of the concerned scrollbar.

public void getValue()

We can retrieve the value of the concerned scrollbar by this method.

public void setMaximum(int)

Using this method, we can set the specified maximum value for the


public void setMinimum(int)

Using this method, we can set the specified minimum value for the


public void setOrientation(int)

The job of this method is to set the provided orientation for the scrollbar.

public void setPageIncrement(int)

Using this method, we can set the specified int value as the page

increment value for the concerned scrollbar.

public void setUnitIncrement(int)

Using this method, we can set the specified int value as the unit

increment value for the concerned scrollbar.

ScrollPane class

The java.awt package provides a predefined class ScrollPane, which is a

window and that can fit only one component on it. The signature of this class

is:

473

public class java.awt.ScrollPane extends java.awt.Container

implements java.accessibility.Accessible

We cannot attach more than one component to a ScrollPane. If the

component is larger than the size of the ScrollPane window, then the

ScrollPane automatically brings the scrollbar into existence. The scrollbar

that will be generated, will have both the orientations.

The constructors of the ScrollPane class

ScrollPane()

It develops a scrollpane, by default.

ScrollPane(int)

It generates a ScrollPane with the specification for displaying the

scrollbar.

For the conditional requirement of the scrollbar, this class declares three

constants, namely

Public static final int SCROLLBAR_ALWAYS

Public static final int SCROLLBAR_AS_NEEDED

Public static final int SCROLLBAR_NEVER

TextField class

The java.awt package provides a TextField class, which is used to take the

users inputs in the text form in a single row only. The signature of this class

is:

public class java.awt.TextField extends java.awt.TextComponent

If the text length exceeds to the TextField size, then visibility scrolls to the

left.

ActionListener, TextListener and FocusListener are generated by the

TextField.

The constructors of the TextField class

474

TextField()

This constructor develops the default TextField. The size of the TextField

differs from one operating system to another.

TextField(int)

These constructor developers an empty TextField with the size specified

by the parameter.

TextField(java.lang.String)

It generates a text field and there will be an already String type content

according to the parameter specified.

TextField(java.lang.String, int)

It constructs a string with specified content and size.

Out of the various methods of the TextField class, two of the most

important methods are:

public void setEchoChar(char)

This method hides the letters that are typed in the TextField and shows

the user the specified character only. This is commonly used when we try

to enter our password for any account.

public char getEchoChar()

This method is used to retrieve the character.

TextArea class

The java.awt package provides a TextArea class, in which the user can write

something two-dimensionally, i.e. both in column and row direction. The


public class java.awt.TextArea extends java.awt.TextComponent

Two listeners can be generated by the TextArea, namely the TextListener

and FocusListener

475

The TextArea class declares some constants in order to set the visibility of

the scrollbar. These are:

public static final int SCROLLBARS_BOTH

public static final int SCROLLBARS_VERTICAL_ONLY

public static final int SCROLLBARS_HORIZONTALLY

public static final int SCROLLBARS_NONE

The constructors of the TextArea class

TextArea()

We can develop an empty TextArea by the help of this constructor.

TextArea(int, int)

Here also, we can generate an empty TextArea, but the row and column size

are specified.

TextArea(java.lang.String)

This TextArea contains an initial String type message.

TextArea(java.lang.String, int, int)

A TextArea will be formed with an already content and the specified

number of rows and columns.

Methods of TextArea

The commonly used methods of the TextArea are:

public java.lang.String getText()

To retrieve the content of the TextArea, this method is used.

public void setText(java.lang.String)

This method is used to attach the specified text in the text area.

476

public java.lang.String getSelectedText()

The job of this method is to return the selected text to the caller.

Example:

import java.awt.*;


public class Comp2 extends Applet

{

Button b1;

Choice c1;

Canvas cs1;

Checkbox cb1,cb2,cb3,cb4;

CheckboxGroup cbg;

Label l1;

List li1;

Scrollbar sb1;

ScrollPane sp1;

TextField tf1;

TextArea ta1;

public void init()

{

setBackground(Color.pink);

477

b1=new Button("Interface");

b1.setBackground(Color.red);

b1.setForeground(Color.white);

c1=new Choice();

c1.addItem("Male");

c1.add("Female");

cs1=new Canvas();

cs1.setSize(100,100);

cs1.setBackground(Color.yellow);

cs1.setVisible(true);

cb1=new Checkbox("C");

cb2=new Checkbox("Java",true);

cbg=new CheckboxGroup();

cb3=new Checkbox("Male",cbg,true);

cb4=new Checkbox("Female",cbg,false);

l1=new Label("Enter Your Course");

li1=new List(3,true);

li1.add("C");

478

li1.add("C++");

li1.add("Java");

li1.add(".Net");

sb1=new Scrollbar(Scrollbar.HORIZONTAL,

425,10,400,600);

sp1=new ScrollPane();

Button b11=new Button("Learn Java");

b11.setFont(new Font("Verdana",Font.BOLD,200));

sp1.add(b11);

tf1=new TextField(10);

ta1=new TextArea(10,10);

add(c1);

add(ta1);

add(sp1);

add(li1);

add(l1);

add(sb1);

add(tf1);

add(b1);

479

add(cb1);

add(cb2);

add(cb3);

add(cb4);

add(cs1);

}

}

/*<applet code="Comp2" width=300 height=260>

</applet>*/

Output:-

480

Menu components:

The java.awt package provides various menu component to develop and

manage the menus.

All the applications regarding the menu must follow the three steps which

are enlightened below:

Step-1:

The Frame has to be constructed.

The MenuBar has to be constructed.

The MenuBar has to be attached with the Frame.

Step-2:

The Menu has to be constructed.

The MenuItem has to be constructed

The MenuItem has to be attached with the Menu.

Step-3

The Menu has to be attached in the MenuBar.

Let us have a brief look on the various menu components.

MenuBar class

The java.awt package contains a predefined class MenuBar to manage the

topmost level of the window which contains the menu.

The signature of the MenuBar class is:

public class java.awt.MenuBar extends java.awt.MenuComponent

implements java.awt.MenuContainer, javax.accessibility.Accessible

In order to develop the MenuBar, first the MenuBar class has to be

instantiated.

MenuBar mnbr=new MenuBar();

481

Then the required number of selectable menus are to be added to the menu

bar by the help of the add() method of the MenuBar class.

Now the menu bar has to be attached with the Frame.

Frame fm=new Frame(“wordpad”);

fm.setMenuBar(mnbr);

Menu class

Menu is a predefined class present in the java.awt package. It is used to

develop a pull-down menu containing a number of items that can be

selected. The signature of the Menu class is:

public class java.awt.Menu extends java.awt.MenuItem implements

java.awt.MenuContainer, javax.accessibility.Accessible

The constructed of the Menu class is

Menu(java.lang.String)

The Menu can be instantiated as

Menu mn=new Menu(“true”);

Here, the constructor of the Menu class takes a String type parameter which

is used as the label of the Menu object.

Then the menu items are added by the help of the add() method.

mn.add(item_1);

mn.add(item_2);

Then the Menu is added to the MenuBar.

Mnbr.add(mn);

The methods of the Menu class:

Public void add(java.awt.MenuItem)

482

By the help of this method, an object of the MenuItem can

be attached with the Menu component.


By the help of this method, a string can be added with the

Menu component.

Public void addSeparator()

This method helps to add a separator to the Menu

component.

public void remove(int)

We can delete one item from the Menu according to the

specified index.

MenuItem class

The java.awt package provides the MenuItem class in order to give the final

touch to the development process of the Menu system.


public class java.awt.MenuItem extends java.awt.MenuComponent

implements javax.accessibility.Accessible

The constructor of this class is

MenuItem(java.lang.String)

This constructor is used to develop a menu item which is having a label as

specified by the String parameter.

To instantiate the class, we can write

MenuItem mnitm=new MenuItem(“open”);

Then the MenuItem has to be added with the Menu by the add() method.

Mn.add(mnitm);

Methods of the MenuItem class

483

public string getLabel()

The label of the menu item can be retrieved and returned

in the form of a String by this method.


The label of the menu item can be set as the specified

String by the help of this method.

public void setEnabled(boolean)

The label of the menu item can be made selectable or

deselect-able according to the boolean parameter. If it is

true, then the item can be selected, otherwise not.

CheckboxMenuitem class

The CheckboxMenuItem is a child class of the MenuItem class. It generates

a dual state for the MenuItem components. The MenuItem‟s state can be

managed by this class. We can toggle on or off the MenuItem, just by

clicking the CheckboxMenuItem.


public class java.awt.CheckboxMenuItem extends extends

java.awt.Menutem implements java.awt.ItemSelectable,


The constructor of this class is

CheckboxMenuItem(java.lang.String)

The methods of this class are:

public boolean getState()

The job of this method is to check the state of the Menu item. If the

CheckboxMenuItem is selected, then the method returns true, otherwise it

returns false.

public void setState(boolean)

484

This method is used to set the state of the MenuItem. If true is passed as

parameter, then the CheckboxMenuItem gets selected, otherwise, it remains

unselected.

Example-1

import java.awt.*;

public class Pull extends Frame

{

Menu m,sub;

MenuBar bar;

MenuItem item1,item2,item3,item4,item5;

CheckboxMenuItem cb1;

Pull()

{

Frame f=new Frame("Menu Demo");

f.setLayout(new GridLayout(1,1));

bar=new MenuBar();

f.setMenuBar(bar); //step-1

m=new Menu("File") ;

sub=new Menu("Edit");

item1=new MenuItem("new");

item2=new MenuItem("print");

item3=new MenuItem("Quit");

item4=new MenuItem("edit");

485

item5=new MenuItem("Cut");

cb1=new CheckboxMenuItem("ok");

m.add(item1); //step-2

m.addSeparator();

m.add(item2);

m.add(item3);

sub.add(item4);

sub.addSeparator();

sub.add(item5);

sub.add(cb1);

bar.add(m); //step-3

bar.add(sub);

f.setSize(300,300);

f.setVisible(true);

}


{

Pull p=new Pull();

}

486

}

Output:-

Container component:

The java.awt package provides a class Container which extends to the

Component class. The signature of this class is:

public class Container extends java.awt.Component

An AWT Container object is used for the purpose of containing the AWT

components. To display the components on the screen, it is mandatory to

attach the components in a container.

A list is maintained for the GUI components that are added to the container.

The order of the list determines the components occupancy inside the

container. If a component is attached to the container without having any

index, then that component will be placed at the end of the list.

Methods of the Container class:

Component add(Component c): Add the component in the container

487

Component add(Component c, int index): Add the component in a

container in a specified position

Component add(String name, Component comp): Add the component

in the container

int countComponents(): This method counts how many components are

present in the container

Component getComponent(int n): Gets the nth component in the

container

int getComponentCount(): Gets the number of component in the

container

void remove(Component comp): Removes the component from the

container

void setLayout(LayoutManager lm): Sets the layout for the container

void removeAll(): Remove all the component from the container

The Container class has some child classes. The hierarchy of the child

classes is shown in the figure below:

488

The Container class is divided into five containers. They are

Panel

Window

Applet Frame

Dialog

Here, the Panel and Window are considered as light weight containers.

The Applet, Frame and the Dialog are heavy weight containers.

According to java, the components that are attached to the light weight

containers are not visible. To make them visible, we have to attach the

light weight containers in the heavy weight containers. So for visibility,

the light weight containers are to be nested with the heavy weight

containers.

For example, the container Panel can contain any component and another

panel. But it is not visible to the user. To make it visible, we have to

attach the panel with the Applet.

489

Let us have a brief discussion about the containers.

Panel class:

The java.awt package provides a class Panel. This class extends the

Container class and therefore becomes a container itself. The signature of

this class is:

public class java.awt.Panel extends java.awt.Container implements


Panel is considered as a light weight container in java. It can contain

different components as well as other panels also. But, an user cannot

visualize the Panel itself. In order to make the panel visible to the users, we

have attach the panel with any of the heavy weight containers like Applet,

Frame or Dialog according to our convenience.

The constructor of the Panel calss is:

Panel()

Window class

The java.awt package provides a class Window, which also extend the

java.awt.Container class and therefore acts as a container itself. The


public class java.awt.Window extends java.awt.Container

implements javax.accessibility.Accessible

The Window is considered as a light weight container. So the user cannot

visualize it. In ordered to make it visible, we have to attach the Window with

any heavy weight container like Frame.

The constructors of the Window class are:

Window()

Window(java.awt.Frame)

Applet class

490

Applet is a class provided by the java.applet package. In java, the Applet is

considered as a heavy weight container. So applet is visible to the user. The

applets can be executed on the web browsers. Applets do not have any

constructor. Also they do not have their own main() method.

To know in details about the Applet class, refer to the java.applet package.

Frame class

The java.awt class provides a class Frame, which extends to the Window

class and therefore acts as a container itself.


public class java.awt.Frame extend java.awt.Window implements

java.awt.MenuContainer

Frame is considered as a heavy weight container. That is why, a frame is

visible to the user.

Frame cannot be executed on the browser. It is only meant for the stand-

alone application. So, it cannot support the web-enabled applications.

The constructors of the Frame class:

Frame()

It is used to generate a frame without any title.

Frame(java.lang.String)

This constructor is used to generate a frame, having a title as specified

by the String type parameter.

To properly execute the Frame application, it is mandatory for the

programmer to use two methods of the Component class. These two

methods are:

public void setSize(int, int)

public void setVisible(booean)

491

Example:

import java.awt.*;

public class Frame1 extends Frame

{

Button b1;

Choice c1;

List l1;

ScrollPane sp1;

public Frame1()

{

Frame f1=new Frame("Frame Demo");

b1=new Button("Interface");

b1.setFont(new Font("Arial",Font.BOLD,20));

c1=new Choice();

c1.addItem("Male");

c1.addItem("Female");

l1=new List(3,true);

l1.add("C");

l1.add("C++");

l1.add("Java");

l1.add(".Net");

sp1=new ScrollPane();

Button b2=new Button("Java Is A Language");

b2.setFont(new Font("Arial",Font.BOLD,140));

sp1.add(b2);

492

f1.setLayout(new FlowLayout());

f1.add(sp1);

f1.add(c1);

f1.add(l1) ;

f1.add(b1);

f1.setSize(300,280);

f1.setVisible(true);

}


{

new Frame1();

}

}

Output:

Dialog class

493

The java.awt package provides a class Dialog. The main job of this class is to

develop the dialog boxes. The signature of the Dialog class is:

public class java.awt.Frame extend java.awt.Window

As the Dialog class extends the Window class, it becomes a container. In

java, Dialog is considered as a heavy weight container. So, is visible to the

users. The dialog boxes can be made modal according to the programmers

choice. If it is made modal, then all other components will be blocked till the

dialog box is active.

The constructors of the Dialog class are:

Dialog(java.awt.Frame)

Dialog(java.awt.Frame, java.lang.String, boolean b)

Example

import java.awt.*;


public class Dial extends Frame implements ActionListener

{

Frame f;

TextField t1,t2;

Button b1;

Box bx;

String s;

Dial()

{

494

f=new Frame("Display");

bx=new Box(f,"Dialog Box",true);

t1=new TextField(20);

t2=new TextField(20);

b1=new Button("OK");


f.setLayout(new FlowLayout());

f.add(t1);f.add(t2);f.add(b1);

f.setVisible(true);

f.setSize(500,500);

}


{


{

String s=t1.getText();

if(s==null || s.equals(""))

{

bx.setSize(200,200);

bx.setVisible(true);

}

}

}

public static void main(String ars[])

{

Dial d=new Dial();

495

}

}

class Box extends Dialog implements ActionListener

{

Label l;

Panel p1,p2;

Button b;

Box(Frame f,String s,boolean bb)

{

super(f,s,bb);

p1=new Panel();

p2=new Panel();

l=new Label("Plz Enter Data");

p1.add(l);

b=new Button("OK");

p2.add(b);

setLayout(new GridLayout(2,1));

add(p1);

add(p2);

b.addActionListener(this);

}


{

if(ae.getSource()==b)

setVisible(false);

}

496

}

Output:-

LayoutManager

The java.awt package provides an interface LayoutManager, which facilitates

the programmer to place the components in the suitable location.

The preferred size of the java components differs from one platform to

another. So, it is the job of the LayoutManager to look after the preferred

size of the java components.

The signature of the LayoutManager is:

public interface java.awt.LayoutManager

There are five child classes of the LayoutManager, which are used for various

layout management process. The child classes are:

FlowLayout

BorderLayout

GridLayout CardLayout

GridbagLayout

497

FlowLayout class

The java.awt package provides a class FlowLayout, which implements the

FlowlayoutManager. The signature for FlowLayout is:

public class java.awt.FlowLayout extends java.lang.Object implements

java.awt.LayoutManager, java.io.Serializable

FlowLayout provides five constants for the arrangement of the layout of the

components. These are:

public static final int LEFT

public static final int RIGHT public static final int CENTER

public static final int LEADING

public static final int TRAILING

The FlowLayout supports two types of java components. These are:

Applet

Panel

The constructors for the FlowLayout are:

FlowLayout()

This constructor helps to develop a layout, which is having the

center alignment. There wii be a padding of 5 pixels between the

components.

FlowLayout(int)

By calling this constructor a new layout is developed with the

specified alignment.

FlowLayout(int, int, int)

This constructor also generates a layout with the specified

alignment, i.e. the first parameter. Here, the second and the third int

parameters denote the horizontal and vertical padding respectively.

498

In case of FlowLayout, the components are attached horizontally. If

there wii be no more space, then the next component to be attached

moves to the next line with the corresponding alignment.

The default alignment of Flowlayout is considered to be CENTER.

import java.awt.*;

public class Flow extends Frame

{

public Flow()

{

setLayout(new FlowLayout());

add(new Label("Name"));

add(new TextField(10));

add(new Button("Send"));

setVisible(true);

setSize(300,300);

}


{

Flow f=new Flow();

}

}

Output:

499

BorderLayout class

The java.awt package provides another class to manage the layout of the

components like Frame, Window and Dialog. This class is known as

BorderLayout. The signature of this class is:

public class java.awt.BorderLayout extends java.lang.Object

implements java.awt.LayoutManager2, java.io.Serializable

The BorderLayout class provides some constants to specify the regions. The

constants are:

Public static final java.lang.String NORTH

Public static final java.lang.String SOUTH Public static final java.lang.String EAST

Public static final java.lang.String WEST Public static final java.lang.String CENTER

Public static final java.lang.String BEFORE_FIRST_LINE Public static final java.lang.String AFTER_LAST_LINE

Public static final java.lang.String BEFORE_LINE_BEGINS Public static final java.lang.String AFTER_LINE_ENDS

Public static final java.lang.String PAGE_START Public static final java.lang.String PAGE_END

Public static final java.lang.String LINE_START

Public static final java.lang.String LINE_END

The constructor of this class is:

BorderLayout()

This constructor generates a new border layout without any gap

between the components.

BorderLayout(int, int)

500

This constructor generates a new border layout, with the horizontal

and vertical gap as specified by the parameters.

The BorderLayout class does not provide any relaxation for the

preferred size.

To explicitly set the layout as BorderLayout, the programmer has to

make use of the method:

public void setLayout(BorderLayout blt)

Methods of the BorderLayout class

public int getHgap()

This method determines the horizontal gap between the components.

public int getVgap()

This method determines the vertical gap between the components.

public void setHgap(int)

This method provides a specific Horizontal gap between the java

components.

public void setVgap(int)

This method provides a specific vertical gap between the java

components.

Example:


import java.awt.*;

public class Border extends Applet

501

{

public void init()

{

setLayout(new BorderLayout());

Button b1=new Button("North");

Button b2=new Button("South");

Button b3=new Button("East");

Button b4=new Button("West");

Button b5=new Button("Center");

add(b1,BorderLayout.NORTH);

add(b2,BorderLayout.SOUTH);

add(b3,BorderLayout.EAST);

add(b4,BorderLayout.WEST);

add(b5);

}

}

/*<applet code="Border" width=300 height=300>

</applet>*/

Output:

502

GridLayout class

The java.awt package contains the GridLayout. The signature of this class is:

public class java.awt.GridLayout extends java.lang.Object

implements java.awt.LayoutManager, java.io.Serializable

The GridLayout class, by default, does not support to any Container. Also,

the GridLayout class does not provide any support for the preferred size.

The GridLayout works like a spreadsheet. All the components in case of the

GridLayout acquires same size.

The constructors of the GridLayout class are:

GridLayout()

This constructs creates a new grid layout, with the default

specifications.

503

GridLayout(int, int)

By the help of this method we can generate a grid layout with specified

size of rows and columns.

Methods of the GridLayout class

public int getColumns()

We can determine the number of columns in the concerned layout by

this method.

public int getRows()

The number of rows of the concerned layout can be derived by this

method.

public int getHgap()

This method is used to determine the horizontal gap between the

components in the concerned layout.

public int getVgap

This method is used to determine the vertical gap between the

components in the concerned layout.

public void setColumns(int)

This method is used to set the specified value for the number of

columns in the concerned grid layout.

public void setRows()

This method is used to set the specified value for the number of rows

in the concerned grid layout.

public void setHgap()

This method is used to set the specified value for the horizontal gap

between the components in the concerned grid layout.

504

public void setVgap()

This method is used to set the specified value for vertical gap between

the components in the concerned grid layout.

Example

import java.awt.*;

public class Grid extends Applet

{

public void init()

{

Button b1=new Button("Button-1");




setLayout(new GridLayout(2,2,5,10));

add(b1);

add(b2);

add(b3);

add(b4);

setBackground(Color.lightGray);

505

}

}

/*<applet code="Grid" width=300 height=300>

</applet>*/

Output:

CardLayout class

The java.awt package provides the CardLayout class by the help of

which, only one component can be made visible at a time. The

signature for this class is:

506

public class java.awt.CardLayout extends java.lang.Object

implements java.awt.LayoutManager, java.io.Serializable

The CardLayout, by default, does not support any container. In case

of CardLayout, more than one component can be attached. It does not

provide support for the preferred size.

CardLayout provides some predefined methods , by the help of which

we can see other components.

The methods are

void next()

This method is used to visit the next component of the current

component.

void previous()

This method is used to visit to the previous component of the current

displayed component.

void first()

This method is used to visit the first attached component of the layout.

void last()

This method is used to visit the last component of the layout.

The constructor of the CardLayout is

CardLayout()

By this constructor, we get a new CardLayout with default

specifications.

CardLayout(int, int)

By the help of this constructor, a new CardLayout with specified

horizontal and vertical paddings will be generated.

507

Example:

import java.awt.*;



public class CardDemo extends Applet implements ActionListener

{

Panel p,p1,p2,p3;

Button b1,b2;

CardLayout cl;

public void init()

{

p=new Panel();

cl=new CardLayout();

p.setLayout(cl);

p1=new Panel();

Label l1=new Label("Panel-1");

l1.setBackground(Color.yellow);

l1.setForeground(Color.red);

l1.setFont(new Font("Sans Serif",Font.BOLD,40));

p1.add(l1);


l2.setBackground(Color.blue);

508

l2.setForeground(Color.white);

l2.setFont(new Font("Arial",Font.BOLD,40));

p2=new Panel();

p2.add(l2);

p3=new Panel();

p3.setBackground(Color.green);

p3.setForeground(Color.black);


l3.setFont(new Font("Verdana",Font.BOLD,40));

p3.add(l3);

p.add(p1,"First");

p.add(p2,"Second");

p.add(p3,"Third");

b1=new Button("NEXT");


b2=new Button("Previous");


add(p);

add(b1);

add(b2);

}


{


509

{

cl.next(p);

}else{

cl.previous(p);

}

}

}

/* <applet code="CardDemo" width=500 height=500>

</applet> */

GridBagLayout class

This is a predefined class of java.awt package which implements the

LayoutManager interface. The signature of this class is:

public class java.awt.GridBagLayout extends java.lang.Object

implements java.awt.LayoutManager2, java.io.Serializable

In case of GridBagLayout, the entire container is divided into cells of equal

size. In this case a component can occupy more than one cells at a time. the

area occupied by the component is known as the display area.

510

Here, the size of the components can be adjusted according to our

requirement. The adjustment mode is denoted by FILL.

When the component is smaller than its display area, then the placement of

the component is decided by the anchor.

The values of the anchor are:

GridBagConstraints.CENTER GridBagConstraints.NORTH

GridBagConstraints.NORTHEAST

GridBagConstraints.EAST GridBagConstraints.SOUTHEAST

GridBagConstraints.SOUTH GridBagConstraints.SOUTHWEST

GridBagConstraints.WEST GridBagConstraints.NORTHWEST

Example:

import java.awt.*;


public class GridbagTest extends Applet

{

TextField tf1,tf2,tf3,tf4;

Label l1,l2,l3,l4,l5;

Button b1;

public void init()

{

l1=new Label("Collect The Information") ;


l2=new Label("Enter Your Name");

511


l3=new Label("Enter Your City");


l4=new Label("Enter Your State");


l5=new Label("Enter Mobile Number");






b1=new Button("Submit");

GridBagLayout gbag=new GridBagLayout();

GridBagConstraints gbc=new GridBagConstraints();

setLayout(gbag);

gbc.weighty=1.0;

gbc.gridwidth=GridBagConstraints.REMAINDER;

gbc.anchor=GridBagConstraints.NORTH;

gbag.setConstraints(l1,gbc) ;

gbc.anchor=GridBagConstraints.EAST;

gbc.gridwidth=GridBagConstraints.RELATIVE;

512



gbag.setConstraints(tf1,gbc);













gbc.anchor=GridBagConstraints.CENTER;

gbag.setConstraints(b1,gbc);

add(l1);

add(l2);

add(tf1);

add(l3);

add(tf2);

add(l4);

add(tf3);

513

add(l5);

add(tf4);

add(b1);

}

}

/*<applet code="GridbagTest" width=300 height=300>

</applet>*/

514

Event Handling

The program is able to respond some dynamic actions in an interactive

environment. Clicking on the mouse, pressed the key, select an item from

List is an example of performing actions. The fundamentals of event-driven

programming are used to translate events to code. In an Object oriented

approach it is also possible to handle events. In java AWT when an user

generates an action, then AWT generates an event and communicates these

events to event handlers. Then the event handlers can respond to the

events.

There are two popular model was used to handle event in java.

1.0 model or Hierarchical model

1.2 model or Delegation model

In 1.0 model the total event handling procedure is done through two

methods action( ) and handleEvent ( ) method. action( ) method having three parameters namely – the event name that has been occurred, the x

and y co-ordinates at which this event occurred. handleEvent ( ) method is implicitly called for every event object. This model having various problems

and the problems are solved through 1.2 model.

Event Delegation Model

In event delegation model, an event is fired from a “source” object to a

“Listener“ object by invoking a methods on the listener and passing in the

instance of the event subclass which defines the event type generated.

When an event is fired, it is received by one or more listener that acts on

that event. Event types are encapsulated in a class hierarchy rooted at

java.util.EventObject.

In java Listener is an object that implements a specific

EventListener interface and extended from the generic java.util.EventListener.

Each and every EventListener interface having one or more methods that are to be invoked by the event source in response to each specific

event type handled by the interface.

515

An Adapter class is an anonymous inner class that includes all

methods specified by the corresponding interface but not providing any functionality.

Types of event handling

The AWT provides two conceptual types of events such as low-level event

and semantic event.

Low-level event

A low-level event is one that represents a low-level input or window-system

occurrence on a visual component on the screen. The low-level event classes

defined by the AWT are as follows:

ComponentEvent (component resized, moved, etc .)

FocusEvent (component got focus, lost focus ) InputEvent

KeyEvent (component got key-press, key-release, etc.) MouseEvent (component got mouse-down, mouse-move, etc.)

ContainerEvent

WindowEvent

The low-level event listeners are as follows:

ComponentListener

ContainerListener FocusListener

KeyListener MouseListener

MouseMotionListener WindowListener

Semantic Events

Semantic Events are defined at a higher – level to encapsulate the semantics

of a user interface component‟s model. The semantic Events classes defined

by the AWT are as follows:

ActionEvent (“do a command”); AdjustmentEvent (“value was adjusted”);

ItemEvent (“item state has changed”);

516

TextEvent (“the value of the text object changed”)

The semantic listener interfaces defined by the AWT are as follows

ActionListener AdjustmentListener

ItemListener

TextListener

Let us have a brief look on the 11 listener suggested by the event

delegation model.

1. ActionListener:-

This is one interface suggested by the event delegation model. This

interface is declared within the java.awt.event package. The signature

for this interface is:

public interface java.awt.event.ActionListener extends

java.util.EventListener

This interface provides the declaration for an abstract method:

public abstract void actonPerformed(java.awt.event.ActionEvent)

This method is used to receive the action events.

Example:-


import java.awt.*;

import java.awt.event.*; //1st step

public class Button1 extends Applet implements ActionListener

//2nd step

{

Button b1,b2,b3;

public void init()

517

{

b1=new Button("Red");

b2=new Button("Green");

b3=new Button("Blue");

//3rd step




add(b1);

add(b2);

add(b3);

}

//step-4


{


{

setBackground(Color.red);

}else if(ae.getSource()==b2)

{

setBackground(Color.green);

}else{

setBackground(Color.blue);

}

518

}

}

/*<applet code="Button1" width=220 height=200>

</applet>*/

2. ItemListener

This interface also inhabits inside the java.awt.event package. The

signature for this interface is:

public interface java.awt.event.ItemListener extends


The interface contains the declaration of an abstract method :

public abstract void

itemStateChanged(java.awt.event.ItemEvent)

This method is used to receive the events generated from the Checkbox,

Choice and List.

Example:-

519

import java.awt.*;



public class Radio extends Applet implements ItemListener

{

CheckboxGroup cbg;

Checkbox cb1,cb2,cb3,cb4;

String msg="";

public void init()

{

cbg=new CheckboxGroup();

cb1=new Checkbox("Oracle",cbg,true);

cb2=new Checkbox("Sybase",cbg,false);

cb3=new Checkbox("Infomix",cbg,false);

cb4=new Checkbox("DB2",cbg,false);

cb1.addItemListener(this);




add(cb1);

add(cb2);

add(cb3);

add(cb4);

}

520

public void itemStateChanged(ItemEvent ae)

{

repaint();

}


{

msg="Current Selected Item Is ";

msg+=cbg.getSelectedCheckbox().getLabel();

g.drawString(msg,170,120);

}

}

/*<applet code="Radio" width=400 height=400>

</applet>*/

3. AdjustmentListener

521

This interface is provided in the java.awt.event. The signature for this

interface is :

public interface java.awt.event.AdjustmentListener extends


The AdjustmentListener contains the declaration of one abstract method.

The method is:

public void

adjustmentValueChanged(java.awt.event.AdjustmentEvent)

This method is used to receive the events generated by the component

Scrollbar.

Example:-

public class Scroll extends Applet implements AdjustmentListener

{

Scrollbar h1,h2,v1,v2;

Panel p1;

TextField tf1;

public void init()

{

setLayout(new BorderLayout());

h1=new Scrollbar(Scrollbar.HORIZONTAL,1,1,1,200);

h1.addAdjustmentListener(this);

add(h1,BorderLayout.NORTH);

522

h2=new Scrollbar(Scrollbar.HORIZONTAL,1,1,1,200);

h2.addAdjustmentListener(this);

add(h2,BorderLayout.SOUTH);

v1=new Scrollbar(Scrollbar.VERTICAL,1,1,1,200);

v1.addAdjustmentListener(this);

add(v1,BorderLayout.WEST);

v2=new Scrollbar(Scrollbar.VERTICAL,1,1,1,200);

v2.addAdjustmentListener(this);

add(v2,BorderLayout.EAST);

p1=new Panel();


p1.add(tf1);

add(p1);

}

public void adjustmentValueChanged(AdjustmentEvent ae)

{

if(ae.getAdjustable()==h1)

{

h1.setValue(h1.getValue());


tf1.setText("Horizontal Location :- "+h1.getValue());

523

}

if(ae.getAdjustable()==v1)

{

v1.setValue(v1.getValue());


tf1.setText("Vertical Location :- "+v1.getValue());

}

if(ae.getAdjustable()==h2)

{



tf1.setText("Horizontal Location :- "+h2.getValue());

}

if(ae.getAdjustable()==v2)

{



tf1.setText("Vertical Location :- "+v2.getValue());

}

}

}

Output:

524

4. TextListener

The TextListener is an interface suggested by the event delegation model

and present in the java.awt.event package. The signature of this method

is:

public interface java.awt.event.TextListener extends


The interface contains one abstract method which is declared as:

public void textValueChanged(java.awt.event.TextEvent)

This method has to be defined in ordered to receive the events generated

by the components TextField and TextArea.

Example:-

import java.awt.*;


525


public class CopyText extends Applet implements TextListener

{

TextArea t1,t2;

public void init()

{

t1=new TextArea(10,10);

t2=new TextArea(10,10);

t1.addTextListener(this);

t2.addTextListener(this);

add(t1);

add(t2);

}

public void textValueChanged(TextEvent te)

{

t2.setText(t1.getText());

}

}

/* <applet code="CopyText" width=400 height=400>

</applet> */

526

5. FocusListener

The FocusListener is an interface present inside the java.awt.event

package. The signature of this class is:

public interface java.awt.event.FocusListener extends


This interface provides the declaration for two abstract methods:

public void focusGained(java.awt.event.FocusEvent)

public void focusLost(java.awt.event.FocusEvent)

Suppose, there are two text fields attached to the screen. But, the user

can write in a single text field at a time. So, the textfield which will be in

use, is associated with the focusGained() method and the other textfield

which is not in use at that particular point of time, is associated with the

focusLost() method.

The two abstract methods of the FocusListener interface are used to

receive the events generated by the TextArea, TextField, Button and

Choice Components.

6. KeyListener

527

This interface is also present in the java.awt.event package. The

signature of this interface is:

public interface java.awt.event.KeyListener extends


The abstract methods present inside this interface are

public void keyPressed(java.awt.event.KeyEvent)

public void keyReleased(java.awt.event.KeyEvent)

public void keyTyped(java.awt.event.KeyEvent)

All of the above methods are used in case of a key pressed, released or

typed.

7. MouseListener

This interface is suggested by the event delegation model and situated in

the java.awt.event package. The signature of this interface is:

public interface java.awt.event.MouseListener extends


There are five abstract methods declared in this interface. These are:

public void mouseEntered(java.awt.event.MouseEvent)

public void mouseExited(java.awt.event.MouseEvent)

public void mousePressed(java.awt.event.MouseEvent)

public void mouseReleased(java.awt.event.MouseEvent)

public void mouseClicked(java.awt.event.MouseEvent)

All of the above methods are to be defined in the corresponding

child classes in order to handle the events generated by the mouse.

8. MouseMotionListener

The MouseMotionListener is used to handle the events generated by all

type of components. The signature for this interface is:

public interfaced java.awt.event.MouseMotionListener extends


There are two abstract methods declared in this interface. These

are

528

public void mouseDragged(java.awt.event.MouseEvent)

public void mouseMoved(java.awt.event.MouseEvent)

Example:-

import java.awt.*;



public class CanvasDemo extends Applet implements

MouseListener,MouseMotionListener

{

int x,y;

GraphCanvas gc;

public void init()

{

gc=new GraphCanvas();

gc.setVisible(true);

gc.setLocation(100,100);

gc.setBackground(Color.blue);

gc.setSize(300,200);

add(gc);

addMouseListener(this);

addMouseMotionListener(this);

}

public void mouseDragged(MouseEvent me)

{

529

x=me.getX();

y=me.getY();

gc.setLocation(x,y);

}

public void mouseMoved(MouseEvent me)

{

}

public void mouseClicked(MouseEvent me)

{

x=me.getX();

y=me.getY();


}

public void mouseEntered(MouseEvent me) {}

public void mouseExited(MouseEvent me) {}

public void mousePressed(MouseEvent me) {}

public void mouseReleased(MouseEvent me) {}

}

class GraphCanvas extends Canvas

{


{

g.setColor(Color.white);

g.setFont(new Font("Sans Serif",Font.BOLD,30));

530

g.drawString("Painting On Canvas",10,40);

g.setColor(Color.pink);

g.fillRect(40,50,40,50);

}

}

/* <applet code="CanvasDemo" width=500 height=500>

</applet> */

9. ContainerListener

531

This interface is suggested by the event delegation model and situated in

the java.awt.event package. The signature for this interface is:

public interface java.awt.event.ContainerListener extends


The ContainerListener provides the mechanism to receive the event

generated by all types of containers.

This interface declares two methods. These are:

public void componentAdded(java.awt.event.ContainerEvent)

public void

componentRemoved(java.awt.event.ContainerEvent)

10. ComponentListener

This interface is suggested by the event delegation model and inhabits in

the java.awt.event package. The signature of this class:

public interface java.awt.event.ComponentListener extends


This interface provides four methods which are to be defined in ordered

to provide the mechanism for handling the events generated by all types

of components. The methods are:

public void componentShown(java.awt.event.ComponentEvent)

public void componentHide(java.awt.event.ComponentEvent)

public void componentResized(java.awt.event.ComponentEvent)

public void componentMoved(java.awt.event.ComponentEvent)

11. WindowListener

This is the last listener interface provided by the event delegation model and

placed in the java.awt.event package. The signature of this interface is:

public interface java.awt.event.WindowListener extends


532

There are seven methods declared in this interface for handling the events.

These are:

public void windowActivated(java.awt.event.WindowEvent)

public void windowDeactivated(java.awt.event.WindowEvent)

public void windowIconified(java.awt.event.WindowEvent)

public void windowDeiconified(java.awt.event.WindowEvent)

public void windowClosed(java.awt.event.WindowEvent)

public void windowClosing(java.awt.event.WindowEvent)

public void windowOpened(java.awt.event.WindowEvent)

Example:-

import java.awt.*;


public class WindowDemo extends Frame implements

WindowListener

{

Frame f1;

public WindowDemo()

{

f1=new Frame("Winow Event");

f1.addWindowListener(this);



}

public void windowActivated(WindowEvent we)

{

533

}

public void windowDeactivated(WindowEvent we){}

public void windowIconified(WindowEvent we){}

public void windowDeiconified(WindowEvent we){}

public void windowClosed(WindowEvent we){}

public void windowClosing(WindowEvent we)

{

System.exit(0);

}

public void windowOpened(WindowEvent we){}


{

WindowDemo d=new WindowDemo();

}

}

Adapter class

The main problem that arises in delegation model is that each and every

Listener is treated as interface and in interface every methods are implicitly

public and abstract. As each and every method of Listeners are implicitly

abstract so the programmer is bound to override all the methods present in

the inherited Listener. To avoid the problem sun microsystem introduced

adapter class for each and every listener that have more than one methods.

Adapter classes are treated as anonymous inner class. An adapter class

implements event listeners. But the over ridden methods present there in

the adapter class does have any codes at all.

534

WindowAdapter

import java.awt.*;


public class Window1 extends Frame implements ActionListener

{

Frame f1;

Button b1,b2;

public Window1()

{

535

f1=new Frame("Frame Demo");

f1.setLayout(new FlowLayout());

b1=new Button("Red");

b2=new Button("Blue");



f1.add(b1);

f1.add(b2);



f1.addWindowListener(new WindowAdapter()

{

public void windowClosing(WindowEvent aw)

{

System.exit(0);

}

} );

}


{


{

f1.setBackground(Color.red);

}else{

f1.setBackground(Color.blue);

536

}

}


{

Window1 w1=new Window1();

}

}

MouseAdapter, MouseMotionAdapter

import java.awt.*;



public class CanvasDemo1 extends Applet

{

int x,y;

GraphCanvas1 gc;

public void init()

{

gc=new GraphCanvas1();

537

gc.setVisible(true);

gc.setLocation(100,100);

gc.setBackground(Color.blue);

gc.setSize(300,200);

add(gc);

addMouseListener(new MouseAdapter()

{

public void mouseClicked(MouseEvent me)

{

x=me.getX();

y=me.getY();


}

});

addMouseMotionListener(new MouseMotionAdapter()

{

public void mouseDragged(MouseEvent me)

{

x=me.getX();

y=me.getY();


}

});

}

}

class GraphCanvas1 extends Canvas

538

{


{


g.setFont(new Font("Sans Serif",Font.BOLD,30));

g.drawString("Painting On Canvas",10,40);

g.setColor(Color.pink);

g.fillRect(40,50,40,50);

}

}

/* <applet code="CanvasDemo1" width=500 height=500>

</applet> */

539

BallRunning.java

import java.awt.*;



/*<applet code="BallRunning.class" width=400 height=400>

</applet>*/

public class BallRunning extends Applet implements

Runnable,ActionListener

{

Thread t=null;

int i,j;

boolean stopFlag;

Button b1,b2,b3,b4;

public void init()

{

b1=new Button("START");

b2=new Button("RESUME");

b3=new Button("SUSPEND");

b4=new Button("STOP");

setBackground(Color.orange);

add(b1);

add(b2);

add(b3);

add(b4);



540



}


{

Object o=ae.getSource();

if(o==b1)

{

if(t==null)

{

t=new Thread(this);

stopFlag=false;

t.start();

}

}

if(o==b2)

t.resume();

if(o==b3)

t.suspend();

if(o==b4)

{

if(t!=null)

541

{

stopFlag=true;

t=null;

t.stop();

}

}

}

public void run()

{

for(i=0,j=400; ;i++,j--)

{

try{

repaint();

Thread.sleep(30);

if(stopFlag)

break;

}

catch(InterruptedException e){}

}

}


{

g.setColor(Color.blue);

g.fillOval(i+85,i+45,80,80);

542

g.setColor(Color.red);

g.fillOval(j-15,j-45,80,80);

}

}

Here, I have used two threads. In the main thread the applet program

executes and in the child thread t, the two balls simultaneously move in

random inside the view port. In, the main thread, since the applet is

displayed constantly , therefore a particular colors with a fixed intensity is

fired to the moniter screen. This is done by the underlying OS, I think this

is quite justified because the main do its unique task. Othe thread just

moves the ball in different direction.

543

mballs.java

import java.awt.*;



public class mballs extends Applet implements Runnable,ActionListener

{

Thread t=null;

Button b1,b2,b3,b4;

int l;

TextField tf2,tf1;

Label l1,l2;

public void init()

{

l1=new Label("Enter Speed in ms");

l2=new Label("No of Balls");

l1.setForeground(Color.orange);

l2.setForeground(Color.orange);



b1=new Button("start");

b2=new Button("stop");

b3=new Button("pause");

b4=new Button("Resume");

544





setBackground(Color.black);

add(l1);

add(tf1);

add(l2);

add(tf2);

add(b1);

add(b2);

add(b3);

add(b4);

}


{

if((ae.getSource()==b1)&&(t==null))

{

t=new Thread(this);

t.start();

}

else if((ae.getSource()==b2)&&(t!=null))

{

t.stop();

t=null;

}

545


{

t.suspend();

}


{

t.resume();

}

}

public void run()

{

for(;;)

{

try

{

repaint();

Thread.sleep(Integer.parseInt(tf1.getText()));

}

catch(Exception e){}

}

}


{

for(int k=0;k<(Integer.parseInt(tf2.getText()))%1000;k++)

{

546

l=((int)(Math.random()*1000))%100;

g.setColor(new

Color(((int)(Math.random()*1000))%254,((int)(Math.random()*1000))%

254,((int)(Math.random()*1000))%254));

g.fillOval(((int)(Math.random()*1000))%500+100,((int)(Math.rand

om()*1000))%500+100,l,l);

}

}

}

/*<applet code="mballs" width=800 height=650>

</applet>*/

ncolor.java

import java.io.*;

547

import java.awt.*;



import java.net.*;

public class ncolor extends Applet implements Runnable,ActionListener

{

Thread t;

Button b1,b2,b3,b4;

int x,y;

TextField tf,tf1;

Label l;

String s;

public void init()

{

l=new Label("Enter Speed in ms");


tf=new TextField(20);

b1=new Button("start");

b2=new Button("stop");

b3=new Button("pause");

b4=new Button("Resume");





add(l);

548

add(tf1);

add(tf);

add(b1);

add(b2);

add(b3);

add(b4);

}


{

if((ae.getSource()==b1)&&(t==null))

{

update(getGraphics());

t=new Thread(this);

t.start();

}


{

t.stop();

t=null;

}


{

t.suspend();

}


{

549

t.resume();

}

}

public void run()

{

x=y=0;

draw();

}

public void draw()

{

s=tf.getText();

Graphics g=getGraphics();

g.setFont(new Font("Monotype Corsiva",Font.BOLD,50));

for(int i=0;i<s.length();i++)

{

if(s.charAt(i)!=' ')

{

try

{

getAudioClip(new URL(getCodeBase(), "chime.au")).play();

}

catch (Exception e) {}

}

g.setColor(new

Color(((int)(Math.random()*1000))%254,((int)(Math.random()*1000))%

254,((int)(Math.random()*1000))%254));

550

g.drawString(String.valueOf(s.charAt(i)),100+x,100+y);

x+=25;y+=25;

try{Thread.sleep(Integer.parseInt(tf1.getText()));}

catch(Exception e){}

}

}

}

/*<applet code="ncolor" width=400 height=400>

</applet>*/

Image1.java

551

import java.awt.*;

import java.applet.Applet;

public class Image1 extends Applet implements Runnable

{

Image im1;

Thread t1;

Graphics g;

int i=0;

boolean flag=true;

public void init()

{

im1=createImage(100,100);

g=im1.getGraphics();

setBackground(Color.cyan);

}

public void start()

{

t1=new Thread(this);

t1.start();

}

public void stop()

{

flag=false;

}

public void run()

{

552

while(flag)

{

repaint();

try{

Thread.sleep(100);

}catch(InterruptedException ie)

{

}

}

}


{

i+=5;

if(i>=100)

i=5;


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

g.setColor(Color.black);

g.drawOval(30,60,i,i);

g.drawImage(im1,10,10,this);

g.setFont(new Font("Verdana",Font.BOLD,22));

g.drawString("Sai",i,i);

}

}


553

</applet>*/

`

554

Chapter-27

The Java Foundation Classes

Java Foundation Classes are the extended version of Abstract

Window Toolkit which is mainly used for GUI development. The drawbacks of AWT

class are removed by the introduction of JFC. AWT has drawbacks!! Yes it does

have. So, let me first address those drawbacks.

if you have ever google through AWT classes you might have come

across the term “peer component” the alias name given to AWT. Why this name is

given? Whenever you develop any GUI application in AWT, internally system

dependent native codes are executed & the required system call is performed in to

display various visual components on the screen. Actually when the AWT class file

is executed by JVM, JVM requests the underlying OS to make appropriate system

call to develop the GUI & return it to the JVM. This is what we call the peer

component. As a java developer you can feel that while performing GUI

development in AWT, you are not sticking to the platform independent features &

that is why GUI looks different in different platform. A GUI contains various

components like button, check-box, text-field etc. Whenever any action is

performed on those components, listener attached to it is invoked to perform the

desired task. Again here also the task is performed by the system call of the

underlying OS. The visual display component & the action component in together is

called “LOOK & FEEL” component. So the “LOOK & FEEL” component of AWT is

platform dependent. With the introduction of JFC, the look & feel can either be

system dependent or independent. Its up to the choice of the programmer.

JFC consists of five major packages:

Swing (for the development of platform independent look & feel

component) Pluggable Look and Feel (for the development of platform dependent

look & feel component)

555

Drag and Drop (for the development of applications where you can drag the data & drop it at the required place & data is transferred to

that pace) Accessibility (useful to develop applications for physically challenged

people) 2D (for the development of 2-D applications) The geom. Class: this class is meant to develop various geometrical

shape.

Briefly about swing

For gui development programmer often uses JFC methods and constructors. This

package contains quite rich set of classes and methods for the development of

various visual objects like button text-area, check-box etc. normally these visual

objects and components light weight and fallow the MVC architecture. MVC stands

for model view controller. Model represents the state of visual objects. State

means, assume that there is a radio button in the GUI and whether it is selected

or not represents its state or model. view represents the visual appearance of

various visual objects when a state change is adapteds by them due to the action

performed by the user. For example when u select a radio button u can see the

visual change in that button . this is done by the invocation of isSelected() method.

When ever user interacts with these visual objects, the state change is first

detected by the controller. After that it is the controller which is responsible for the

display of changed visual objects present in the GUI.

JComponent:-

According to the order pf hierarchy, JComponent class resides at the top. This

class is extended by all the visual components of JFC, hence its methods &

constructors are available to them. Just check hierarchical levels in the diagram.

556

Window panes

Jframe class, the core class of javax.swing package is used to develop GUI in which

various visual objects like text field, radio button ,scroll bar , chech box , etc are

embedded . this GUI is called window pane. There are four types of window panes

are available. They are

1. Content pane

557

2. Layered pane 3. Root pane

4. Glass pane

1. Glass pane

Glass pane is designed in such a way that it appears to the user as if the

window is just pasted on the monitor. getGlassPane() method is used to

communicate with the glass pane window. If you are attaching some visual

components to the foreground of any GUI they are attached to the glass pane

window.

2. Root pane

This window resides just below the glass pane window. When programmer

attach any visual objects to the GUI such that it is appeared to be attached at

the back ground then actually root pane window contains that visual object. For

example if you are doing a moving animated picture of krish flying in the sky

then krish (a visual object) should be attached to glass pane where as the

clouds and the blue sky has to be attached to the root pane. This can be

performed by the invocation of method getRootPane() .

3 Layered pane

This pane resides beneath the root pane . normally it is used to embed a

collection of objects. We can communicate with the getLayeredPane () method.

4 Content pane

This pane lays below all the above defined planes . you can communicate with

this pane with the use of getContentPane() method .

558

whenever you are attaching any visual objects to GUI u have to attach them to one

of these panes.

Your first window

Enough theory let‟s have a programming example

import javax.swing.*;

public class window1 {


{

JFrame w1 = new JFrame(" WELCOME");

w1.setSize(300,300);

w1.setVisible(true);

}

}

Output :

559

W1 is a JFrame object created by calling the constructor of JFrame which takes the

name of the window to be displayed on the screen as it‟s argument. As the name

suggests setSize() sets the size and setVisible() makes the window visible. the

default size that is passed to the setSize() method is 0 pixel x 0 pixel .

Now there is a interesting thing associated with this program. Although you have

clicked the close button , the program is not going to removed from the memory

this is because of it‟s TSR characteristics, the program is not going to be removed

from the memory this is because of it‟s TSR characteristics. You can check it from

the process table of the task manager (windows os) or by performing ps –e in linux

system that the process javawx exists there. Some thing is lacking for the complete

termination of the program , the solution is to invoke the

setDefaultCloseOperation() method. Just see the example below




{




w1. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

}

setDefaultCloseOperation() this method upon calling removes the program from

the memory permanently. This method is called when you click the close button.

560

BoxLayout class

BoxLayoutManager provides implementation techniques to embed various visual

objects either vertically or horizontally. These visual objects or you can say the

components are not going to wrap, when the GUI is resized. Theis Layout manger

solely belongs to the JFC. It shows similarity with the FlowLayout. This Layout

facilitates to add visual objects vertically or horizontally maintaining a stack

principle. You can specify the orientation of the BoxLayout during the construction.

The predefined fields X_AXIS & Y_AXIS is used to arrange the visual objects.

BoxLayout follows the principle to maintain the optimum size of various visual

objects properties. Suppose the components are gathered around the Y_AXIS then

the automatic resizing is done by the BoxLayout class.

The following example emphasizes the utility of BoxLayout.

import java.awt.*;


import java.util.*;


class BoxDemo extends JFrame

{

public BoxDemo()

{

setTitle("Box Layout");

JPanel contentpane =( JPanel)getContentPane();

contentpane.setLayout(new BorderLayout()) ;

561

Box mainbox=new Box(BoxLayout.Y_AXIS);

JButton ok=new JButton("OK");

contentpane.add("North",ok);

JButton cancel=new JButton("CANCEL");

contentpane.add("South",cancel);

myadapter myapp=new myadapter() ;

addWindowListener(myapp);

}

private class myadapter extends WindowAdapter

{

public void windowClosing(WindowEvent e)

{

System.exit(0);

}

}


{

BoxDemo b=new BoxDemo() ;

b.setSize(400,400);

b.setVisible(true);

}

}

Output

562

Setting the back ground color

For this purpose you have to call the setBackground() method through the

object of JFrame. The parameter you have to send is the various static fields of

Color class.


import java.awt.*;

563


import java.awt.*;



{


Container c1=w1.getContentPane();

c1.setBackground(Color.green);




}

}

Output:

564

Steps to add color

Import the java.awt.* package. This package makes the setBackground()

method available to you. The background color can only be added to the container. Therefore you

have to make a container object for the window w1. This is done by calling the getContentPane () methodthrough w1. By the container object, invoke the setBackground() method. This method

takes argument as various static predefined fields of Color class.

Adding text to the window

JFC provides two ways to display text in a window frame

1. by overriding the paintComponent() method. In this technique you have to extend the JPanel class scince paintComponent() is available there.

Let’s have a coding example

First technique :


import java.awt.*;

class X extends JPanel{

public void paintComponent(Graphics g)

{

super.paintComponent(g);

g.drawString("Hello world",50,100);

565

}

}



{



X a1=new X();

c1.add(a1);





}

}

566

c

Steps

extend the JPanel class.

override the paintComponent().

Invoke the paintComponent() of JPanel class by the statement super.paintComponent().

Invoke the method drawstring() inside the overridden body of paintComponent(). This methods takes the string to be displayed along with the co ordinate position.

Inside main() create the object of the class , that has extended the JPanel class.

Create the Container object by the getContentPane().

Add the object of class X to the container by the statement c1.add(a1).

Second technique :


import java.awt.*;

public class window1 extends JFrame {

JLabel l1;

567

window1()

{

l1 = new JLabel("hello world");

}


{

window1 w1 = new window1();


c1.add(w1.l1);





}

}

steps

Extend the class JFrame .

Create an object of JLabel.

Add it to the container object. Constructor of JLabel is going to take the string to be displayed as it’s argument.

Let us have another example for TextArea in case of Swing.

568

import java.awt.*;



import javax.swing.text.*;

public class TextAreaDemo extends JFrame

{

JTextArea jtx;

public TextAreaDemo()

{

JPanel contentpane=(JPanel)getContentPane( );

contentpane.setLayout(new BorderLayout()) ;

setTitle("Text area Example");

jtx=new JTextArea( );

jtx.setFont(new Font("Arial",Font.PLAIN,14));

contentpane.add("Center",jtx);

myadapter myapp=new myadapter();


}

class myadapter extends WindowAdapter

{

public void windowCloseting(WindowEvent e)

{

System.exit(0);

}

}


569

{

TextAreaDemo tx=new TextAreaDemo( ) ;

tx.setSize(150,150);

tx.setVisible(true);

}

}

Output

JComponent class

This class belongs to the javax.swing package . Component class of awt package is it’s parent

class . hence the methods of the Component class is inherited to the JComponent class. along with the

inherited method this class has also defined it’s own methods whenever you are creating any visual

components or visual objects , donot embed that object to the frame. Rather create an window pane

and embed the visual component to it.

570

Methods add component and remove component

add(Component ) :

this method is called by the object of the container class

remove(Component) :

like add method this method is invoked by the object of the container class to remove

the specified component

removeAll() :

this method is invoked by the container object to remove all the components attached.

setLayout()

in a GUI development you have to place the visual components at certain places according to a specific

manner. The layout manager sets the visual component at the desired places in the GUI. This is done by

the invocation of setLayout() method through the object of Container class.

setBackground(): this method is used to add the back ground color to a GUI. This method takes static

color element from Color class. for example setBackground(Color.red);

setForeground() this method is similar to the setBackground() method.

setFont(Font font_obj): this method used to set different on a GUI application. This method takes the

object of Font class as its argument.

Creation of push button using JButton class

571


import java.awt.*;

public class window1 extends JFrame {

JButton b1;

window1()

{

b1 = new JButton("hello world");

}


{

window1 w1 = new window1();


c1.add(w1.b1);





}

}

Output

572

;

Creation of push button is similar to that of adding text to a GUI discussed in second technique . instead

of creating a object of JLabel you have to create the object of JButton and the rest are similar. Since I

have not registered any listener corresponding to the push button b1 no actions are going to be fired

upon pressing the push button.

Let us have another programming example.

import java.awt.*;


import java.util.*;


public class PanelDemo extends JFrame

{

public PanelDemo( )

{

setTitle("Box 1");

JPanel contentpane =(JPanel)getContentPane( );

573

contentpane.setLayout(new GridLayout());

JButton ok=new JButton("ok");

contentpane.add(ok);

JButton cancel=new JButton("CANCEL");

contentpane.add(cancel);



}


{

public void windowCloseing(WindowEvent e)

{

System.exit(0);

}

}


{

PanelDemo pd=new PanelDemo();

pd.setSize(400,400);

pd.setVisible(true);

}

}

Output:-

574

Embedding the Components

Components means the visual objects. Visual objects includes check box, text fields, radio button,

buttons etc.

Check box:

First create the object of JCheckBox by the statement JCheckBox=new JCheckBox(); the check box

created upon execution of this statement is said as blank CheckBox. it neither has a level name nor any

image is attached to it. the constructor of JCheckBox is over loaded. Other forms of the existing

constructors are:

JCheckBox a=new JCheckBox(String level_name); the argument taken by the constructor is a string

holding the level name for the check box.

JCheckBox a=new JCheckBox(String l_name, bollean status); you are already familiar with the tskof first

argument. The next argument is of boolean data type. If you send boolean true value, then the checkbox

is appread as auto selected.

575

JCheckBox a=new JCheckBox(String l_name, Image im); this constructor attach the level name along

with a image to the check box.

After creation of check box, do the modeling of check box by calling the getModel() method. This is

done by the execution of Model mm=a.getModel();

To determine whether the check box is selected or not, you have to use the isSelcted() method. This is

done by the execution of the statement boolean x=m.isSelected();

Lets have a program:


import java.awt.*;


public class window1 extends JFrame implements ActionListener {

JCheckBox cbox1,cbox2,cbox3;

JTextArea tarea;

String s1;

window1()

{

//Creation of Content pane

Container c1=getContentPane();

//Set flow lay out

c1.setLayout(new FlowLayout());

//creation of text area

tarea=new JTextArea(10,20);

// creation of two check box

cbox1=new JCheckBox("java");

cbox2=new JCheckBox("C++");

cbox3=new JCheckBox(".NET");

576

// add these visual objects

c1.add(cbox1);

c1.add(cbox2);

c1.add(cbox3);

c1.add(tarea);

//embed the listeners

cbox1.addActionListener(this);



setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

public void actionPerformed(ActionEvent ae){

if(cbox1.getModel().isSelected())s1+="java";

if(cbox2.getModel().isSelected())s1+="C++";

if(cbox3.getModel().isSelected())s1+=".NET";

tarea.setText(s1);

s1="";

}


{

window1 w1=new window1();



}

577

}

Output:

Let us have another example for the checkbox.

import java.awt.*;



578

public class CheckboxDemo extends JFrame implements ItemListener

{

JCheckbox cb;

public CheckboxDemo()

{

setTitle("check box example");

JPanel contentpane=(JPanel)getContentPane();

contentpane.setLayout(new GridLayout(2,2);

cb=new JCheckbox("Toggle");

cb.addItemListener(this);

contentpane.add(cb);



}


{


{

System . exit (0);

}

}

public void itemStateChanged(ItemEvent e)

{

if(e.getStateChange( )==ItemEvent.SELECTED)

setTitle(“checkbox selected ”);

579

else

setTitle(“Checkbox unselected”) ;

}


{

CheckboxDemo c=new CheckboxDemo() ;

c.setVisible(true) ;

c.setSize(250,250);

}

}

Output

Radio button:

580

Radio buttons are created by instanciating the object of JRadioButton class. the constructor of

JRadioButton class is overloaded. It’s various constructors are

1. JRadioButton() : this is the default constructor for JRadioButton. 2. JRadioButton(String s1) this constructorn takes String s1 as its argument. s1 serves

as the level name for the argument. 3. JRadioButton(String s1, ImageIcon i) this constructor takes another extra parameter

as image icon to the radio button. 4. JRadioButton(String s1, boolean b) the boolean value b suggests that by default the

button is selected or not See the example below


import java.awt.*;



JRadioButton cbox1,cbox2;

JTextArea tarea;

String s1;

window1()

{

//Creation of Content pane

Container c1=getContentPane();

//Set flow lay out


//creation of text area

tarea=new JTextArea(10,20);

// creation of two radio button

cbox1=new JRadioButton("java");

cbox2=new JRadioButton("C++");

// add these visual objects

581

ButtonGroup b=new ButtonGroup();

b.add(cbox1);

b.add(cbox2);

//button group is created & two button behaves as a single

group from which only one can be selected

c1.add(tarea);

c1.add(cbox1);

c1.add(cbox2);

//embed the listeners




}

public void actionPerformed(ActionEvent ae){

if(cbox1.getModel().isSelected())s1+="java";

if(cbox2.getModel().isSelected())s1+="C++";

tarea.setText(s1);

s1="";

}


{



582


}

}

Output:

If you select the c++ that is going to be displayed on the text area.

Let us have another example:

583

import java.awt.*;



public class RadioButtonDemo extends JFrame implements ActionListener

{

JRadioButton rb1,rb2;

ButtonGroup grp=new ButtonGroup();

public RadioButtonDemo()

{

setTitle("Radio Buttons Example");

JPanel contentpane=(JPanel)getContentPane();

contentpane.setLayout(new FlowLayout());

rb1=new JRadioButton("Enabled");

rb1.addActionListener(this);

rb1.setActionCommand("One Activated");

rb1.setSelected(true);

contentpane.add(rb1);

rb2=new JRadioButton("Disabled");

rb2.addActionListener(this);

rb2.setActionCommand("Two Activated");

contentpane.add(rb2);

grp.add(rb1);

grp.add(rb2);



}

584


{


{

System.exit(0);

}

}

public void actionPerformed(ActionEvent e)

{

if(e.getSource()==rb1)

{

setTitle("First radio button enabled.");

rb1.setEnabled(false);

rb2.setEnabled(true);

}

else if(e.getSource()==rb2)

{

setTitle("Second radio button enabked.");

rb1.setEnabled(false);

rb2.setEnabled(true);

}

}


{

RadioButtonDemo rb=new RadioButtonDemo();

rb.setSize(300,300);

585

rb.setVisible(true);

}

}

Output:

Navigation through LOOK and FEEL

Swing facilitates plaf, it means plugable look and feel. The visual appearance of a GUI along with it’;s

visual objects is called LOOK components . when a event is fired or generated on any of those visual

objects , the mechanism through which the event is handeled is termed as FEEL component . swing

facilitates 3 types of LOOK and FEEL .

1 :Mmetal LOOK and FEEL

2: Motif LOOK and FEEL

3: Window LOOK and FEEL

586

Since everything in java are class and objects therefore the above mentioned LOOK and FEELs

are clases of javax.swing.plaf package . the default look and feel choosed whenever we design a swing

application is metal. setLookAndFeel() is used to change the default LOOK and FEEL component of swing

application.

Inorder to have the Motif Look and Feel you have to send the string

“com.sun.java.swing.plaf.motif.MotifLookAndFeel”

As a argument to setLookAndFeel().

For windows Look and Feel the string is “com.sun.java.swing.plaf.windows.windowsLookAndFeel”

Then you have to invoke the updateComponentTreeUI() to incorporate the change.

Now let’s have a example


import java.awt.*;


import javax.swing.plaf.*;

public class window1 extends JFrame implements ItemListener {

JButton button;

JCheckBox cBox;

JTextField tF;

JRadioButton rb1,rb2,rb3;

ButtonGroup bGroup;

Container c;

window1(){

//create the content pane

c=this.getContentPane();

587

//set the appropiate lay out manager

c.setLayout(null);

//embed visual objects

button=new JButton("BUTTON");

cBox=new JCheckBox("check box");

tF=new JTextField();

rb1=new JRadioButton();

rb2=new JRadioButton();

rb3= new JRadioButton();

//Design a button group & add all the radio button to that group

bGroup=new ButtonGroup();

bGroup.add(rb1);

bGroup.add(rb2);

bGroup.add(rb3);

// locate each visual component on the GUI

button.setBounds(100,50, 80, 50);

cBox.setBounds(100, 1000, 1000, 50);

tF.setBounds(100, 150, 100,40);

rb1.setBounds(50, 250, 100, 30);

rb2.setBounds(150, 250, 100, 30);

rb3.setBounds(250, 250, 100, 30);

// embed these visual objects to the content pane

c.add(button);

c.add(tF);

588

c.add(cBox);

c.add(rb1);

c.add(rb2);

c.add(rb3);

// embed the listener

rb1.addItemListener(this);



this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

public void itemStateChanged(ItemEvent ie)

{

try{

if(rb1.getModel().isSelected())

UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel

");


UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLook

AndFeel");


UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.Windows

LookAndFeel");

SwingUtilities.updateComponentTreeUI(c);

}catch(Exception e){}

}

public static void amin(String[] args)

589

{



w1.setTitle("My Window");


}

}

Execute the codes to go through various available look & feel

component.

The JTable class

To create tables for a GUI based application JTable class is

used. The constructor of the JTabe class is called to create the table

object. Each table consists of rows and column.

Methods associated with JTable class

1. getRowCount() : this method is invoked by the table object. It

returns the number of rows present in that table. it’s return

type is integer.

2. getColumnCount() : similar to the getRowCount() it returns the

number of columns present in the table.

590

3. getColumnName(int i) : this method takes the index number of

the column number as it’s argument and returns the name of the

column in the form of string.

4. getTableHeight() : this method returns the length of the table

in terms of pixel. it’s returns type is integer.

5. getSelectedColumn() : this method is invoked by the JTable

object.this method returns the index number of the column

which is selected on the GUI. If no column is selected then

this method is going to return -1.

6. getSelectedColumns() : this method returns an array of

integers . this array contains the index number of all the

selected columns.

7. getSelectedRows() : this method returns an array of integers .

this array contains the index number of all the selected rows.

8. setValueAt(Object data , int row_index , int column_index) :

this is used to put the data in the specified position of the

table.

JTabbedPane class

When you instanciate the JTabbedPane class, the visual object

of this class is encapsulated with tabs. GUI developed by this

class is called JTabbed frame. This class contains some

predefined fields such as

JTabbedPane.TOP,JTabbedPane.BOTTOM,JTabbedPane.LEFT ,

JTaabbedPane.RIGHT.

These fields are used to embed the tabs in the position

indicated by the fields.

Methods

1 add() : this method is used to add tabs to a specific

position in the frame. This method is overloaded in this

class. other versions of this method takes strings and image

as argument for the name of the tabs and icons.

591

2 removeTabAt( int i) : this method is invoked through the

object of the JTabbedPane class. the argument I indicates the

index of the tab to be removed from the frame .

3 removeAll() : this method removes all the tab from the

component pane

4 remove ( Component c) : this method is used to remove a

specific component from the tabbed pane.

5 getTabCount() : this method is invoked by the object of

the JTabbedPane class to count the number of tabs present in

the tabbed pane .

6 getSelectedIndex( ) : this method returns the index

number of the selected tabs from the JTabbedPane.

7 getComponentAt( int i) : This method returns the visual

object or component associated with the index i.

8 setComponentAt(int index,Component c) This method is used

to embed a visual object or a component at the position

specified by the index i.

Programming example:


import java.awt.*;


public class TabbedDemo extends JFrame

{

592

JTabbedPane fpane=new JTabbedPane();

JPanel First=new JPanel();

JPanel Second=new JPanel();

JPanel Third=new JPanel() ;

public TabbedDemo()

{

getContentPane().setLayout(new BorderLayout());

fpane.addTab("First",First) ;

fpane.addTab("Second",Second) ;

fpane.addTab("Third",Third) ;

fpane.setSelectedIndex(0) ;

getContentPane().add(fpane,BorderLayout.CENTER);

myadapter myapp=new myadapter() ;

addWindowListener(myapp) ;

}


{


{

System.exit(0);

}

}

void makePane(String thestring)

{

TabbedDemo newtab=new TabbedDemo();

newtab.setVisible (true) ;

593

newtab.setSize (400,400) ;

}


{

TabbedDemo td=new TabbedDemo();

td.setSize(250,200);

td.setVisible(true);

}

}

Output:-

JSplitPane class

594

This class is used to divide the GUI or the window in exactly two

parts but not more than that. Splitting is done in two ways

horizontal splitting process : in this process it splits the

window into two parts horizontally.

Vertical splitting process : in this process it splits the window

into two parts vertically.

Methods

1 setDividerLocation( int pix) : this method sets the divider

location between two components.

2 getDividerLocation( ) : this method is used to get the

divider location.

3 getTopComponent() : this method is used to deal with the

top or left component.

4 getButtomComponent() : this method is used to deal with

the buttom or right component .

5 remove() : this method is used to remove the component from

the split pane.

6 remove(int i) removes the component specified by the index

i.

595

7 setTopComponent(Component object) : deploy the component at

top of the frame.

8 setBottomComponent(): deploy the component at bottom of the

frame.

9 setLeftComponent():deploy the component at left of the

frame.

10 setRightCompnent():deploy the component at right of the

frame.


import java.awt.*;


import javax.swing.plaf.*;


String st1="This is my area to write java code";

JButton button;

JTextArea tA;

JSplitPane jsp;

window1(){

Container c;

//create the content pane

c=this.getContentPane();

//set the appropiate lay out manager

c.setLayout(new BorderLayout());

596

//embed visual objects

button=new JButton("BUTTON");

tA=new JTextArea("this is the text area");

jsp=new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, button, tA);

jsp.setDividerLocation(300);

c.add("CENTER",jsp);

button.addActionListener(this);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

public void actionPerformed(ActionEvent ie)

{

tA.setText(st1);

}

public static void amin(String[] args)

{



w1.setTitle("My Window");


}

}

597

JTreeClass

JTreeClass implements the graphical tree structure to display various

nodes in a hierarchical manner. Each node represents the data or

entity or some text. You can design the graphical tree structure of

directory structure present in a partition by the use of methods &

constructors in this class.

Normally when you want to display the entities in tree structure, then

two stage approaches is followed. In first stage the root is developed

& in second stage Childs are spawned from the root node. To create a

root node the JTree() constructor is invoked. In the next stage to

spawn child the constructor of DefaultMutableTreeNode() is invoked.

The argument passed to JTree class constructor can either be the

entity of hash table containing keys & values or element of vector.

Methods of JTree class.

add(Object node): this method is invoked by the root node in

order to add a node to the root node.

getNewLeadSelectionPath() Each nodes present in the tree contains

data or element. When you select an item, this method is used to

return the path that describes the position of the element in the

tree. This method returns a TreePath object.

getLastPathcomponent(). This method returns the item or element

that is selected by the user.

getPathCount() To know the number of paths available to the

particular node.

JComboBox Class

As the name suggests this class is used to create the combo box

component for the GUI interface. You can either create an empty combo

box by

JComboBox comb=new JComboBox();

598

Or create an combo box having list of items by

JCombobox comb=new JComboBox(Object []arr); here the array contains

list of items to be displayed in the combo box.

Methods of Combo Box class

addItem(): This method is invoked by the combo box object to

add item to the combo box.

getSelectedItem(): this method is used extract an item from

the combo box, but first of all you have to select the item

to be extracted.

getselectedIndex() this method is used to extract the

element specified by the index from the combo box.

getItem(int i) This method is used to extract the element

specified by the index number I from the combo box.

getItemCount(): This method is used to count the nuber of

elements present in the combo box.

removeItem(): This method is used to remove the selected

item from the combo box.

removeAll(): This method is used to remove all the elements

present in the combo box.

JList class

This class is used to create the list of items to be displayed on the

GUI. From this list you are able to select more than item. The

constructor for creation of JList object is

JList jl=new JList();

JList() constructor when invoked through new operator is used to

create an empty list.

JList jl=new JList(Object []arr); this constructor is used to create a

list containg the array of elements suppilied by the array arr. You

can also send the object of vector to supplay the list items.

getSelectedItem():This method returns the selected item from

the list.

599

getselectedIndex(): this method is used to retun the index of

the selected item.

getSelectedValues(): this method returns the array of

selected items.

getSelectedIndices(): This method is used to return array of

indices.

import java.awt.*;


import javax.swing.event.*;

class list extends JFrame implements ListSelectionListener

{

JList j1;

JLabel j2;

Object ary[];

String mesg="";

list()

{

Container c1 = getContentPane();

c1.setLayout(null);

String s1[]={"orissa","mharastra","kerela","karnataka","goa"};

j1 = new JList(s1);

j1.setBounds(100,50,100,100);

c1.add(j1);

600

j2 = new JLabel();

j2.setBounds(50,200,400,40);

c1.add(j2);

j1.addListSelectionListener( this);


}

public void valueChanged(ListSelectionEvent ae1)

{

ary = j1.getSelectedValues();

for(int i=0;i<ary.length;i++)

{

mesg += " , " ;

mesg += (String)ary[i];

}

j2.setText("selected : "+mesg);

mesg="";

}


{

list tb = new list();

tb.setTitle("MY LIST");

tb.setSize(600,400);

tb.setVisible(true);

601

}

}

Output :

JMenu class

JMenu class is used to create the visual object of menu . after

creation this visual object is added to menu bar.

Steps to create a menu object and add it to the GUI.

602

Create a menu bar by

JMenuBar j1 = new JMenuBar();

Attach the menu bar object to the container of GUI.

C1.add(j1);

Here c1 is the Container class object

Create a JMenu object by invoking the JMenu constructor

through new operator.

JMenu jm = new JMenu(“hello”);

Add the JMenu object to the menu bar.

J1.add(jm);

JToggle Class

In case of push button when you click it the button goes to a

different state and looks as if it is pushed inwards. When re cliked

on the „pushed-button‟ it comes back to it‟s normal state.the

mechanism of toggle button is some what similar to the push button.

The button goes to the inward push state as long as you have pressed

603

the left mouse key and when you release the left mouse key the button

comes to it‟ normal state.

To create a toggle button you have to invoke the constructor and

supply the label name. another overloaded format of the constructor of

this class takes the image icon along with the label name.

import java.awt.*;



class TogleButon extends JFrame implements ActionListener

{

JToggleButton j1;

ImageIcon image1;

TogleButon()

{

Container c1 = getContentPane();


image1 = new ImageIcon("start.gif");

j1 = new JToggleButton("START / STOP", image1);

c1.add(j1);

j1.addActionListener(this);

}

604

public void actionPerformed(ActionEvent ae1)

{

ImageIcon image2 = new ImageIcon("stop.gif");

if( j1.isSelected())

j1.setIcon(image2);

else

j1.setIcon(image1);

}


{

TogleButon tb = new TogleButon();

tb.setSize(800 , 800);

tb.setVisible(true);

tb.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE);

}

}

When you 1st clicked see the out put

605

When you clicked for the 2nd time see the output.

606

JProgressBar class

Progress bars are normaly used to have a visual display of process

life that means it indicates how much percentage of a executing

process is completed , how many percentage remaining , how long it

will take to complete the entire execution of the process. You have

seen the scroll bar when you copy a file , while installing the

software , etc.

An interesting aspect is that through JFC classes java provides

vertical progress bars . ProgressBar object is created by calling the

constructor of the JProgressBar class. the various overloaded

constructors are

1. JProgressBar(); 2. JProgressBar( int X )

X indicates the orientation of the progress bar

Methods

1 . getMinimum() : this method is used to get the least value of

the progress bar.

2 . getMaximum() : this method is used to get the optimum value

of the progress bar.

3 . getOrientation() : this method is used to get the orientation


4 . getValue() : this method is used to have the current value of

the progress bar.

5 . setValue() : this method is used to set the value of the

progress bar.

607

6 . setOrientation() : this method is used to set the orientation


7. setStringPainted() : this method is used to display the

percentage of the progress of the task bar.

import java.awt.*;



public class Progress extends Object

{

public static void main (String args[ ])

{

JFrame frame =new JFrame("ProgressMonitor Example");

JButton button=new JButton("Start");

frame.getContentPane().add(button,BorderLayout.CENTER);

int min = 0;

int max = 100;

String[] message=new String[2];

message[0]="performing Operation.";

message[1]="This may take some time ...";

final ProgressMonitor monitor=new ProgressMonitor(frame,

message,"Iteration",min,max );

final Runnable runnable=new Runnable( )

{

public void run ( )

608

{

int sleepTime = 500;

for(int i=1;i<100;i++)

{

try{

monitor.setNote( "Iteration" + i);

monitor.setProgress( i );

if(monitor.isCanceled( ))

{

monitor.setProgress( 100 );

break;

}

Thread.sleep( sleepTime );

}catch(InterruptedException dontcare )

{

}

}

}

//monitor.close( );

};

button.addActionListener( new ActionListener ( )

{

public void actionPerformed(ActionEvent event)

{

Thread thread = new Thread(runnable);

thread.start( );

609

}

} );

//show the frame.

frame.pack( );

frame.setVisible( true );

}

}

Output

JColorChooser class

This class is used to select different colors available in the Color

menu bar.

The constructors of this class are

1. JColorChooser() 2. JColorChooser(java.awt.Color) 3. JColorChooser(javax.swing.colorchooser.ColorSelectionModel)

610

This class provides three String type constants for selecting the

model for the color. These are

1. Public static final java.lang.String SELECTION_MODEL_PROPERTY 2. Public static final java.lang.String PREVIEW_PAEL_PROPERTY 3. Public static final java.lang.String CHOOSER_PANELS_PROPERTY

Example-13



import java.awt.*;

import java.lang.*;

public class ColorChooserDemo extends JFrame

{

public ColorChooserDemo( )

{

setTitle("JColorChooser Example");

JColorChooser jcc = new JColorChooser( );

JPanel content=(JPanel)getContentPane( ) ;

content.add(jcc,"Center");

}


{

JFrame jf = new JFrame("JColorChooser Example"):

ColorChooserDemo c = new ColorChooserDemo();

c.setVisible(true);

}

}

611

Output

Dealing with the keyboard events

612

Normally an user interacts with the system by entering data through

the keyboard. When you press a key, an interrupt is generated and

propagates to the operating system.Upon receiving the interrupt

signal, the os invokes the appropriate interrupt service routine

through device driver. The JVM hides this complex techniques from the

programmer by providing listener interfaces and event handling

methods.

In java the generated interrupt is termed as event. Each event is

closely entangled with a listener object. All these listener

interfaces and event handling classes belongs to the java.awt.event

package. when you press a key, an event is generated according to the

status of the key and the value of the key. Status of the key

indicates whether a key is pressed or released and the represents

which key is pressed.

A state of a key can be determined by various methods available in

the java.awt.event package. for detailed description the reader‟s

can go through the chapter-26.

The value attribute represents the key that has been pressed.

VK_A to VK_Z holds the logical value of the key between A to Z.

VK_0 to VK_9 holds the logical value of the key between 0 to 9.

VK_F1 to VK_F12 holds the logical value of the key between F1 to F12.

VK_HOME holds the logical value of the key HOME

VK_END holds the logical value of the key END

613

VK_PAGE_UP holds the logical value of the key PAGE_UP

VK_PAGE_DOWN holds the logical value of the key PAGE_DOWN.

VK_INSERT holds the logical value of the key INSERT

VK_CAPS_LOCK holds the logical value of the key CAPS_LOCK

VK_ALT holds the logical value of the key ALT

VK_CONTROL holds the logical value of the key CONTROL

VK_SHIFT holds the logical value of the key SHIFT

VK_TAB holds the logical value of the key TAB

VK_LEFT holds the logical value of the key LEFT ARROW

VK_RIGHT holds the logical value of the key RIGHT ARROW

VK_UP holds the logical value of the key UP ARROW

VK_DOWN holds the logical value of the key DOWN ARROW

VK_ESCAPE holds the logical value of the key ESCAPE

614

We can also get the logical value behind the keycodes such as VK_F1

for F1, VK_SHIFT for SHIFT and etc. in the form of a String by the

following predefined method:

Static String getKeyText(int keycode)

Example:-

import java.awt.*;



class window1 extends JFrame implements KeyListener

{

Container cnt;

JTextArea txt;

String st1=””;

window1()

{

cnt=getContentPane();

txt=new JTextArea(“ please press a key:”);

txt.setFont(new Font(“Arial”,Font.BOLD,20));

cnt.add(txt);

615

txt.addKeyListener(this);

}

public void keyPressed(KeyEvent kee)

{

int keycode1=getKeyCode();

if(keycode1==KeyEvent.VK_F1) st1+=”The F1 key”;



if(keycode1==KeyEvent.VK_PAGE_UP) st1+=”page-up”;

if(keycode1==KeyEvent.VK_PAGE_DOWN) st1+=”page-down”;

if(keycode1==KeyEvent.VK_ALT) st1+=”the Alter key”;

if(keycode1==KeyEvent.VK_HOME) st1+=”the HOME key”;

if(keycode1==KeyEvent.VK_END) st1+=”the END key”;

}

public void keyReleased(KeyEvent kee)

{}

public void keyTyped(KeyEvent kee)

{}

public static void main(String arg[])

{

KeyBoardEvents kkk=new KeyBoardEvents();

kkk.setVisible(true);

616

kkk.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

}

Just run code & see the ouput.

MessagePane

MessagePane allows the programmer to develop the GUI, such that when a

particular event is fired with respect to a visual object, a MessageBox is poped-up

instantly.

Various methods of the MessageBox

Method Description

public static void

showMessageDialog(Component c1,

Object msg1)

C1 determines the visual object or the

frame to be poped-up and msg1

represents the message to be

displayed.

617

public static void

showMessageDialog(Component

c1, Object msg1, String title1, int

messageType1)




displayed. title1 represents the title of

the box and message_type1 is used to

display the exact type of the message

like ERROR_MESAGE,

INFFORMATION_MESSAGE,

WARNING_MESSAGE,

QUESTION_MESSAGE,

or PLAIN_MESSAGE

public static void

showMessageDialog(Component c1,

Object msg1, String title1, int

message_type1, Icon icn)




displayed. title1 represents the title of

the box and message_type1 is used to

display the exact type of the message

like ERROR_MESAGE,

INFFORMATION_MESSAGE,

WARNING_MESSAGE,

QUESTION_MESSAGE,

or PLAIN_MESSAGE. Here, icn is used

to display the picture as an icon for tht

particular message box.

618


import java.awt.*;

import java.lang.*;

public class MessagePaneDemo extends JPanel implements ActionListener

{

public MessagePaneDemo( )

{

JButton b1 = new JButton("Click here");


add(b1);

}


{

JOptionPane.showMessageDialog(this,"Hai,See The

Message","Informational Message pane",JOptionPane.INFORMATION_MESSAGE);

}

public Dimension getPerferredSize( )

{

return new Dimension(100,60);

}

public static void main(String s[])

619

{

JFrame frame = new JFrame("Information");

MessagePaneDemo panel=new MessagePaneDemo( );

frame.setForeground(Color.black);

frame.setBackground(Color.lightGray);

frame.addWindowListener(new WindowCloser( ) );

frame.getContentPane().add(panel);

frame.setSize(panel.getPreferredSize());

frame.setVisible(true);

}

}

class WindowCloser extends WindowAdapter

{

public void WindowClosing(WindowEvent e)

{

Window win=e.getWindow( );

win.setVisible(false);

System.exit (0);

}

}

Output

620

JOptionPane

A JOptionPane class is used to design option pane dialog box which is encapsulated

with four major visual objects.

The Icon object

The Message object The Input object The Option object

Each of these objects is stored in their respected areas as shon in the following

diagram.

Icon

Area

Message Area

621

Option Attributes

JOptionPane class contains various predefined fields which are used to configure the pane prior it is

displayed. You have to to remember these fields to work in different option panes.

Input Area

Options Area

622

623

The option type for an OptionPane is used to determine the buttons to be displayed

in the option button‟s area. There are four defaults setting for this value. We can

also create our own button combinations if we use a generic option pane. Each

default value is defines as a class variable for JOptionPane.

Example-11


624


import java.awt.*;

import java.1ang.*;

public class Confirm extends JPanel implements ActionListener

{

public Confirm( )

{

JButton b1 =new JButton("click here");

b1.addActionListener (this);

add (b1);

}

public void actionPerformed (ActionEvent e)

{

int result;

result =JOptionPane.showConfirmDialog(this,”Continue”);

switch(result)

{

case JOptionPane.YES_OPTION:

System.out.println(“Yes Button was pressed”);

break;

case JOptionPane.NO_OPTION:

System.out.println(“No Button was pressed”);

break;

case JOptionPane.CANCEL_OPTION:

System.out.println(“Cancel Button was pressed”);

break;

625

case JOptionPane.CLOSED_OPTION:

System.out.println(“Dialog closed”);

break;

}

}

public Dimension getPreferredSize( )

{

return new Dimension (100, 60);

}

public static void main(String s [ ])

{

JFrame frame =new JFrame (“Confirm Dialog”);

Confirm panel =new Confirm ( );


frame.setBackground(Color.lightGrey);

frame.addWindowListener (new WindowCloser ( ));

frame.getContentPane ( ).add(panel,”Center”);

frame.setSize(panel.getPreferredSize( ) );

frame.setVisible (true);

}

}


{

public void windowCloseing(WindowEvent e)

{

626

Window win =e.getWindow( );


System.exit( 0);

}

}

Output:

Let us have another programming example which shows another task of the

JOptionPane.



import java.awt.*;

import java.lang.*;

public class InputDialogDemo extends JPanel implements ActionListener

{

627

public InputDialogDemo( )

{

JButton b1=new JButton("Click here");


add(b1);

}


{

String output;

output=JOptionPane.showInputDialog(this,"Enter your favorite

place");

if((output==null)||(output.lenght()==0))

{

System.out.println("zero data: ");

System.out.println("Enter data in the text field ");

}

else

{

System.out.println("Entered data is :" + output);

}

}

public Dimension getPreferredSize( )

{

return new Dimension(100, 60);

}

public static void main(String s[ ] )

628

{

JFrame frame = new JFrame("Confirm Dialog");

InputDialogDemo panel = new InputDialogDemo( );


frame.setBackground(Color.gray);

frame.addWindowListener(new WindowCloser( ) );

frame.getContentPane( ).add(panel,"Center");

frame.setSize(panel.getPreferredSize( ) );

frame.setVisible(true);

}

}


{


{

Window win = e.getWindow( ) ;


System.exit(0);

}

}

Output

629

630

Chapter-28

Java.net

Introduction to Networking

A group of computer connected by cable to share the information is popularly

known as network. A network is a set of computers and peripherals, which are

physically connected together. Networking enables sharing of resources and

communication. Internet is a network of networks. Java applets can be downloaded

from a Web site. This is one of the main attractions of java. Networking in java is

possible through the use of java .net package. The classes within this package

encapsulate the socket model developed by Berkeley software Division. Network

required some components, such as

Server

Client Peer

Protocol Physical Media Physical Devices

Servers provide services to the client. If the server provides application services

then server is treated as Application Server.

Client access services from the Server. Peer is a computer that works as a

server and also as a client.

Protocols

Communication between computers in a network or a different network requires

certain set of rules called protocols. Java networking is done using TCP/IP protocol.

Examples of different types of protocol available in TCP/IP are, HTTP (Hyper Text

Transfer Protocol – enables interaction with the Internet), FTP (File Transfer

Protocol – enables transfer of files between computers), SMTP (Simple Mail Transfer

Protocol – provide e-mail facility), NNTP (Network News Transfer Protocol – acts as

a bulletin board for sharing news), TCP (Transmission Control Protocol – acts as

communicating data from source to destination within the network) and UDP (User

Datagram Protocol – acts as communicating data from source to destination within

the network).

631

Port Number:

A computer is identified by its 32 bits IP address through which the programmer

can deliver the data to the destination computer within the network and outside the

network. Whereas the port is the 16 bit number, which is used by the TCP or UDP

to deliver the data to the appropriate application. Generally the port having three

meaning.

As a verb, port is a communicating channel between two application.

In the context of the hardware, port takes the input from the input devices and loaded in the memory through the CPU.

In the context of TCP or UDP, data is transmitted to the appropriate

application within the network or outside the network. Port number ranges from 0-65535. Whereas the registered ports are in between

1-1023. Specific ports are assigned to some protocols by TCP/IP. A few example

are port number 21 is assigned for FTP, 23 is assigned for Telnet, 25 is assigned for

e-mail, 80 for HTTP and so on. Each protocol establishes specific set of rules to

communicate. For example, to transfer hypertext pages and images, web browsers

and servers use the HTTP protocol.

Client/Server

A computer, which requests for some service from another computer, is called a

client. The one that processes the request is called Server. A server waits till one of

its clients makes a request. It can accept multiple connections at a time to the

same port number. Multithreading is used to serve multiple users at the same time

IP Address

Each and every computer connected within a network has a unique IP address. It is

similar to every student of a batch having a unique id. An IP address is a 32-bit

number which has four numbers separated by periods. It is possible to connect to

the Internet either directly or by using Internet Service Provider. By connecting

directly to the Internet, the computer is assigned with a permanent IP address. In

case connection is made using ISP, it assigns a temporary IP address for each

session. A sample IP address is given below.

632

80.0.0.53

.

Domain Naming Service

It is very difficult to remember the IP address to connect to the Internet. The

Domain Naming Service (DNS) is used to overcome this problem. DNS maps one

particular IP address to a string of characters which is popularly known as domain

name. For example, www.yahoo.com implies com is the domain name reserved

for US commercial sites, yahoo is the name of the company and www is the name

of the specific computer, which is yahoo‟s server.

InetAddress

There are classes provided in java to enable networking. They are found in the java

.net package. InetAddress is one such class, which is used to encapsulate the IP

address and the DNS. To create an instance of InetAddress class, factory

methods are used, as there are no constructors available for this class. Factory

methods are conventions where static methods return an instance of that class.

Methods

static InetAddress

getLocalHost( )

Returns InetAddress object

representing local host

static InetAddress

getByName(String

hostName)

Returns InetAddress for the host

passed to it.

IP address

633

static InetAddress[]

getAllByName(String name)

Returns an array of InetAddresses

that represent all of the addresses

that a particular name resolves to.

ll the methods throw UnKnownHostException, if

they are unable to locate the host.

Program:

import java.net.*;

public class InetDemo

{

public static void main(String args[])throws UnknownHostException

{

InetAddress ia=InetAddress.getLocalHost();

System.out.println(ia);

ia=InetAddress.getByName("localhost");

System.out.println(ia);

InetAddress is[]=InetAddress.getAllByName("localhost");

for(int i=0;i<is.length;i++)

{

System.out.println(is[i]);

}

}

}

Output:

634

Datagram

Datagram is a type of packet that represents an entire communication. There is no

necessity to have connection or disconnection stages when communication using

datagrams. This is less reliable than communication using TCP/IP. There are two

classes in java, which enable communication-using datagrams. DatagramPacket is

the class, which acts as the data container, and DatagramSocket is a mechanism

used to send or receive DatagramPackets.

DatagramPacket

DatagramPacket is a class present in java.net package. This class works as a dada

container. This class is used to broken the data into small packets and send it over

the net through the DatagramSocket class. A DatagramPacket object can be

created as follows.

Constructors

The constructor of the class is overloaded.

DatagramPacket (byte data[ ], int size)

The above constructor takes a byte array and its size as its parameter.

DatagramPacket (byte data [], int size, InetAddress ia, int port)

In addition to the byte array and its size, the above constructor takes the

InetAddress and the port as its parameters.

Methods

public synchronized int getPort() Returns the port number.

public synchronized byte[] getData() Returns the data in byte format

635

public synchronized int getLength() Returns the length of the packet

public void setPort(int i) Set the port number

public void setData(byte data[]) Set the data in the packet.

DatagramSocket

The class DatagramPacket does not provide methods to send or receive data. The

DatagramSocket class takes up this job. Listed below are its constructors and some

of its methods.

Constructors

The creation of a DatagramSocket object throws a SocketException, which must

be handled.

There are two constructors of DatagramSocket class. The first constructors does

not take any parameters and is created as given below:

DatagramSocket s = new DatagramSocket( ) ;

The next constructor is given as follows.

DatagramSocket s= new DatagramSocket (int port);

Methods

public void

send(DatagramPacket d)

Dispatches the given DatagramPacket

object

public synchronized void

receive(DatagramPacket p)

Receives the given DatagramPacket object

public void close( ) Closes the socket connection

public int getPort() Returns the port number of

DatagramSocket

636

public InetAddress

getLocalAddress()

Return the InetAddress of the local

address.

Note - The send and receive methods of the DatagramSocket class throw an

IOException which must be caught.

Write The Server side Application

import java.net.*;

import java.io.*;

public class DataServer

{

public static DatagramSocket ds;

public static int clientport=9999,serverport=10000;


{

byte buffer[]=new byte[2300];

ds=new DatagramSocket(serverport);



System.out.println("Enter Text");

InetAddress ia=InetAddress.getByName("localhost");

while(true)

{

String s=br.readLine();

if((s==null)||s.equalsIgnoreCase("end"))

{

637

break;

}

buffer=s.getBytes();

ds.send(new DatagramPacket(buffer,buffer.length,ia,clientport));

}

}

}

Write the server side application Compile it :- javac DataServer.java Execute it:- java DataServer

Write The Client Side Application

import java.net.*;

import java.io.*;

public class DataClient1

{

public static DatagramSocket ds;

public static int clientport=9999,serverport=10000;


638

{

byte buffer[]=new byte[2300];

ds=new DatagramSocket(clientport);

System.out.println("Client is waiting for server to send data");

DatagramPacket p=new DatagramPacket(buffer,buffer.length);

while(true)

{

ds.receive(p);

String str=new String(p.getData(),0,p.getLength());

System.out.println(str);

}

}

}

Compile Client side Application:- javac DataClient1.java Execute Client side application:- java DataClient

TCP/IP

TCP/IP sockets are the most reliable, bi-directional, stream protocols. It is possible

to send arbitrary amounts of data using TCP/IP. Sockets are used for data

communication using this protocol. There are two kinds of sockets in java – a

server and a client. Java.net package used ServerSocket class through the server

waits for the client and the client connects to the server using Socket class present

in java.net package.

639

Socket Class

A Socket object establishes connection between the client and the server. In java

Socket is a communicating channel between source and destination. On a Socket

we write the data. From the Socket we read the data.

Constructors

The first constructor takes the hostname and port as its parameters to create a

Socket object. Creation of a Socket object throws an UnknowmHostException or

an IOException, which must be caught.

Socket s = new Socket (String hostName, int port);

The next constructor takes the InetAddress and port number as its parameters to

create a Socket object. The constructor throws an IOException or an

UnknowmHostException, which must be caught and handled.

Socket s=new Socket(InetAddress ia , int port);

Methods

InetAddress

getInetAddress( )

Returns InetAddress associated with

Socket object

int getport( )

Returns remote port to which this Socket

object is connected

int getLocalport ( )

Returns the local port to which the Socket

object is connected

640

InputStream

getInputStream( )

Returns the InputStream associated with

this socket

OutputStream

getOutputStream( )

Returns the outputSream associated with

this socket

void close ( ) Closes both InputStream and

OutputStream

How to read the data from Socket?

BufferedReader br=new BufferedReader (new InputStreamReader (

socket.getInputStream ()))

How to write the data on Socket?

PrintWriter out=new PrintWriter(socket.getOutputStream(),true);

ServerSocket Class

The ServerSocket object waits for the client to make a connection. An object of

this class registers itself as having an interest in client connections. Apart from

using the methods listed above, this class has accept ( ) method which is used to

wait for a client to initiate communications. The normal socket object is used for

further transfer of data.

Constructors

There are two types of constructors available. The first constructor accepts a port

number as parameter to create a ServerSocket object on that port. Creation of this

object throws an IOException, which must be caught and handled.

641

ServerSocket ss=new ServerSocket(int port) ;

The next constructor accepts a port and maximum queue length as parameters.

The queue length indicates the maximum number of client connections that the

system can have before refusing further connections.

ServerSocket ss=new ServerSocket(int port, int max) ;

Write the Server Side Application

import java.net.*;

import java.io.*;

public class FServer

{


{

ServerSocket ss=null;

try{

ss=new ServerSocket(9999);


{}

Socket s1=null;

try{

s1=ss.accept();

642

}catch(Exception e)

{}

PrintWriter out=new PrintWriter(s1.getOutputStream(),true);

BufferedReader stdin=new BufferedReader(new


System.out.println("Enter The File Name");

String s=stdin.readLine();

File f=new File(s);

if(f.exists())

{

BufferedReader d=new BufferedReader(new FileReader(s));

String line;

while((line=d.readLine())!=null)

{

out.write(line);

out.flush();

}

d.close();

}

out.close();

s1.close();

ss.close();

}

}

643

Write the server side application through ServerSocket class Compile the server side application by javac FServer.java

Execute the Server side application by java FServer

Write the client side Application

import java.net.*;

import java.io.*;

public class FClient

{


{

Socket s=null;

BufferedReader in=null;

String userinput=null;

try{

s=new Socket(InetAddress.getLocalHost(),9999);

in=new BufferedReader(new

InputStreamReader(s.getInputStream()));

}catch(Exception ue)

{

644

}

while((userinput=in.readLine())!=null)

{

System.out.println(userinput);

}

in.close();

s.close();

}

}

Compile the client side application javac FClient.java Execute the client side application java FClient

The ServerSocket object waits for a client to make a connection at some port

number 9999. Once a client makes a connection, the accept method is called to

accept the connection, after which a message is displayed giving details about the

local port number, client address and the port number of the client. The server

program requests for a file name. This file may present in the current working

directory or anywhere. A check is made at the server end and if the file exists, the

data is read by the socket object using the getInputStream () method. The transfer

of data between the client program and the server program takes using the socket

object. The client end displays the file contents. Both the programs terminate after

the request is serviced.

Communication between Server and Client application through

multithreading

645

Write the server side application

import java.awt.*;


import java.io.*;

import java.net.*;

public class AppServer extends Frame implements ActionListener,Runnable

{

Button b1;

TextField tf;

TextArea ta;

ServerSocket ss;

Socket s;

PrintWriter pw;

BufferedReader br;

Thread th;

public AppServer()

{

Frame f=new Frame("Server Side Chatting");


f.setBackground(Color.orange);

b1=new Button("Send");

b1.setBackground(Color.pink);



ta=new TextArea(12,20);

646

ta.setBackground(Color.cyan);

f.addWindowListener(new W1());

f.add(tf);

f.add(b1);

f.add(ta);

try{

ss=new ServerSocket(12000);

s=ss.accept();

br=new BufferedReader(new


pw=new PrintWriter(s.getOutputStream(),true);

}catch(Exception e)

{

}

th=new Thread(this);

th.setDaemon(true);

th.start();

setFont(new Font("Arial",Font.BOLD,20));

f.setSize(200,200);

f.setLocation(300,300);

f.setVisible(true);

f.validate();

}

private class W1 extends WindowAdapter

{


647

{

System.exit(0);

}

}


{

pw.println(tf.getText());

tf.setText("") ;

}

public void run()

{

while(true)

{

try{

ta.append(br.readLine() +"\n");

}catch(Exception e)

{

}

}

}


{

AppServer a=new AppServer();

}

}

648

Compile Server side application:- javac AppSerer.java

Execute Server side application:- java AppServer

Write the client side application

import java.awt.*;


import java.io.*;

import java.net.*;

public class AppClient extends Frame implements ActionListener,Runnable

{

Button b;

649

TextField tf;

TextArea ta;

Socket s;

PrintWriter pw;

BufferedReader br;

Thread th;

public AppClient()

{

Frame f=new Frame("Client Side Chatting");


f.setBackground(Color.orange);

b=new Button("Send") ;

b.addActionListener(this);

f.addWindowListener(new W1());


ta=new TextArea(12,20);

ta.setBackground(Color.cyan);

f.add(tf);

f.add(b);

f.add(ta);

try{

s=new Socket(InetAddress.getLocalHost(),12000);

br=new BufferedReader(new


pw=new PrintWriter(s.getOutputStream(),true);

}catch(Exception e)

650

{

}

th=new Thread(this);

th.setDaemon(true);

th.start();

setFont(new Font("Arial",Font.BOLD,20));

f.setSize(200,200);

f.setVisible(true);

f.setLocation(100,300);

f.validate();

}

private class W1 extends WindowAdapter

{


{

System.exit(0);

}

}


{

pw.println(tf.getText()) ;

tf.setText("") ;

}

public void run()

{

while(true)

651

{

try{

ta.append(br.readLine()+"\n") ;

}catch(Exception e) {}

}

}


{

AppClient a1=new AppClient();

}

}

Compile the client side application:- javac AppClient.java

Execute the client side application:- java AppClient

652

URL

URL stands for Uniform Resource Locator and it points to resource files on the

Internet. The term Web is often used when there is a discussion about the Internet.

The Web is a collection of higher level protocols and file formats. An important

aspect of a Web is its ability to locate files on the Internet. The URL helps in

locating such files using their addresses on the Net. Java provides URL class that

provides an API to access information across the Internet.

Components of URL

The URL has four components – the protocol, IP address or the hostname, port

number and actual file path. The protocols may be HTTP, SMTP, NNTP, FTP or

gopher. The most commonly used protocol of the web is the hyper text transfer

protocol (HTTP). The IP address is delimited on the let by double slashes (//) and

on the right by a slash (/) or a colon. The third component, port, is optional and is

delimited on the left by a colon and on the right by a slash. The last component

specifies the actual file path.

Given below is an example of an URL.

http://www.yahoo.com:80/root/htmlfiles/index.html

http is the protocol,www.yahoo.com is the host name, 80 is the port number and

the file index.html is stored under root/html files directory.

653

Constructors

There are four constructors and creation of a URL object throws a

MalformedURLException.

The first constructor takes the urlname as parameter and creates an object. This is

the most commonly used constructor to create the URL object.

URL u = new URL(String urlname);

The next constructor takes the name of the protocol, host name, port number and

the file path as parameters.

URL u = new URL (String protocolname, String hostname, int port, String path);

The third constructor accepts three parameters as given below.

URL u = new URL (String protocolname, String hostname, String path);

The last constructor accepts the URL object and a string.

URL u = new URL (URL urlobj, String urlspecifier);

Methods

int getPort( ) Returns specified pot number in URL /

returns – 1 if port is not explicitly set

654

String getHost( ) Returns host name specified in URL

String getFile( ) Returns the path of file specified in

URL

InputStream

openStream( )

Opens file specified in the URL

URLConnection

openConnection()

Returns the reference of

URLConnection associated with URL

object.

String getProtocol() Returns the protocol name

Program:

import java.net.*;

public class U1

{


{

URL u=new URL("http://sify.com:80/index.jsp");

System.out.println("Protocal Used Is "+u.getProtocol());

System.out.println("Host name is "+u.getHost());

System.out.println("Port Number is "+u.getPort());

System.out.println("File Name Is "+u.getFile());

}

}

655

Output:

Program:

import java.io.*;

import java.net.*;

public class ReadUrl

{


{

URL u=new URL("http://localhost:8085/ex1.jsp");


InputStreamReader(u.openStream()));

String line;

while((line=br.readLine())!=null)

{

System.out.println(line);

}

br.close();

}

}

656

URLConnection

URLConnection is an abstract class present in java.net package. It is the super class

of all classes that represents a communication link between the application and

URL. URLConnection is a general-purpose class, which provides methods to know

more about the remote resource.

Methods

InputStream

getInputStream()

Read the data from URLConnection

reference

String getContentType( ) Returns content type & return null if not

known

long getLastModified( ) Returns last modified date of object & 0 if

not known

int getContentLength( ) Returns length of content & -1 if not

known

abstract void connect() Connect the URL object

Program

import java.net.*;

import java.io.*;

public class UrlConn

{

657


{

URL u=new URL("http://localhost:8085/ex1.jsp");

URLConnection uc=u.openConnection();


InputStreamReader(uc.getInputStream()));

String line;

while((line=br.readLine())!=null)

{

System.out.print(line);

}

}

}

658

CHAPTER 29

JDBC(Java Database Connectivity)

Introduction to JDBC

JDBC stands for Java Database Connectivity .JDBC is an API whose prime task is to execute SQL statements. JDBC API contains a number of classes

and interfaces for executing SQL statements. Java Database Connectivity (JDBC) is a standard developed by Sun Microsystem. JDBC is a specification

given by Sun Microsystem and standard followed by X/Open SAG (SQL Access Group) CLI (Call Level Interface) to interact with any Database.

JDBC API lets the programmer to invoke SQL commands from Java programming language methods.

Call Level Interface is a library of function calls that supports SQL

statements. CLI requires neither host variables nor other embedded SQL

concepts that would make it less flexible from a programmer‟s perspective.

It is still possible, however, to maintain and use specific functions of a

database management system when accessing the database through a CLI.

659

The goal of creating JDBC is to create an interface that keeps simple tasks simple,

while ensuring the more difficult and uncommon tasks are at least made possible.

JDBC was developed in 1996.

Microsoft ODBC API is used to connect most of the database. But ODBC API is not

directly used with java application and applet due to numerous number of reasons.

Hence the need for JDBC came into existence.

Java and JDBC

The combination java with JDBC is very useful because it lets the programmer run

his/her program on different platforms. Java programs are secure, robust,

automatically downloaded from the network and java is an elegant language to

create database applications. JDBC API enables java applications to interact with

different types of databases. It is possible to publish vital information from a

remote database on a web page using a java applet. Some of the advantages of

using java with JDBC are

Supports a variety of Relational databases.

Easy and economical Continued usage of already installed databases

Development time is short Installation and version control simplified

There are two types of interfaces-low-level interface and high-level interface. While

high level interfaces are user-friendly, low-level interfaces are not. Java uses JDBC

API which is a low-level API interface that is used to execute various SQL

commands. JDBC API contains a number of pre defined methods where SQL

statements are passed as a parameter in String format.

JDBC Vs ODBC

The most widely used interface to access relational database today is Microsoft‟s

ODBC API. ODBC performs similar tasks as that of JDBC and yet JDBC is preferred

due to the following reasons:

ODBC API uses C interface for making the connections with number of

databases but from security and implementation point of view JDBC API was introduced.

Pointer is an integral part of ODBC whereas java never permits the programmer to use pointer.

660

On all client machines ODBC drivers are manually installed whereas JDBC drivers are installed automatically in every client machines.

JDBC Driver Models

JDBC supports two tier and three tier models.

Two tier model

In two tier model java applets and applications are directly connected with any type

of database. In two tier model client directly communicate with database server

through JDBC driver.

Three tier model

In three tier model client connect with database server through a middle tier

server, which is used for various purposes. Middle tier server performs various

functions:

It extracts the SQL commands from the clients and send these commands to

database server. Extracting the results from the database server and submit the result to the

client.

Different types of Driver Managers

JDBC API contains three components:

Application

Driver Manager

Driver.

The JDBC application through the predefined methods executes SQL Statements

and retrieves the results from the database server. Java application and applets are

connected with JDBC driver through the DriverManager. The installed JDBC driver is

JDBC compatible or not is checked through Driver component. JDBC driver is of four

different types. They are:

The JDBC-ODBC bridge plus ODBC driver Native-API partly-java driver

JDBC-Net pure java driver Native-protocol pure java driver

661

The JDBC-ODBC Bridge plus ODBC driver

This driver is popularly known as Type-1 driver. The Type-1 driver is used to bridge

the gap between JDBC-ODBC Bridge and ODBC driver. As ODBC driver installed

manually in each client machine so it is not advisable to select this Type-1 driver for

a network whose size is large.

Architecture:

If oracle is the backend and java is the frontend how the programmer set the

path.

Set path=C:\Program Files\Java\jdk1.5.0\bin;

C:\oraclexe\app\oracle\product\10.2.0\server\BIN;

Set classpath=C:\Program Files\Java\jdk1.5.0\bin;

C:\oraclexe\app\oracle\product\10.2.0\server\BIN;

Java Application

JDBC-ODBC

Driver

Native ODBC

client driver

libraries

DBMS Interface

client libraries

DBMS Interface

server libraries DBMS

662

Example-1(Type-1 Driver)

import java.sql.*;

public class Type1

{

public static void main(String ll[])

{

try{

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

Connection con=

DriverManager.getConnection("jdbc:odbc:omm","scott","tiger");

Statement st=con.createStatement();

ResultSet rs=st.executeQuery("select * from emp");

while(rs.next())

{

String name=rs.getString("ename");

int salary=rs.getInt("sal");

System.out.println("Employee Name is: "+name+" and

"+"Salary is :"+salary);

}

}catch(Exception e1)

{

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

}

}

}

663

Native-API partly-java driver

This driver is popularly known as Type-2 driver. This driver is used to convert JDBC

calls to client API for any database. Through this driver some binary code has to be

loaded in each and every client machine like the bridge driver in case of Type-1 and

hence is not suitable for large networks.

Architecture:

If oracle is the backend and java is the frontend how the programmer set the

path. In type-2 driver programmer has to install any middleware server like

weblogic server.

Set CLASSPATH=%WEBLOGIC_CLASSPATH%; %POINTBASE_CLASSPATH%;

%JAVA_HOME%\jre\lib\rt.jar;%WL_HOME%\server\lib\webservices.jar;%WL_HOME%\server\lib\ojdbc14.jar; Example-2(Type-2 Driver)

import java.sql.*;

import java.util.Properties; import javax.naming.Context;

import javax.naming.InitialContext; import javax.sql.DataSource;

public class Type2

{ public static void main(String[] args)

{

JDBC Applicaion JDBC Type-2

Driver

DBMS Client

libraries (Native)

DBMS Interface

server libraries

(Native) DBMS

664

try{

String datasource="ds1"; String pool="pool1";

Properties p=new Properties(); p.put(Context.INITIAL_CONTEXT_FACTORY,"webl

ogic.jndi.WLInitialContextFactory");

p.put(Context.PROVIDER_URL,"t3://localhost:7001");

InitialContext ctx=new InitialContext(p); DataSource source=(DataSource)ctx.lookup(datasource);

Connection con=source.getConnection(); Statement st=con.createStatement();

ResultSet rs=st.executeQuery("select * from emp"); while(rs.next())

{

String name=rs.getString("ename"); int salary=rs.getInt("sal");

System.out.println("Employee Name is: "+name+" and "+"Salary is :"+salary);

}

} catch (Exception e) {

}

} }

JDBC-Net pure Java driver

This driver is popularly known as Type-3 driver. This Type-3 driver converts JDBC

calls into DBMS independent net protocol. The middleware server converts the net

protocol to a DBMS protocol. Through this driver the middle ware server connects

with a variety of clients. Whatever protocols used in the middleware server is

vendor dependent.

665

ARCHITECTURE


import java.sql.*;

import java.util.Properties; import javax.naming.Context;

import javax.naming.InitialContext; import javax.sql.DataSource;

public class Type3 {


try{ String datasource="ds3";

String pool="pool3";

Properties p=new Properties();

p.put(Context.INITIAL_CONTEXT_FACTORY,"weblogic.jndi.WLInitialContextFactory");

p.put(Context.PROVIDER_URL,"t3://localhost:7001"); InitialContext ctx=new InitialContext(p);

DataSourcesource =(DataSource)ctx.lookup(datasource); Connection con=source.getConnection();

Statement st=con.createStatement(); ResultSet rs=st.executeQuery("select * from emp");

while(rs.next()) {

String name=rs.getString("ename");

JDBC

Applicaion

JDBC Type-3

Driver

Middleware

listener

DBMS Interface

server listener DBMS

DBMS interface

client

666

int salary=rs.getInt("sal");

System.out.println("Employee Name is: "+name+" and "+"Salary is :"+salary);

}

}catch (Exception e) {

}

} }

Native-protocol pure java drivers

This driver is popularly known as Type-4 driver. Type-4 driver converts JDBC calls

to network protocols used by the DBMS directly. This type driver supports two-tier

architecture. Through this driver client directly make requests to the database

server.

Type-3 and Type-4 Driver are the most preferred ways to access data from

databases Server.

ARCHITECTURE

Set path=C:\Program Files\Java\jdk1.5.0\bin;

C:\oraclexe\app\oracle\product\10.2.0\server\jdbc\lib\ojdbc14.jar;

JDBC Applicaion JDBC Type-4

Driver

DBMS Interface

server listener

DBMS

667

Set classpath=C:\Program Files\Java\jdk1.5.0\bin;

C:\oraclexe\app\oracle\product\10.2.0\server\jdbc\lib\ojdbc14.jar;


import java.sql.*;

class Customer

{

public static void main(string args[]) throw SQLException

{

DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());

System.out.println("Connection to the database……..");

try{

Connection cn=DriverManager.getConnection

("jdbc:oracle:thin:@rashmi:1521:orc11","sai","sai");

Statement st=cn.createStatement();

ResultSet rs=st.executeQuery("select * from emp1”);

while(rs.next())

{

String s=rs.getString(1);


}

st.close();

cn.close();

}catch(Exception ex)

668

{

System.out.println("The exception raised is : " + ex);

}

}

}

In the url, thin is the JDBC driver, rashmi is the database name, 1521 is the port

on which the connection to the database name, 1521 is the port on which the

connection is to be established and orc11 is the system ID.

“sai” is the user id and “sai” is password.

java.sql package

We have seen that the JDBC API defines a set of interfaces and classes are found in

the java.sql package.

Interfaces in java.sql

Array

This interface is used to map java array into SQL type ARRAY. This interface

contains some predefined methods:

getArray()

getBaseType() getBaseTypeName() getResultSet()

Blob

Blob is an interface present in java.sql package. An SQL BLOB is a built-in data type

that stores a Binary Large Object in a database table. The methods of this interface

are:

getBinaryStream()

getBytes() length()

669

position()

CallableStatement

CallableStatement is an interface present in java.sql

package.CallableStatements is used to call SQL stored procedures. A

CallableStatements may return a ResultSets or multiple ResultSets. Escape

syntax is used for procedures that return a parameter. This interface extends

the PreparedStatement interface. The methods in this interface include the

getXXX(where XXXstands for any datatype) methods and the following

methods.

registerOutParameter() wasNull()

Clob

Clob is an interface is present in java.sql package. In SQL CLOB is a built-in data

type that stores a Character Large Object in a database table. The methods of the

CLOB interface are:

getAsciiStream() getCharacterStream()

getSubSting() length() position()

Connection

Connection is an interface present in java.sql package. A connection is session in a

specific database engine. Information such as database tables, stored procedures

and other database objects may be obtained from a connection with the

getMetaData() methods. Some of the important methods in this interface are:

commit()

creaeStatement() getAutoCommit()

isClosed() isReadOnly()

prepareCall()

670

prepareStatement() rollback()

setAutoCommit() setReadOnly()

DatabaseMetaData

The DatabaseBaseMetaData interface provides information regarding the database

itself, such as version information, table names, and supported functions. Many of

the method of this interface return lists of information in the form of ResultSet

objects. Some of the important methods of this interface are:

getCatalogs()

getColumns() getConnection()

getDatabaseProductVersion() getDriverName() getDriverVersion()

getMaxRowSize() isReadOnly()

Driver

Every driver must implement the Driver interface. The Driver interface is used to

create connection objects. When a Driver class is loaded, first it must create an

instance of the driver and then it registered in the DriverManager. The following are

the methods present in the Driver interface.

acceptsURL()

connect() getMajorVerson() getMinorVerson()

getPropertyInfo() jdbcCompliant()

Ref

Ref is an interface present in java.sql package. This interface is a reference to an

SQL structure type value in the database. The reference of the interface is saved in

the persistent storage mechanism. The method present in this interface is

671

getBaseTypeName()

ResultSet

The ResultSet interface provides methods for the retrieval of data returned by a

SQL statement execution. A ResultSet maintains a cursor pointing to its current row

of data. The most often used methods, namely, getXXX and updateXXX methods

are present in this interface. The other important methods present in this interface

are:

absolute()

afterLast() beforeFast() cancelRowUpdate()

close() deleteRow()

insertRow() next()

previous() wasNull()

DatResultSetMetadata

The ResultSetMetaData interface is used for the collection of meta data information

associated with last ResultSet object. Some of the important methods of this

interface are:

getCatalogName() getColumnName()

getColumnCount() isNullable() isReadOnly()

SQLData

SQLData is an interface present in java.sql package. This interface is used to map

the SQL user defined data types.

672

getSQLTypeName() readSQL()

writeSQL()

SQLInput

SQLInput is an interface present in java.sql package. This interface contains an

InputStream that contains a stream oriented values. The programmer does not

invoke this interface. Rather, the driver uses it. The readXXX methods (where XXX

represents any data type) of this interface are used to read the attributes from the

input stream. Another method in this interface is:

wasNull()

SQLOutput

SQLOutput is an interface present in java.sql package. This interface used the

OutputStream for writing the attributes of user defined data types in the data base.

This interface is also used by the driver and the programmer does not invoke it

directly. The writeXXX methods (where XXX represents any data type) of this

interface are used to write data on SQLData object.

Statement

The methods of the Statement interface are used to execute SQL statements and

retrieve data into the ResultSet. A Statement can open only one ResultSet at a

time. Some of the important methods of this interface are:

cancel() close() execute()

executeBatch() executeUpdate()

getConnection() getFetchSize() getMaxRow()

673

getAttributes() getSQLTypeName()

Classes in java.sql

Date

The Date class contains methods to perform conversion of SQL date formats and

Java Date objects. The Date class contains the following important methods:

getHours() getMinutes()

getSeconds() setHours()

setMinutes() setSeconds() setTime()

toString() valueOf()

DriverManager

The DriverManager class is used to load and unload the drivers and establish the

connection with the database. The important methods of this class are:

getConnection()

getDriver() getLogStream() println()

registerDriver()

DriverPropertyInfo

The methods of the DriverPropertyInfo class are used for the insertion and retrieval

of driver properties. It is useful for advanced programmers. This class inherits its

methods from the java.lang.Object class.

674

Time

The Time class extends the Date class. It allows the JDBC to identify java.util. Date

as a SQL Time value. The methods of this class are used to perform SQL time and

java Time object conversions. The methods available in this class are

getDate() getDay()

getMonth() getMonth()

getYear() setDate() setMonth()

setTime() setYear()

toString() valueOf()

TimeStamp

The TimeStamp class also extends the Date class. It provides additional precision to

the java Date object by adding a nanosecond field. The methods of this class are:

after()

before() equals()

getNanos() setNanos() toString()

valueOf()

Types

The Types class extends the java.lang.object class. The Types class defines

constants that are used to identify generic SQL types, called JDBC types. Its

methods are inherited from the class object.

675

Exceptions in java.sql

There are four Exceptions in java.sql class. Let us see each of them in

detail.

BatchUpdateException

The BatchUpdateException extends the SQLException. When an error occurs in the

batch update operation then BatchUpdateException is thrown at runtime.

SQLException

The SQLException extends Exception. The SQLException provides information on a

database access error. The information given in the exception includes a string

describing the error, a string describing the SQLState, the error code and a chain to

the next exception.

SQLWarning

The SQLWarning extends SQLException. The SQLWarning provides information on

database access warnings and is chained to the object whose method caused it to

be report.

Steps for using JDBC

There are seven basic steps for using JDBC to access a database. They are:

Import the java.sql package

Register the driver Connect to the database

Create a statement Execute the statement Retrieve the results

Close the statement and the connection

676

Before dealing about each of these steps in detail, let us consider the following

case.

Import the java.sql package

The interfaces and classes of the JDBC API are present inside the package called

java.sql. When you want to make java-database connectivity then the programmer

is bound to import java.sql package.

import java.sql.*;

Register the driver

In java if the programmer used to register the driver then the programmer call the

static method of DriverManager class.

Syntax

DriverManager.registerDriver(Driver dr) ;

Connect to the database

The next step is to connect to the database .The getConnection() method is used

to establish the connection.

Syntax

DriverManager.getConnection(String url, String user , String passwd);

Where url is the database url of the form jdbc:subprotocol:subname,user is the

database user and passwd is the password to be supplied to get connected to the

database. The return value connected to the url.

677

Create a statement

A statement can be created using three methods, namely,

createStatement(),prepareStatement() and prepareCall().The syntax of each of

these is given below:

Syntax

cn.createStatement();

Where cn is a connection object. This method creates and returns a statement

object for sending SQL statement to database.

cn.createStatement(int rsType, int rsConcur);

Where cn is a connection object, rsType and rsConcur denote and type and

concurrency of ResultSet , respectively. This method creates a statement object

that will generate ResultSet objects with the given type and concurrency.

cn.prepareStatement(String str);

where cn is a connection object and str is a sql statement that may contain one or

more IN parameter place holders. This method creates and returns a

PreparedStatement object for sending sql statements with parameters to the

database.

cn.preparestatement(string str, int rsType , int rsConcur ) ;

Where cn is a connection object, str is a SQL statement, rsType is a result set type

and rsConcur is a concurrency type. This method creates a preparedstatement

object that will generate ResultSet objects with the given concurrency.

cn.prepareCall(string str);

678

where cn is a connection Object and is a SQL statement that may contain one or

more IN parameter placeholders. This method creates and returns a

CallableStatement object for calling database-storing procedures.

cn.preparecall(String str, int retype, int reConcur);

Where cn is a connection object, str is a SQL statement, retype is a result set type

and rsConcur is a concurrency type. It creates a CallableStatement object that will

generate ResultSet objects with the given type and concurrency.

SQL statements without parameters are normally executed using Statement

objects. If the same SQL statement is executed many times, it is more efficient to

use a PreparedStatement.

Execute the Statement

We have three methods to execute the statement. They are execute (),

executeQuery() and executeUpadate(). Let us see the syntax of these below:

Syntax

Stmt.execute();

Where stmt is a statement object. This method returns a Boolean value and is used

to execute any SQL statement.

Stmt.execute(string str);

Where stmt is a statement object and str is an SQL statement. This method is used

execute an SQL statement that may return multiple results. The return value is a

Boolean , which is true if the next result is a ResultSet and false if it is an update

count, or there are no more results.

Stmt.executeQuery();

Where stmt is a PreparedStatement object. The method returns a result set

generated by executing the query in stmt.

679

Stmt.executeQuery(string str);

This method takes query as string & is invoked by the statement object

Stmt & returns the ResultSet.

stmt.executeUpdate();

Here stmt is an object of PreparedStatement. By the object of PreparedStatement

this method executes SQL statements. In case of INSERT, UPDATE, DELETE

statement this method return value is an int, which counts the number of rows are

affected.

Stmt.executeUpdate(string str);

Here stmt is a statement object and str is a SQL statement for performing INSERT,

UPDATE or DELETE task.

Retrieve the results

The results of the SQL statements (in particular q ueries are) are stored in a

ResultSet object. To retrieve the data from the ResultSet we need to use the

getXXX methods. These methods retrieve the data and convert it to a java data

type. There is a separate getXXX methods for each data type. For example,

getString is used to retrieve the string value and getDate() is used to retrieve a

date value.The getXXX takes one argument which is the index of the column in the

ResultSet and return the value of the column. To move in to the next row in the

ResultSet we make use of the ResultSet.next() method.

Close the statement and connection

It is not absolutely necessary to close the connection. But , since open connection

can cause problem, it is better to close the connections. The close() method is used

to close the statements and connection.The syntax is given below:

Syntax

Stmt.close();

Where stmt is a statement object to be closed. This methods release stmt‟s

database.The return type is void.

Cn.close();

Where cn is the connection to be closed.

680

Executing DDL and DML Commands

Once the connection with the database is established, the user can start creating

and working with the objects of the database. In this part we will be learning how

to execute Data Definition Language (DDL) and Data Manipulation Language(DML)

commands.

DDL Commands

The DDL commands are create, alter and drop .Let us learn how to execute each of

these.

The create command is used to create database tables. Let us consider the case of

“The Rhythm”. The following are the tables needed by them:

Customer

Custld Number(3)

CustName varchar2(15)

Address varchar2(30)

Product

Prodid Number(3)

ProdName varchar2(10)

681

Price Number(5,2)

Stock-on-hand Number(4)

Transaction

TranDt Date

TranId Number(3)

ProdId Number(3)

CustId Number(3)

Qty Number(2)

The create statement for creating the above three tables are as follows:

Create table Customer (CustId Number(3), CustName varchar2(15), Address

varchar2(30));

Create table Product (ProdId Number(3),ProdName varchar2(10), Price

Number(5,2), Stock- on- hand Number(4) );

Create table Transaction (Custid Number(3),ProdId Number(3),tranid

Number(3),Qty Number(2) , TranDt Da2te);

Example-5(Create The table)

import java.sql.* ;

public class Customer1

{

public static void main(String args[])throws SQLException

{


682

System.out.println("Connection to the database…");



System.out.println("Connected to the database");

Statement st =cn.createStatement ();

try{

st.executeUpdate("create table Customer(CustId number(3),CustName

varchar2(15),Address varchar2(30))");

System.out.println(“Table Customer Created”);

}catch(SQLException ex)

{

System.out.println(“The Exception raised is “ + ex);

}

st.close();

cn.close();

}

}

Connection to the database…

Connection to the database…

Table customer created

Example-6(Table Transaction Altered)

import java.sql.*;

683

public class Customer_alt

{

public static void main(String args[])throws SQLException

{

DriverManager.registerDriver(new

oracle.jdbc.driver.oracleDriver());

try{




Statement.st=cn.createStatement();

st.executeUpdate("alter table Transaction modify(Qty

Number(4))");

System.out.println("Table Transaction altered");

}catch(Exeception ex)

{

System.out.println("The Exeception raised is:"+ ex);

}

}

}

The output is as follows:

Connected to the database

Table Transaction altered

684

Example-7(Column Dropped)

import java.sql.*;

public class Customer_drop

{

public static void main(String args[])throws SQLExeception

{

DriverManager.registerDriver(new oracle.jdbc.driver.oracleDriver());

System.out.println("Connecting to the database…..");

try{





st.executeUpdate("drop table Trans");

System.out.println("Table Trans dropped");


{

System.out.println("The exception raised is:"+ex);

}

}

}

The out put is follows:


Column amount dropped

DML Commands

685

The Data Manipulation Language Commands are the select, insert, update and

delete commands. Now the tables are created. Pioneer System Ltd. wants to input

the data in the tables. The insert command is used to input the data and the select

command is used to retrive the records from the tables.

Example-8(Insert a row in the table)

import java.sql.*;

public class CustomerInsert

{

public static void main(String args[])throw SQLException

{

DriverManager.registerDriver(new

oracle.jdbc.driver.Oracle.OracleDriver());

try{



System.out.println(“Connected to the database”);

Statement st = cn.createStatement();

st.executeUpdate("insert into customer values (100, „usha‟,

„100,Naya Bazar,Cuttack , Orissa‟)");

System.out.println("one row inserted");

st.close();

cn.close();


{

686

System.out.println(“The Exception raised is ” + ex);

}

}

}



One row inserted

Example-9(Update a row)

import java.sql.*;

import java.io.*;

public class ProductUpdate

{

public static void main(String args[])throws SQLException,IOException

{


String refValue;

String UpdateValue;

String Str;

try{

Connection cn = DriverManager.getConnection

("jdbc:oracle:thin:@:1521:orc11","sai","sai");

refValue=readEntry("Enter the Product ID: ");

updateValue=readEntry("Enter the new Price: ");

687


str="update product set price = "+ updateValue + ","+"where

prodId ="+refValue ;

st.executeUpdate(str);

System.out.println("Row Updated");

st.close();

cn.close();


{

System.out.println("The Exception raised is "+ex);

}

}

static String readEntry(String prompt)

{

try{

StringBuffer tempo=new StringBuffer();

System.out.print(prompt);

System.out.flush();

int c=System.in.read();

while (c!='\n' && c != -1)

{

tempo.append ((char)c);

c=System.in.read ();

}

return tempo.toString().trim();

}catch(IOException ex)

688

{

return "";

}

}

}

The input and output are as follows:

Enter the product id: 100

Enter the new price: 110.00

Row update

Example-10(Delete One row)

import java.sql.*;

public class CustomerDel

{

public static void main(string args[])throws SQLExeception

{


try{

Connection cn = DriverManager.getConnection




st.executeUpdate("delete from Product where ProdId=105");

System.out.println("One row deleted");

689


{

System.out.println("The Exception raised is:" +ex);

}

}

}



One row deleted

Joins and Transactions

Sometimes we need to use two or more tables to get the data. This is a case where

the join is needed. A join is a database operation that relates two or more tables by

names of values that they share in common.

Joins

There are different types of joins available in Oracle. Let us see examples of equi

join and outer join.

Example-11(Join Two Table)

import java.sql.*;

import java.io.*:

public class ListTran

{

690

public static void main(String args [])throws SQLExeception,IOExeception

{

DriverManager.registerDriver(new oracle:jdbc:driver.OracleDriver());

try{

Connection cn= DriverManager.getConnection


Statement st= cn.createStatement();

ResultSet rs = st.executeQuery("select

product.prodid,prodname,trained,qty from product,transaction where

product.proid=transaction.prodid");

System.out.println("ProdID\tProdName\t\tTranID\tQuantity");

while (rs.next())

{

System.out.Println(rs.getInt(1)+"\t"+rs.getString(2)+"\t"+

rs.getgetInt(3) + "\t" + rs.getInt(4)));

}

rs.close();

st.close();

cn.close();


{

System.out.println("the exception is " +ex);

}

}

}

The output of the program is as follows:

691

Prodid prodName TranID Quantity

001 Gajani 1 2

001 Gajani 4 3

002 Lagan 2 3

004 Mann 5 1

005 Rangeela 3 1

Transaction

In case of transaction one sql statement wait for another statement to be executed.

Let us take the instance of The Rhythm. Whenever there is a transaction, in

addition to the inserting the corresponding record in the Transaction table, the

corresponding row in the Product table should also be updated. If either of the

operations fails, then the data will become inconsistent. In order to be sure that

either both the operations are executed or neither of them is executed, we can

make use of transitions. A transaction is a set of one or more statements that are

executed together as a unit.

Cn.setAutoCommit (false) ;

Example-12(Transaction)

import java.sql.*;

import java.io.*;

public class TransCmt

{

public static void main(String args [])throws SQLException,IOException

692

{

DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver()) ;

try{



cn.setAutoCommit(false);

Statement stm=cn.createStatement();

stm.executeUpdate("Insert into transaction values(103, 101, 6, 1, '3-

jan-09‟)");


ResultSet rs;

rs=st.executeQuery("select stock_on_hand from product where

ProdId=103");

rs.next();

int i=rs.getInt(1);

i = i -1;

Statement stmt = cn.createStatement();

stmt.executeUpdate("Update Product set stock_on_hand = " + i +

"where ProdId = 103");

cn.commit();

System.out.prinln("Changes commited")

st.close();

cn.close();


{

System.out.println("The Exception raised is " + ex);

cn.rollback();

693

}

}

}


Changes commited

Conclusion:

In software development alone java is not enough. Although it provides

support for distributed web application but, it has to bridge with the data

base server. JDBC provides a common technology to communicate with any

database. If the database is changed, no matter same program will serve

your problem.

694

Chapter-30

Brain Teasers

QUESTION 1

public class Test1 {


class Foo {

public int i = 3;

}

Object o = (Object)new Foo();

Foo foo = (Foo)o;

System.out.println("i = " + foo.i);

}

}

What is the result?

A. i = 3

B. Compilation fails.

C. A ClassCastException is thrown at line 6.

D. A ClassCastException is thrown at line 7.

QUESTION 2

public class Test2{


int i =1,j =10;

695

do {

if(i++> --j) {

continue;

}

} while (i <5);

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

What is the result?

A. i = 6 and j = 5 B. i = 5 and j = 5

C. i = 6 and j = 5

D. i = 5 and j = 6

E. i = 6 and j = 6

QUESTION 3

class Test {

private Demo d;

void start() {

d = new Demo();

this.takeDemo(d);

}

void takeDemo(Demo demo) {

demo = null;

demo = new Demo();

}

696

}

When is the Demo object, created on line 3, eligible for garbage collection?

A. After line 5.

B. After line 9.

C. After the start() method completes.

D. When the takeDemo() method completes.

E. When the instance running this code is made eligible for garbage collection.

QUESTION 4

interface Animal {

void soundOff();

}

class Elephant implements Animal {

public void soundOff() {

System.out.println("Trumpet");

}

}

class Lion implements Animal {

public void soundOff() {

System.out.println("Roar");

}

}

class Alpha1 {

static Animal get( String choice ) {

if ( choice.equalsIgnoreCase( "meat eater" )) {

return new Lion();

697

} else {

return new Elephant();

}

}

}

Which compiles?

A. new Animal().soundOff();

B. Elephant e = new Alpha1();

C. Lion 1 = Alpha.get("meat eater");

D. new Alpha1().get("veggie").soundOff();

QUESTION 5

public class Test

{


{

int i = 1,j = 10;

do {

if(i>j) {

break;

}

j--;

} while (++i <5);

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

698

}

}

What is the result?

A. i = 6 and j = 5

B. i = 5 and j = 5

C. i = 6 and j = 4

D. i = 5 and j = 6 E. i = 6 and j = 6

QUESTION 6

class Test

{


{

Holder h=new Holder();

h.held=100;

h.bump(h);

System.out.println(h.held);

}

}

class Holder

{

699

public int held;

public void bump(Holder h)

{

h.held++;

}

}

What is the result ?

A. 0 B. 1 C. 100

D. 101

QUESTION 7

public class Test {

public static void aMethod() throws Exception {

try {

throw new Exception();

} finally {

System.out.println("finally");

}

}


try {

aMethod();


700

System.out.println("exception");

}

System.out.println("finished");

}

}

What is the result?

A. finally

B. exception

finished

C. finally

exception

finished

D. Compilation fails.

QUESTION 8

package test1;

public class Test1 {

static int x = 42;

}

package test2;

public class Test2 extends test1.Test1 {


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

}

701

}

What is the result?

A. x = 0

B. x = 42

C. Compilation fails because of an error in line 2 of class Test2.

D. Compilation fails because of an error in line 3 of class Test1.

E. Compilation fails because of an error in line 4 of class Test2.

QUESTION 9

public class Delta {

static boolean foo(char c) {

System.out.print(c);

return true;

}

public static void main( String[] argv ) {

int i =0;

for ( foo('A'); foo('B')&&(i<2); foo('C')){

i++ ;

foo('D');

}

}

}

What is the result?

702

A. ABDCBDCB

B. ABCDABCD

C. Compilation fails.

D. An exception is thrown at runtime.

QUESTION 10

class Test

{


{

double d=12.3;

Decrement de=new Decrement();

de.decree(d);

System.out.println(d);

}

}

class Decrement

{

public void decree(double d1)

{

d1=d1-1.0;

}

}

What is the result ?

703

A. 0.0 B. –1.0

C. 12.3 D. 11.3

QUESTION 11

public class ArrayTest {


float fl[], f2[];

fl = new float[10];

f2 = f1;

System.out.println("f2[0]= " + f2[0]);

}

}

What is the result?

A. It prints f2[0] = 0.0.

B. It prints f2[0] = NaN.

C. An error at line 5 causes compile to fail.

D. An error at line 6 causes compile to fail.

E. An error at line 6 causes an expectation at runtime.

QUESTION 12

public class Test {

public int aMethod() {

704

static int i = 0;

i++;

return i;

}

public static void main (String args[]) {

Test test = new Test();

test.aMethod();

int j = test.aMethod();


}

}

What is the result?

A. 0

B. 1

C. 2


QUESTION 13

public class Test{


boolean bool = true;

if(bool = false) {

System.out.println("a");

} else if (bool) {

705

System.out.println("c");

} else if (!bool) {

System.out.println("c");

} else {

System.out.println("d");

}

What is the result?

A. a

B. b

C. c

D. d

E. Compilation fails.

QUESTION 14

public class Xor

{


{

byte b=10;

byte c=15;

b=(byte)(b^c) ;


}

}

706

What is the output ?

A. 10 B. 5

C. 250 D. 245

QUESTION 15

class TestSuper {

TestSuper(int i) { }

}

class TestSub extends TestSuper{ }

class TestAll {

public static void main (String [] args) {

new TestSub();

}

}

Which is true?

A. Compilation fails.

B. The code runs without exception.

C. An exception is thrown at line 7.

D. An exception is thrown at line 2.

QUESTION 16

707

public class Test{


int i = 0;

for (; i <4; i += 2) {

System.out.print(i + "");

}


}

}

What is the result?

A. 0 2 4

B. 0 2 4 5

C. 0 1 2 3 4


E. An exception is thrown at runtime.

QUESTION 17

public class SwitchTest {


System.out.println("value = " + switchIt(4));

}

public static int switchIt(int x) {

int j = 1;

switch (x) {

708

case 1: j++;

case 2: j++;

case 3: j++;

case 4: j++;

case 5: j++;

default: j++;

}

return j + x;

}

}

What is the result?

A. value = 3

B. value = 4

C. value = 5

D. value = 6

E. value = 7

F. value = 8

QUESTION 18

public class Foo {


try {

return;

} finally {

709

System.out.println( "Finally" );

}

}

}

What is the result?

A. Finally


C. The code runs with no output.


QUESTION 19

public class Alpha1 {

public static void main( String[] args ) {

boolean flag; int i=0;

do {

flag = false;

System.out.println( i++ );

flag = i < 10;

continue;

} while ( (flag)? true:false );

}

}

What is the result?

710

A. 000000000

B. 0123456789


D. The code runs with no output.

E. The code enters an infinite loop.

F. An exception is thrown at runtime.

QUESTION 20

class Super {

public Integer getLenght() { return new Integer(4); }

}

public class Sub extends Super {

public Long GetLenght() { return new Long(5); }


Super sooper = new Super();

Sub sub = new Sub();

System.out.println(sooper.getLenght().toString() + "," +

sub.getLenght().toString() );

}

}

What is the output?

A. 4,4

B. 4,5

C. 5,4

711

D. 5,5


QUESTION 21

public class Test {

public static String output ="";

public static void foo(int i) {

try {

if(i==1) {


}

output += "1";

}

catch(Exception e) {

output += "2";

return;

}

finally {

output += "3";

}

output += "4";

}


foo(0);

foo(1);

712

}

}

What is the value of the variable output at line 23?

QUESTION 22

class Base {

Base()

{

System.out.print("Base");

}

}

public class Alpha extends Base {


new Alpha();

new Base();

}

}

What is the result?

A. Base

B. BaseBase




713

QUESTION 23

public class Test{


int i = 1,j = -1;

switch (i) {

case 0,1:

j = 1;

case 2:

j = 2;

default:

j = 0;

}

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

}

}

What is the result?

A. j = -1

B. j = 0

C. j = 1

D. j = 2


QUESTION 24

714

public class X {

public static void main(String [] args) {

try {

badMethod();

System.out.print("A");

}

catch (Exception ex) {

System.out.print("B");

}

finally {

System.out.print("C");

}

System.out.print("D");

}

public static void badMethod() {}

}

What is the result?

A. AC

B. BD

C. ACD

D. ABCD


Answer: C

715

QUESTION 25

public class Test{


Float f = new Float("12");

switch (f) {

case 12: System.out.println("Twelve");

case 0: System.out.println("Zero");

default: System.out.println("Default");

}

}

}

What is the result?

A. Zero

B. Twelve

C. Default

D. Twelve

Zero

Default


QUESTION 26

public class X {


716

try {

badMethod();


}



}

finally {


}


}

public static void badMethod() {

throw new RuntimeException();

}

}

What is the result?

A. AB

B. BC

C. ABC

D. BCD


QUESTION 27

717

public class Test{


for (int i =0; i <3; i++) {

switch(i) {

case 0: break;

case 1: System.out.print("one ");

case 2: System.out.print("two ");

case 3: System.out.print("three ");

}

}

System.out.println("done");

What is the result?

A. done

B. one two done

C. one two three done

D. one two three two three done


Answer: D

QUESTION 28

public class Conditional

{


{

718

int x=4;

System.out.println(“Value is ”+((x>4) ? ) 99.9 : 9);

}

}


A. Value is 99.9 B. Value is 9

C. Value is 9.0 D. Value is 99 E. Compile Time Error

QUESTION 29

class A {

final public int method1(int a, int b) {return 0; }

}

class B extends A {

public int method1(int a, int b)

{

return 1;

}

}

public class Test {

public static void main(Strings args[]) {

B b;

System.out.println("x = " + b.method1(0, 1));

}

719

}

What is the result?

A. x = 0

B. x = 1


D. En exception is thrown at runtime.

QUESTION 30

class Super {

public int getLenght()

{

return 4;

}

}


public long getLenght()

{

return 5;

}


Super sooper = new Super();

Sub sub = new Sub();

System.out.println(sooper.getLenght() + "," + sub.getLenght() );

}

720

}

What is the output?

A. 4,4

B. 4,5

C. 5,4

D. 5,5


QUESTION 31

class Test

{

static int x=10;

static{

x+=5;

}


{


}

static{

x/=5;

}

}

721


A. Compile time error

B. 10 C. 15

D. 3

QUESTION 32

public class X {


try {

badMethod();


}

catch (RuntimeException ex) {


}

catch (Exception ex1) {


}

finally {


}

System.out.print("E");

}



722

}

}

What is the result?

A. BD

B. BCD

C. BDE

D. BCDE

E. ABCDE

F. Compilation fails.

QUESTION 33

public class Test

{


{

byte a=2;

byte b=2;

byte c=a*b;

System.out.println(c);

}

}

What is the output

A. Compile time error

723

B. 4 C. 00000100

D. 0

QUESTION 34

public class Foo {

public void main( String[] args ) {

System.out.println( "Hello" + args[0] );

}

}

What is the result if this code is executed with the command line?

java Foo world

A. Hello

B. Hello Foo

C. Hello world


E. The code does not run.

QUESTION 35

public class Test{

public static void main(String ags[]){

int i = 0, j = 5;

tp;

for (;;) {

724

i++;

for(;;) {

if (i> --j) {

break tp;

break tp;

}

}

System.out.println("i=" +i ",j ="+j);

What is the result?

A. i = 1, j = 0

B. i = 1, j = 4

C. i = 3, j = 4

D. i = 3, j = 0


QUESTION 36

public class Test {

public static void main(String Args[]) {

int i =1, j = 0;

switch(i) {

case 2: j +=6;

case 4: j +=1;

default: j +=2;

725

case 0: j +=4;

}

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

}

}

What is the result?

A. 0

B. 2

C. 4

D. 6

E. 9

F. 13

QUESTION 37

class Super {

public int i = 0;

public Super(String text) {

i = 1;

}

}


public Sub(String text) {

i = 2;

}

726


Sub sub = new Sub("Hello");

System.out.println(sub.i);

}

}

What is the result?

A. 0

B. 1

C. 2


QUESTION 38

public class Test{


int i = 1,j = 10;

do{

if (i>j) {

continue;

}

j--;

} while (++i <6);

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

}

727

}

What is the result?

A. i = 6 and j = 5

B. i = 5 and j = 5

C. i = 6 and j = 4

D. i = 5 and j = 6

E. i = 6 and j = 6

QUESTION 39

public class Test

{


{

int x=0,y=4,z=5;

if(x>2)

{

if(x<5)

{

System.out.println(“Message One”) ;

}else{

System.out.println(“Message Two”);

}

}

else if(z > 5)

728

{

System.out.println(“Message Three”);

}else{

System.out.println(“Message Four”);

}

}

}


A. Message One B. Message Two

C. Message Three D. Message Four

QUESTION 40

public class X {


try {

badMethod();


}



}

finally {


729

}


}


throw new Error();

}

}

What is the result?

A. ABCD


C. C is printed before exiting with an error message.

D. BC is printed before exiting with an error message.

E. BCD is printed before exiting with an error message.

QUESTION 41

class Exc0 extends Exception { }

class Exc1 extends Exc0 { }

public class Test {


try {

throw new Exc1();

} catch (Exc0 e0) {

System.out.println("Ex0 caught");


730

System.out.println("exception caught");

}

}

}

What is the result?

A. Ex0 caught

B. exception caught

C. Compilation fails because of an error at line 2.

D. Compilation fails because of an error at line 6.

QUESTION 42

public class A {

void A() {

System.out.println("Class A");

}


new A();

}

}

What is the result?

A. Class A


731

C. An exception is thrown at line 2.

D. An exception is thrown at line 6.

E. The code executes with no output.

QUESTION 43

class Bar { }

class Test {

Bar doBar() {

Bar b = new Bar();

return b;

}

public static void main (String args[]) {

Test t = new Test();

Bar newBar = t.doBar();

System.out.println("newBar");

newBar = new Bar();

System.out.println("finishing");

}

}

What is the output?

QUESTION 44

732

interface Beta {}

class Alpha implements Beta {

String testIt() {

return "Tested";

}

}

public class Main1 {

static Beta getIt() {

return new Alpha();

}


Beta b = getIt();

System.out.println( b.testIt() );

}

}

What is the result?

A. Tested




QUESTION 45

public class Test{

public static void main(String ar[]){

733

int x = 1, y =6;

while (y--) {

x++;

}

System.out.println("x =" + x + "y =" +y);

}

}

What is the result?

A. x = 6 y = 0

B. x = 7 y = 0

C. x = 6 y = -1

D. x = 7 y = -1


QUESTION 46

public class Test{


int i = 0;

while (true) {

if(i==4) {

break;

}

++i;

}

734

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

}

}

What is the result?

A. i = 0

B. i = 3

C. i = 4

D. i = 5


QUESTION 47

public class Test{


try {

int x = 0;

int y = 5 / x;


System.out.println("Exception");

} catch (ArithmeticException ae) {

System.out.println("Arithmetic Exception");

}

System.out.println("finished");

}

}

735

What is the result?

A. finished

B. Exception


D. Arithmetic Exception

QUESTION 48

public class Alpha{

public static void main( string[] args ){

if ( args.length == 2 ) {

if ( args.[0].equalsIgnoreCase("-b") )

System.out.println( new Boolean( args[1] ));

}

}

}

And the code is invoked by using the command:

java Alpha -b TRUE

What is the result?

A. true

B. null

C. false


736

E. The code runs with no output.


QUESTION 49

public class Test{


int i = 0, j = 1;

if ((i++ == 1) && (j++ == 2)) {

i = 42;

}

System.out.println("i = " + i + ", j = " + j);

}

}

What is the result?

A. i = 1, j = 2

B. i = 1, j = 1

C. i = 42, j = 2

D. i = 42, j = 1


Answer: B

QUESTION 50

737

public class X {

private static int a;


modify(a);


}

public static void modify(int a) {

a++;

}

}

What is the result?

A. 0

B. 1



QUESTION 51

public class Test {

public static void add3 (Integer i) {

int val = i.intValue();

val += 3;

i = new Integer(val);

}


738

Integer i = new Integer(0);

add3(i);

System.out.println(i.intValue());

}

}

What is the result?

A. 0

B. 3



QUESTION 52

public class Test{


String a = null;

a.concat("abc");

a.concat("def");


}

}

What is the result?

A. abc

B. null

739

C. abcdef


E. The code runs with no output.


QUESTION 53

public class Test {


System.out.println(args.length > 4 && args[4].equals("-d"));

}

}

If the program is invoked using the command line:

java Test One Two Three -d

What is the result?

A. true

B. false



Answer: D

QUESTION 54

740

class BaseClass {

private float x = 1.of;

protected float getVar()

{

return x;

}

}

class SubClass extends BaseClass {

private float x = 2.Of;

// insert code here

}

Which two are valid examples of method overriding when inserted at comment line

? (Choose two)

A. float getVar() { return x; }

B. public float getVar() { return x; }

C. public double getVar() { return x; }

D. protected float getVar() { return x; }

E. public float getVar(float f) { return f; }

QUESTION 55

class A {

public byte getNumber() {

return 1;

741

}

}

class B extends A {

public short getNumber() {

return 2;

}


B b = new B();

System.out.println(b.getNumber());

}

}

What is the result?

A. 1

B. 2

C. An exception is thrown at runtime.


QUESTION 56

class A {

public A() {

System.out.println("hello from a");

}

}

class B extends A {

742

public B () {

System.out.println("hello from b");

super();

}

}

public class Test {


A a = new B();

}

}

What is the result when main is executed?


B. hello from a

C. hello from b

D. hello from b

hello from a

E. hello from a

hello from b

QUESTION 57

class MyThread extends Thread {

public void run()

{

System.out.println("AAA");

743

}

public void run(Runnable r)

{

System.out.println("BBB");

}


new Thread(new MyThread()).start();

}

}

What is the result?

A. AAA

B. BBB



QUESTION 58

public class X implements Runnable {

private int x;

private int y;


X that = new X();

(new Thread( that )).start();

(new Thread( that )).start();

744

}

public void run() {

for (;;) {

synchronized (this) {

x++;

y++;

}

System.out.println(Thread.currentThread().getName() + "x = " + x + ", y = " +y);

}

}

}

What is the result?


B. The program prints pairs of values for x and y that might not always be the

same on

the same line (for example, "x = 2, y = 1").

C. The program prints pairs of values for x and y that are always the same on the

same

line (for example, "x = 1, y = 1").

In addition, each value appears only once (for example, "x = 1, y = 1" followed

by "x = 2, y = 2").

The thread name at the start of the line shows that both threads are executing

concurrently.

745

D. The program prints pairs of values for x and y that are always the same on the

same line (for example, "x = 1, y = 1").

In addition, each value appears only once (for example, "x = 1, y = 1" followed

by "x = 2, y = 2").

The thread name at the start of the line shows that only a single thread is actually

executing.

Answer: D

QUESTION 59

public class A extends Thread {

A() {

setDaemon(true);

}

public void run() {

(new B()).start();

try {

Thread.sleep(60000);

} catch (InterruptedException x) { }

System.out.println("A done");

}

class B extends Thread {

public void run() {

try {

Thread.sleep(60000);

746

} catch (InterruptedException x) {}

System.out.println("B done");

}

}


(new A()).start();

}

}

What is the result?

A. A done

B. B done

C. A done

B done

D. B done

A done

E. There is no exception that the application will print anything.

F. The application outputs "A done" and "B done", in no guaranteed order.

QUESTION 60

public class Test {

private static int[] x;


System.out.println(x[0]);

747

}

}

What is the result?

A. 0

B. null


D. A NullPointerException is thrown at runtime.

E. An ArrayIndexOutOfBoundsException is thrown at runtime.

QUESTION 61

public class Test{


Object obj = new Object() {

public int hashCode() {

returns 42;

}

};

System.out.println(obj.hashCode());

}

What is the result?

A. 42

B. An exception is thrown at runtime.

C. Compilation fails because of an error on line 12.

748

D. Compilation fails because of an error on line 16.

E. Compilation fails because of an error on line 17.

QUESTION 62

public class Test {

private static float[] f = new float[2];


System.out.println("f[0] = " + f[0]);

}

}

What is the result?

A. f[0] = 0

B. f[0] = 0.0



QUESTION 63

public class Test {


String str = NULL;

System.out.println(str);

}

}

749

What is the result?

A. NULL




QUESTION 64

public class Test{


System.out.println(Math.sqrt(-4D));

}

}

What is the result?

A. -2

B. NaN

C. Infinity



QUESTION 65

public class Test{


750

String a = "ABCD";

String b = a.toLowerCase();

b.replace('a', 'd');

b.replace('b', 'c');


}

}

What is the result?

A. abcd

B. ABCD

C. dccd

D. dcba



QUESTION 66

public class Foo {


StringBuffer a = new StringBuffer ("A");

StringBuffer b = new StringBuffer ("B");

operate (a,b);

System.out.printIn{a + "," +b};

}

static void operate (StringBuffer x, StringBuffer y) {

751

x.append(y);

y = x;

}

}

What is the result?

A. The code compiles and prints "A,B".

B. The code compiles and prints "A,A".

C. The code compiles and prints "B,B".

D. The code compiles and prints "AB,B".

E. The code compiles and prints "AB,AB".

F. The code does not compile because "+" cannot be overloaded for StringBuffer.

QUESTION 67

public class Test {

public static void stringReplace (String text) {

text = text.replace ('j' , 'i');

}

public static void bufferReplace(StringBuffer text) {

text = text.append ("C")

}

public static void main (String args[]} {

String textString = new String ("java");

StringBuffer textBuffer= new StringBuffer ("java");

752

stringReplace (textString);

bufferReplace (textBuffer);

System.out.println (textString + textBuffer);

}

}

What is the output?

QUESTION 68

public class Foo {


StringBuffer a = new StringBuffer ("A");

StringBuffer b = new StringBuffer ("B");

operate (a,b);

System.out.println{a + "," +b};

}

static void operate (StringBuffer x, StringBuffer y)

{

x.append {y};

y = x;

}

}

What is the result?

753

A. The code compiles and prints "A,B".

B. The code compiles and prints "A,A".

C. The code compiles and prints "B,B".

D. The code compiles and prints "AB,B".

E. The code compiles and prints "AB,AB".

F. The code does not compile because "+" cannot be overloaded for StringBuffer.

QUESTION 69

interface Foo {

int k = 0;

}

public class Test implements Foo {


int i;

Test test = new Test ();

i= test.k;

i= Test.k;

i= Foo.k;

}

}

What is the result?

A. Compilation succeeds.

B. An error at line 2 causes compilation to fail.

C. An error at line 9 causes compilation to fail.

D. An error at line 10 causes compilation to fail.

754

E. An error at line 11 causes compilation to fail.

QUESTION 70

public class Test{

public int aMethod(){

static int i=0;

i++;

return i;

}

public static void main (String args[]){

Test test = new Test();

int j = test.aMethod();

System.out.printIn(j);

}

}

What is the result?

A. Compilation will fail.

B. Compilation will succeed and the program will print "0"

C. Compilation will succeed and the program will print "1"

D. Compilation will succeed and the program will print "2"

QUESTION 71

public class Test {

755

public static void main(string args[]) {

int 1= 0;

while (i) {

if (i==4) {

break;

}

++i;

}

}

}

What is the value of i at line 10?

A. 0

B. 3

C. 4

D. 5

E. The code will not compile.

Answer: E

QUESTION 72

public class A extends Thread

{

private int x=2;


{

756

new A().make();

}

public A()

{

x=5;

start();

}

public void make()throws Exception

{

join();

x=x-1;


}

public void run()

{

x*=2;

}

}

What is the output?

QUESTION 73

public class Loop

{

static String o="";

757


{

z:

for(int x=2;x<7;x++)

{

if(x==3)continue;

if(x==5)break z;

o=o+x;

}

System.out.println(o);

}

}

What is the output?

QUESTION 74

public class Auto

{

Boolean b1=new Boolean("yes");

boolean b=b1;

void show()

{

if(b){

System.out.println("You Need Money");;

}else{

System.out.println("You Need Knowledge");

}

758

}


{

Auto a=new Auto();

a.show();

}

}

What is the output?

QUESTION 75

interface Do2

{

float getRange(int low,int high);

}

interface DoMore

{

float getAvg(int a,int b,int c);

}

abstract class DoAbstract implements Do2,DoMore

{

}

class DoStuff implements Do2

{

public float getRange(int x,int y)

{

759

return 3.14f;

}

}

interface DoAll extends DoMore

{

float getAvg(int a,int b,int c,int d) ;

}

public class B

{


{

}

}

What is the output?

QUESTION 76

abstract class Vehicle

{

public int speed()

{

return 0;

}

}

class Car extends Vehicle

760

{

public int speed()

{

return 60;

}

}

class RacerCar extends Car

{

public int speed()

{

return 150;

}

}

public class C

{


{

RacerCar racer=new RacerCar();

Car car=new RacerCar();

Vehicle v=new RacerCar();

System.out.println(racer.speed()+","+car.speed()+","+v.speed());

}

}

What is the output?

761

QUESTION 77

public class D

{


{

Sente a=new Sente();

a.go();

Goban b=new Goban();

b.go();

Stone c=new Stone();

c.go();

}

}

class Sente implements Go

{

public void go()

{

System.out.println("go in Sente");

}

}

class Goban extends Sente

{

public void go()

{

System.out.println("go in Goban");

762

}

}

class Stone extends Goban implements Go{}

interface Go

{

public void go();

}

What is the output?

QUESTION 78

public class Demo

{


{

int x,y,z;

x=9;

y=0;

try{

z=x/y;


{

System.out.println("You can not devide an intrger by zero");

System.out.println("so using y++");

y++;

763

z=x/y;

}

System.out.println("I am executed");

}

}

What is the output?

QUESTION 79

public class Demo1

{


{

try{

int len=argts.length;

System.out.println("Length ="+len);

int con=5/len;

int mak[]={222};

mak[42]=1000;


{

System.out.println("inside catch block"+e);

}

catch(ArrayIndexOutOfBoundsException aoe)

{

764

System.out.println("Inside Catch Block"+aoe);

}

}

}

What is the output?

QUESTION 80

public class Excep

{

static void test()

{

try{

String s=null;

System.out.print(s.toString()+" ");

}finally{

System.out.print("finally");

}

}


{

try{

test();

}catch(Exception e)

{

765

System.out.print("exception");

}

}

}

What is the output?

QUESTION 81

public class F

{

public String doit(int x,int y)

{

return "a";

}

public String doit(int...vals)

{

return "b";

}


{

F ab=new F();

System.out.println(ab.doit(4,5));

}

766

}

What is the output?

QUESTION 82

public class Outer1

{

String name;

int roll;

public class Inner1

{


{

name=n;

return name;

}

int getRoll(int r)

{

roll=r;

return roll;

}

}


{

Outer1 o1=new Outer1();

767

Inner1 i1=o1.new Inner1();

System.out.println("Name Is "+i1.getName("Asit"));

System.out.println("Roll Number Is "+i1.getRoll(4));

}

}

What is the output?

QUESTION 83

public class Test

{

public enum Dogs{collie, harrier};


{

Dogs mydog=Dogs.collie;

switch(mydog)

{

case collie:

System.out.print("Collie ");

case harrier:

System.out.print("harrier ");

}

}

}

768

What is the output?

QUESTION 84

What is the result of compiling and running the following application ?

import java.awt.*;

public class Test extends Frame

{

public Test()

{

setSize(300,300);

setLayout(new GridLayout(1,2));

Panel p1=new Panel();

p1.setLayout(new FlowLayout(FlowLayout.RIGHT));

p1.add(new Button(“Hello”));

add(p1);

Panel p2=new Panel();

p2.setLayout(new FlowLayout(FlowLayout.LEFT));

p2.add(new Button(“Goodbye”));

add(p2);

}


{

Test t1=new Test();

t1.setVisible(true) ;

769

}

}

A. The program crashes by throwing an Exception , because Frame‟s default layout cannot be overridden.

B. The program crashes by throwing an Exception , because GridLayout must have at least two rows and two columns.

C. The program displays two Button which are just large enough to encompass their labels. The Buttons appear at the top of the Frame. The “Hello” Button is just to the left of the vertical midline of the Frame and the “Goodbye”

Button is just the right of the vertical midline of the Frame. D. The program displays two large Buttons. The Hello Button occupies the entire

left half of the Frame and the Goodbye Button occupies the entire right half of the Frame.

E. None of these.

QUESTION 85

What will happen if you try to compile and run the following code?

public class MyClass {

public static void main(String arguments[]) {

amethod(arguments);

}

public void amethod(String[] arguments)

{

System.out.println(arguments);

System.out.println(argumen ts[1]);

}

1) error Can't make static reference to void amethod.

2) error method main not correct

3) error array must include parameter

770

4) amethod must be declared with String

QUESTION 86

What will be printed out if this code is run with the following command line?

Java myprog good morning

public class myprog

{

public static void main(String argv[])

{

System.out.println(argv[2]);

}

}

1) myprog

2) good

3) morning

4) Exception raised: "java.lang.ArraylndexOutOfBoundsException: 2"

QUESTION 87

class Test1

{

public void start()

{

System.out.println(“Java”);

}

771

}

public class Test extends Text1

{

public void start()

{

System.out.println(“Sai”);

}


{

((Test1)new Test()).start();

}

}

What is the output?

QUESTION 88

interface Task1

{

String toString();

}

public class Task

{


{

System.out.println(new Task1()

{

772

public String toString()

{

return "Java";

}

});

}

}

What is the output?

QUESTION 89

public class Check

{


{

S1 a=new S1();

a.go();

S2 b=new S2();

b.go();

S3 c=new S3();

c.go();

}

}

interface Go

{

773

void go();

}

class S1 implements Go

{

public void go()

{

System.out.println("Java") ;

}

}

class S2 extends S1

{

public void go()

{

System.out.println("C");

}

}

class S3 extends S2 implements Go

{

}

774

What is the output?

QUESTION 90

public class Text

{

int i=12;

public void show(int i)

{

i+=i;


}


{

Text t=new Text();

t.show(10);

}

}

What is the output?

QUESTION 91

public class Boot1

{

775

int i;

String s;

public Boot1()

{

this("Java") ;

System.out.println("First");

}

public Boot1(String s1)

{

this(1,"See Java Program");

System.out.println("Second");

}

public Boot1(int i1,String s1)

{

i=i1;

s=s1;

System.out.println("Third");

}


{

Boot1 b=new Boot1();

System.out.println(b.s+"\t"+b.i);

}

}

What is the output?

776

QUESTION 92

public class N1

{


{

String str="null";

if(str==null)

{

System.out.println("null");

}

else if(str.length()==0)

{

System.out.println("zero");

}

else{

System.out.println("Java") ;

}

}

}

What is the output?

QUESTION 93

public class Loop1

{

777


{

int x=0;

int y=10;

do{

y--;

++x;

}while(x<5);

System.out.println(x+"\t"+y);

}

}

What is the output?

QUESTION 94

import java.util.*;

public class Col1

{

public static Iterator reverse(List l)

{

Collections.reverse(l) ;

return l.iterator();

}

public static void main(String r[])

{

List l1=new ArrayList();

778

l1.add("1");

l1.add("2");

l1.add("3");

for(Object obj : reverse(l1))

{

System.out.print(obj+"\t");

}

}

}

What is the output?

QUESTION 95

import java.util.*;

public class Col2

{

public static Collection get()

{

Collection sorted=new LinkedList();

sorted.add("B") ;

sorted.add("C") ;

sorted.add("A");

return sorted;

}


{

779

for(Object obj: get())

{

System.out.print(obj+"\t");

}

}

}

What is the output?

QUESTION 96

import java.io.*;

class Excep1

{

public void process()

{

System.out.print("A,");

}

}

public class Excep extends Excep1

{

public void process()throws IOException

{

System.out.print("B,");

throw new IOException();

}

public static void main(String arg[])

780

{

try{

new Excep().process();


{

System.out.println("Exception");

}

}

}

What is the output?

QUESTION 97

public class Process

{

static class A

{

void process()throws Exception

{


}

}

static class B extends A

{

void process()

781

{

System.out.println("B") ;

}

}


{

new B().process();

}

}

What is the output?

QUESTION 98

public class Ex1

{

static void test()throws RuntimeException

{

try{

System.out.print("Test") ;


}catch(Exception e)

{

System.out.println("Caught");

}

}


782

{

try{

test();

}catch(RuntimeException re)

{

System.out.println("Runtime ");

}

System.out.println("End");

}

}

What is the Output?

QUESTION 99

import java.io.*;

class Tree

{

}

public class Forest implements Serializable

{

private Tree t=new Tree();


{

Forest f=new Forest();

try{

783

FileOutputStream fos=new FileOutputStream("A.txt");

ObjectOutputStream oos=new ObjectOutputStream(fos) ;

oos.writeObject(f);

oos.close();

}catch(Exception e)

{

e.printStackTrace();

}

}

}

What is the output?

QUESTION 100

import java.io.*;

public class Serial implements Serializable

{

public int i,j;

static ObjectInputStream ois;

static ObjectOutputStream oos;

public Serial(int i,int j)

{

this.i=i;

this.j=j;

}

private void writeObject(ObjectOutputStream oos)throws IOException

784

{

this.oos=oos;

oos.writeInt(i);

oos.writeInt(j);

}

private void readObject(ObjectInputStream ois)throws

IOException,ClassNotFoundException

{

this.ois=ois;

i=ois.readInt();

j=ois.readInt();

System.out.println(i+"\t"+j);

}


{

Serial s1=new Serial(12,7);

s1.readObject(ois);

s1.writeObject(oos);

}

}

What is the output?

Documents

core java