core java
Post on 27-Nov-2014
923 Views
Preview:
TRANSCRIPT
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];
char item2_name[20];
char item3_name[20];
char item4_name[20];
char item5_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 {
public static void main(String[]args)
{
int x=12;
System.out.print(-+x);
}
}
Output: -12
class Demo {
public static void main(String[]args)
{
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
System.out.println(i);
}
}
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
{
public static void main(String args[]){
int i=6;
int j=++i;
System.out.println(i);
System.out.println(j);
}
}
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
{
public static void main(String args[]){
int i=6;
i=++i;
System.out.println(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
{
public static void main(String args[])
{
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
System.out.println(i);
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
{
public static void main(String args[])
{
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{
public static void main(String args[])
{
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{
public static void main(String args[])
{
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
public static void main(String[]args)
{
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 {
public static void main(String[]args)
{
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
{
public static void main(String args[]){
byte i=10;
byte j=9;
i+=j;
System.out.println(i);
}
}
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 {
public static void main(String[]args)
{
int x;
byte y=5;
x=y;
System.out.print(x);
}
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:
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
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)
System.out.println("equall");
else
System.out.println("not equall");
if(i>j)
System.out.println("equall");
else
System.out.println("not equall");
if(i<j)
System.out.println("equall");
else
41
System.out.println("not equall");
i=20;
if(i>=j)
System.out.println("equall");
else
System.out.println("not equall");
if(i<=j)
System.out.println("equall");
else
System.out.println("not equall");
}
}
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{
public static void main(String args[])
{
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
{
public static void main(String ar[])
{
int x = -12;
int y = 13;
x= x & y;
System.out.println(x);
}
}
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 {
public static void main(String[]args)
{
int x=12;
int y=13;
x=x|y;
System.out.print(x);
}
}
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 {
public static void main(String[]args)
{
int x=-12;
int y=13;
x=x|y;
System.out.print(x);
}
}
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
{
public static void main(String ar[])
{
46
int x = 12;
int y = 13;
x= x ^ y;
System.out.println(x);
}
}
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
{
public static void main(String ar[])
{
47
int x = -12;
int y = 13;
x= x ^ y;
System.out.println(x);
}
}
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
{
public static void main(String ar[])
{
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
{
public static void main(String ar[])
{
int i = 5;
i = i >> 2;
System.out.println(i);
i = -5;
i = i >> 2;
System.out.println(i);
}
}
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
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 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
{
public static void main(String ar[])
{
int i = 5;
i = i << 2;
System.out.println(i);
i = -5;
i = i << 2;
System.out.println(i);
}
}
Output :
20
-20
52
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 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
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 left 11111111 11111111
11111111 11101100
so after shifting we get the value of i as -20 .
*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 Unsigned Right Sift Operator ( >>> )
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 ;
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
{
public static void main(String ar[])
{
int i = 64;
i = i >>> 4 ;
System.out.println(i);
i = - 64;
i = i >>> 4 ;
System.out.println(i);
}
}
Output :
4
268435452
Let‟s see what happens in the above example. What actually happens in memory.
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
value is shown to us. Now let‟s see
i = -64 is stored in the memory as 11111111 11111111 11111111
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.
*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.
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
public static void main(String[]args)
{
int x=9;
int y=0;
if((++x)==10 && (++y)==1)
{
}
System.out.println(x);
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 {
public static void main(String[]args)
{
int x=9;
int y=0;
if(++x==1&& ++y==1)
{
}
56
System.out.println(x);
System.out.println(y);
}
}
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 {
public static void main(String[]args)
{
int x=9;
int y=0;
if(++x==10||++y==1)
{
57
}
System.out.println(x);
System.out.println(y);
}
}
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 {
public static void main(String[]args)
{
int x=9;
int y=0;
if(++x==1||++y==1)
{
}
System.out.println(x);
System.out.println(y);
}
}
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
{
public static void main(String ar[])
{
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
{
public static void main(String args[]) {
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="";
public static void main(String args[]) {
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
{
public static void main(String args[])throws Exception
{
int a=0,b=1,c=0;
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
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
{
public static void main(String args[])throws Exception
{
int a=1,r;
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
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
{
public static void main(String args[])throws Exception
{
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
{
public static void main(String args[])throws Exception
{
int r,c,n,t;
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Enter Binary Number");
n=Integer.parseInt(br.readLine());
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
{
public static void main(String args[])throws Exception
{
int n,f,i;
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Enter any Numer");
n=Integer.parseInt(br.readLine());
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
{
public static void main(String args[])throws Exception
{
int r=0,s=0,n;
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Enter Any Number");
n=Integer.parseInt(br.readLine());
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
{
public static void main(String args[])throws Exception
{
int i,j,row;
89
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
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
{
public static void main(String args[])throws Exception
{
int row=0,t=0,i=0,j=0,k=0,s=0;
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Enter The Number Of Rows");
row=Integer.parseInt(br.readLine());
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
System.out.print(" "+t);
t++;
}
System.out.print("\n\n") ;
91
}
}
}
Assignment-10
Draw A Number Triangle?
import java.io.*;
public class NumberTriangle
{
public static void main(String args[])throws Exception
{
int i,j,t=1,row;
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Enter number of rows");
row=Integer.parseInt(br.readLine());
92
for(i=0;i<row;i++)
{
for(j=0;j<=i;j++)
{
if(t<10)
{
System.out.print(" "+t);
}else{
System.out.print(" "+t);
t++;
}
}
System.out.print("\n");
}
}
}
93
Assignment-11
Draw A Pascal Triangle?
import java.io.*;
public class Pascal
{
public static void main(String args[])throws Exception
{
int b,p,q,r,x;
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
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;
System.out.println(x);
}
}
Above program generates compilation error . The error is given below
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
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;
System.out.println(x);
}
System.out.println(x);
}
}
Above program generates compilation error. The error is given below
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
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
{
public static void main(String a[ ])
{
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!!”);
}
public static void main(String a[ ])
{
p x=new p();
}
}
Above program generates compilation error. The error is given below
99
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
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
{
public static void main(String args[ ])
{
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
{
public static void main(String args[])
{
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;
// compute and return volume
double area()
{
return width * height ;
}
// sets dimensions of the rectangle
void setValue(double w, double h)
{
width = w;
height = h;
}
}
class RectangleDemo
{
public static void main(String args[])
105
{
Rectangle rec1 = new Rectangle();
Rectangle rec2 = new Rectangle();
double area;
// initialize each rectangle
rec1.setValue(10, 20);
rec2.setValue(3, 6);
// 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("Area is " + 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
{
public static void main(String args[]) {
107
// declare, allocate, and initialize Rectangle objects
Rectangle rec1 = new Rectangle(); Rectangle rec2 = new Rectangle();
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 :
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 {
public static void main(String args[]) {
// 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 :
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
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{
public static void main(String args[]) {
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; }
// compute and return volume
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;
}
// compute and return volume
double area() {
return this.width * this.height ;
}
}
115
public class RectangleDemo {
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);
}
}
Output :
area of rec1 is 200.0
area of rec2 is 625.0
area of rec3 is 225.0
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");
}
public static void main ( String ag[])
{
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");
}
public static void main ( String ag[])
{
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
public static void main(String args[ ])
{
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;
public static void main(String args[ ])
{
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 {
public static void main(String args[ ])
{ 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
{ public static void main(String args[])
{ 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
{ public static void main(String args[])
{ int [ ]mak={1,2,3};
//Array declaration in java mak[0]=1;
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
{
public static void main(String args[]) {
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 {
public static void main(String args[]) {
int [ ]mak=new int[1];
//Array declaration in java mak[0]=10;
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]);
System.out.println(town[1]);
System.out.println(town[2]);
}
}
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];
town[2]=new int [2];
town[2]=new int [3];
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;
arr[1]=new Demo(); arr[1].x=1;
arr[2]=new Demo(); arr[2].x=2;
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
{
public static void main(String args[ ])
{
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
{
public static void main(String args[])
{
147
try{
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Enter The Number Of Rows");
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 k=0;k<r;k++)
{
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 k=0;k<r;k++)
{
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
{
public static void main(String args[])
{
try{
BufferedReader br=new BufferedReader(new
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 k=0;k<r;k++)
{
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 k=0;k<r;k++)
{
for(int j=0;j<r;j++)
{
System.out.print(c[k][j]);
}
System.out.println();
}
}catch(IOException ie)
{
}
}
151
}
Assignment-3:-
Enter four integer value from keyboard and Sort the elements of
array in Ascending order?
import java.io.*;
public class ArrSortA
{
public static void main(String args[])throws Exception
{
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
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
{
public static void main(String args[])throws Exception
{
int i,j,temp=0;
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
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
{
public static void main(String args[])throws Exception
{
int num,i=0,j,k;
int a[]=new int[20];
int b[]=new int[20];
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
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
{
public static void main(String args[])throws Exception
{
int r,q,o,num;
int a[]=new int[10];
int b[]=new int[10];
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
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
{ public static void main(String args[])
{ 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
{ public static void main(String argts[])
{
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) {
System.out.println("Inside super class parameterized constructor");
} }
class Y extends X {
Y(int i)
{ System.out.println("Inside child class parameterized
constructor"); }
}
class Demo {
public static void main(String argts[]) {
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
{
public static void main(String argts[]) {
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
System.out.println("Inside super class parameterized
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 {
public static void main(String argts[]) {
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
System.out.println("Inside super class parameterized
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
{ public static void main(String argts[])
{ 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
System.out.println("Inside super class parameterized constructor");
} void fun()
{ System.out.println("Parent");
} }
class Y extends X {
Y() {
System.out.println("Inside child class parameterized constructor"); }
proteted void fun()
{ System.out.println("Child");
} }
class Demo {
public static void main(String argts[]) {
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
System.out.println("Inside super class parameterized
constructor"); fun();
} 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 extends Y
{ public static void main(String argts[])
{ 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() {
System.out.println("Inside super class parameterized
constructor"); fun();
} 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 extends Y {
public static void main(String argts[]) {
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() {
System.out.println("Inside super class parameterized
constructor"); fun();
}
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 extends Y
{ public static void main(String argts[])
{ 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;
}
class Demo extends Y {
public static void main(String argts[]) {
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");
}
} class Demo extends Y
{ public static void main(String argts[])
{ 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()
{ System.out.println("Parent class");
}
176
}
class Y extends X {
void fun(int x) {
System.out.println("Child class");
}
} class Demo extends Y
{ public static void main(String argts[])
{ 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()
{ System.out.println("Parent class");
} }
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
{
public static void main(String argts[]) {
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()
{ System.out.println("Parent class");
} }
class Y extends X
178
{
Y() {
super(); System.out.println("Child class");
} X fun()
{ return super;
} }
class Demo extends Y {
public static void main(String argts[]) {
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()
{ System.out.println("Parent class");
} }
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
{ public static void main(String argts[])
{ 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
{ public static void main(String argts[])
{ 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
{ public static void main(String argts[])
{ 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
public static void main(String args[])
{
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); }
public static void main(String args[]) {
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);
}
}
public static void main(String args[])
{
Test t1=new Test();
t1.display();
}
}
Output:
189
Example-2
public class Inner2
{
String name;
static int roll;
private String getName(String n)
{
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()
{
Inner2 i1=new Inner2();
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);
}
}
public static void main(String args[])
{
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)
{
Inner3 i3=new Inner3();
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;
}
}
public static void main(String args[])
{
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;
private String getName(String n)
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"));
}
}
public static void main(String args[])
{
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
{
String getName(String n)
{
name=n;
return name;
}
int getRoll(int r)
{
roll=r;
return roll;
}
}
public static void main(String args[])
{
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
{
String getName(String n)
{
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();
}
public static void main(String args[])
{
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) {
//Codes to handle the exception
}
catch(Exception_Type_3 excp3) {
//Codes to handle the exception
}
//….
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)
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.
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
{
public static void main(String argts[])
{
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
{
public static void main(String argts[])
{
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
{ public static void main(String argts[])
{
int x,y,z; x=9;
y=0; try{
z=x/y; System.out.println("I am not Executed");
210
}catch(ArithmeticException e)
{ 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 {
public static void main(String argts[]) {
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
{ public static void main(String argts[])
{ 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 {
public static void main(String argts[])
{ 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 {
public static void main(String argts[])
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 {
public static void main(String args[]) {
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
{ public static void main(String args[])
{ 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
{
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
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 {
public static void main(String args[]) {
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.
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 {
public static void main(String args[]) {
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 {
public static void main(String args[]) {
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 {
public static void main(String args[]) {
String s1=new String("Hello,Java!"); System.out.println(s1);
} }
Output is
Hello,Java!
class Demo {
public static void main(String args[]) {
String s2="Hello World!"; String s1=new String(s2);
System.out.println(s1); }
}
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
public static void main(String args[])
{ byte ascii[] = {65, 66, 67, 68, 69, 70 };
String s1 = new String(ascii); System.out.println(s1);
String s2 = new String(ascii, 2, 3);
System.out.println(s2); }
}
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 {
public static void main(String args[])
{ 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
{ public static void main(String args[])
{ 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
{ public static void main(String argts[])
{
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
{
public static void main(String argts[]) {
String d1=new String("Java"); String d2=new String("Java");
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:
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
{ public static void main(String argts[])
{
String d1=new String("Java"); String d2=new String("Java");
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.");
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{
public static void main(String args[]) {
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{
public static void main(String args[])
{ String s1="Hello world";
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{
public static void main(String args[]) {
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{
public static void main(String args[]) {
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{
public static void main(String args[]) {
String s1="Hello world"; String s2="hello world";
boolean b=s1.equalsIgnoreCase(s2);
240
System.out.println(b);
}} 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
class Demo { public static void main(String[]args)
{ String s1="Java";
String s2="C++"; int i=s2.compareTo(s2);
System.out.println(i); }
} Output:
0
class Demo {
public static void main(String[]args) {
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
class Demo { public static void main(String[]args)
{ String s1="Java";
String s2="java"; int i=s1.compareTo(s2);
System.out.println(i); }
} Output: -32
public boolean startsWith(String prefixValue,int index) checks whether the string begins with the specified prefixValue
from specified index class Demo {
public static void main(String[]args) {
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 {
public static void main(String[]args) {
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.
class Demo{ public static void main(String args[])
{ String s1="Hello world";
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{
public static void main(String args[]) {
String s1="Hello world";
int b=s1.indexOf('l',4); System.out.println(b);
}} Output 9
class Demo{
public static void main(String args[])
{ String s1="Hello world";
int b=s1.indexOf('l',4);
System.out.println(b); }}
Output:2
class Demo{ public static void main(String args[])
{ String s1="Hello world";
243
int b=s1.indexOf('H',4);
System.out.println(b); }}
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{
public static void main(String args[]) {
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.
class Demo{ public static void main(String args[])
{ String s1="Hello World";
String s2=s1.toLowerCase();
System.out.println(s2); }}
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{
public static void main(String args[]) {
String s1=" Hello World";
244
String s2=s1.trim(); System.out.println(s1);
System.out.println(s2); }}
Output: Hello World Hello World
public char[] toCharArray()
this method is used to convert the string to character array. class Demo{
public static void main(String args[]) {
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
“NumberFormatException”.
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
object then the program is terminated at runtime by throwing an Exception
“NumberFormatException”.
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
then the program is terminated at runtime by throwing an Exception
“NumberFormatException”.
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
then the program is terminated at runtime by throwing an Exception
“NumberFormatException”.
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
object then the program is terminated at runtime by throwing an Exception
“NumberFormatException”.
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++;
System.out.println(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;
System.out.println(s);
s=Short.toString(s1);
s+=2;
System.out.println(s);
}
}
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");
}
}
public static void main(String args[])
{
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
public static void main(String args[])
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{
public static void main(String args[])
{
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];
System.out.println(s);
}
}
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
{
public static void main(String args[])
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{
public static void main(String args[]) {
InputStreamReader is=new InputStreamReader (System.in);
BufferedReader br=new BufferedReader(is);
String s;
try{
s=br.readLine();
}catch(IOException e)
{
}
System.out.println(s);
}
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
available to be read.
boolean hasNextShort() Returns true if a short value is
available to be read.
boolean hasNextInt() Returns true if a int value is available
to be read.
boolean hasNextFloat() Returns true if a float value is
available to be read.
boolean hasNextLong() Returns true if a long value is
available to be read.
263
boolean hasNextDouble() Returns true if a double value is
available to be read.
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 {
public static void main(String[] args)
{ 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 {
public static void main(String[] args) {
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
{
public static void main(String[] args) {
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 {
public static void main(String[] args) {
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();
public static void main(String args[]) {
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{
public static void main(String args[]) {
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");
}
}
class Demo { public static void main(String[] args){
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
class X implements Runnable{
public void run()
{ System.out.println(Thread.currentThread());
}
} class Demo {
public static void main(String[] args){ 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[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.
class X implements Runnable{
public void run() {
System.out.println(Thread.currentThread()); Thread.yield();
System.out.println(Thread.currentThread());
}
} class Demo {
public static void main(String[] args){ X o=new X();
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.
class X implements Runnable{
public void run()
285
{
System.out.println(Thread.currentThread()); Thread.yield();
System.out.println(Thread.currentThread());
} }
class Demo { public static void main(String[] args){
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
class X implements Runnable{
public void run()
{ try{
Thread.sleep(2000);
}catch(InterruptedException e) {
System.out.println("I am mhandling it"); }
System.out.println(Thread.currentThread()); }
} class Demo {
public static void main(String[] args){ X o=new X();
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
class X implements Runnable{
public void run()
287
{
for(int i=1;i<5;i++) {
try{ Thread.sleep(500);
}catch(InterruptedException e) {
}
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");
t1.start(); t2.start();
} }
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();
}catch(InterruptedException e) {
}
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");
t1.start(); t2.start();
} }
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");
t1.start(); t2.start();
} }
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.
class X implements Runnable{
public void run() {
System.out.println(Thread.currentThread()+"Hello X"); }
}
Running (Run
method is in
execution)
Ready
Blocked Dead
295
class Demo {
public static void main(String[] args){ X o=new X();
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
{
public static void main(String[] args)
{
// 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");
// prints the type of data hold by it
ob2.showClass();
// prints the data hold by it
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.
Gener<Integer> ob1 = new Gener<Integer>(100);
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.
// Defination of the generic class Gener
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);
System.out.println("Data in ob2 "+ ob2);
301
}
}
public class GenericDemo {
public static void main(String[] args) {
// Create a Gener reference for Integer and String
Gener<Integer,String> obj1 = new
Gener<Integer,String>(100,"SAMITA , LORY");
// prints the type of data hold by it
obj1.showClass();
// prints the data hold by it
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.
// Defination of the generic class Gener
class Gener<A extends Integer >{
A ob1;
Gener(A o1 )
{
ob1 =o1;
}
void showClass()
{
System.out.println("Type of A is "+ ob1.getClass().getName());
}
void showData()
{
System.out.println("Data in ob1 "+ ob1);
}
303
}
public class GenericDemo {
public static void main(String[] args) {
// Create a Gener reference for Integer
Gener<Integer> obj1 = new Gener<Integer>(100);
// prints the type of data hold by it
obj1.showClass();
// prints the data hold by it
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
// Defination of the generic class Gener
class Gener<A extends Integer >{
A ob1;
Gener(A o1 )
{
ob1 =o1;
}
void showClass()
{
System.out.println("Type of A is "+ ob1.getClass().getName());
}
void showData()
{
System.out.println("Data in ob1 "+ ob1);
}
}
public class GenericDemo {
public static void main(String[] args) {
305
// Create a Gener reference for String
Gener<String> obj2 = new Gener<String>("SAMITA ,
LORY");
// prints the type of data hold by it
obj2.showClass();
// prints the data hold by it
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.
// Defination of the generic class Gener
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");
}
}
public class GenericDemo {
public static void main(String[] args) {
// Create a Gener reference for Integer
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
public class GenericDemo {
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);
}
public static void main(String[] args) {
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.
// Defination of the generic class Gener
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);
}
}
public class GenericDemo {
public static void main(String[] args) {
312
// Create a Gener reference for Integer
Gener ob1 = new Gener(100);
System.out.println("Type of ob1 is "+
ob1.getClass().getName());
// prints the type of data hold by it
ob1.showClass();
// prints the data hold by it
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());
// prints the type of data hold by it
ob2.showClass();
// prints the data hold by it
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
Gener<Integer> ob1 = new Gener<Integer>(100);
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
{
public static void main(String args[])
{
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
{
public static void main(String args[])
{
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 {
public static void main(String[] args)
{
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{
public static void main(String[] args)
{
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
{
public static void main(String args[])
{
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{
public static void main(String[] args)
{
File myFile=new File(“/dir1/pex”);
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{
public static void main(String[]args)
{
File myFile=new File(“/dir1/pex”);
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 {
public static void main(String args[])
{ 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);
}
public static void main(String args[])throws IOException
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;
}
public static void main(String args[])throws Exception
{
byte input []=get( ) ;
FileOutputStream f=new FileOutputStream("c:/java/write.txt");
for (int i=0;i<50;i++)
{
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
{
public static void main(String args[])throws Exception
{
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");
for (int i=0;i<1;i++)
{
while ((c =inp.read( )) != -1)
{
System.out.print(Character.toUpperCase ((char)c));
}
System.out.println();
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
{
public static void main(String args[])
{
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
available( ), mark( ),
markSupported( ), read(
), reset( ), skip( ),
PushbackInputStream Has a one-byte pushback
buffer, so the last
character read can be
pushed back.
available( ), mark( ),
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{
public static void main(String[]args)throws IOException
{
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{
public static void main(String[]args)throws IOException
{
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{
public static void main(String[]args)throws IOException
{
346
FileInputStream fin=new FileInputStream(“myFile.txt”);
int ch;
while((ch=(char)fin.read())!=-1)
System.out.print((char)ch);
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{
public static void main(String[]args)throws IOException
{
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{
public static void main(String[]args)throws IOException
{
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)
System.out.print((char)ch);
fin.close ();
}
}
Here in this program I have used the BufferedReader to improve the
performance.
348
Example-21
import java.io.*;
public class DataStream
{
public static void main(String args[])throws IOException
{
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
{
public static void main(String args[])
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{
public static void main(String[]args)throws IOException
{
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{
public static void main(String[]args)throws IOException
{
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
public static void main(String[]args) {
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; }
class Demo { public static void main(String[]args)
{ 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
class Demo { public static void main(String[]args)
{
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 {
public static void main(String[]args) {
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());
}
public static void main(String[] args) {
372
Thread t1 = new ThreadLocalDemo1(); Thread t2 = new ThreadLocalDemo1();
t1.start(); t2.start();
}
}
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
Thread Thread-1 has thread number 4 Thread Thread-1 has thread number 5
Thread Thread-1 has thread number 6 Thread Thread-1 has thread number 7
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:
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 {
public static void main (String arg[]) {
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
package demo; import java.util.*;
class X{ int i;
void show() {
System.out.println(i); }
} class Y extends X{
int j; void show()
{
System.out.println(j); }
} class Demo {
public static void main (String arg[]) {
ArrayList<X> arrX=new ArrayList<X>(); System.out.println("Initially size of the array:"+arrX.size());
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);
} System.out.println("Finally the array size "+arrX.size());
for(X a:arrX){ a.show();
}
}
} 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
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
System.out.println(i);
} }
class Y extends X{ int j;
void show() {
System.out.println(j); }
} class Demo {
public static void main (String arg[]) {
ArrayList<X> arrX=new ArrayList<X>(); System.out.println("Initially size of the array:"+arrX.size());
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);
} System.out.println("Finally the array size "+arrX.size());
for(X a:arrX){
a.show(); }
}
} Output:
Initially size of the array:0 now size of the array 5
Finally the array size 9 0
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) {
System.out.println(s);
} }
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>();
for(int i=0;i<5;i++) {
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 {
public static void main (String arg[]) {
LinkedList<X> linkedL=new LinkedList<X>(); for(int i=0;i<5;i++)
{ X a=new X();
a.i=i; linkedL.add(a);
}
for(int i=0;i<5;i++) {
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; }
class Demo { public static void main (String arg[])
{ 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=new X();
a.i=100; linkedL.set(1,a);
for(X b:linkedL) {
System.out.println(b.i); }
}} 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 {
public static void main (String arg[]) {
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; }
class Demo { public static void main (String arg[])
{ HashSet<X> hashS=new HashSet<X>();
for(int i=0;i<5;i++) {
X a=new X(); a.i=i;
hashS.add(a); }
X z=new X(); z.i=100;
hashS.add(z);
for(X b:hashS) {
System.out.println(b.i); }
}}
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.
package demo; import java.util.*;
class Demo {
public static void main (String arg[]) {
TreeSet<Integer> treeS=new TreeSet<Integer>(); int j=5;
for(int i=0;i<5;i++) {
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;
import java.util.*; class X{
int i;
397
}
class Demo { public static void main (String arg[])
{ 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;
import java.util.*; class X{
int i; }
class Demo { public static void main (String arg[])
{
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(a.i); }
System.out.println("Back ward traversing"); while(LiteR.hasPrevious()){
X a=LiteR.previous();
System.out.println(a.i); }
}
}
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; }
class Demo { public static void main (String arg[])
{ 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
package demo; import java.util.*;
class K { int key;
} class V{
int data; }
class Demo { public static void main (String arg[])
{
403
HashMap<K,V>hashM=new HashMap<K,V>();
for(int i=0;i<5;i++) {
K key1=new K(); key1.key=i;
V val=new V(); val.data=i+5;
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;
}
}
class Demo { public static void main (String arg[])
{ 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)
{ 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
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;
} }
class Demo {
public static void main (String arg[]) {
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) {
System.out.println(a.i); }
}
}
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
package demo; import java.util.*;
class Demo {
public static void main (String arg[]) {
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 {
public static void main (String arg[]) {
Vector<X> vect=new Vector<X>();
for(int i=0;i<5;i++) {
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
package demo; import java.util.*;
class X{ int i;
}
class Demo { public static void main (String arg[])
{ 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
package demo; import java.util.*;
class X{
int i; }
class Demo { public static void main (String arg[])
{ 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();
System.out.println(a.i); }
} }
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 {
public static void main (String arg[]) {
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.
package demo; import java.util.*;
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;
V val=new V(); val.data=i+5;
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.
package demo; import java.util.*;
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
just Clock Time!!"; public static void main(String arg[])
{ 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
just Clock Time!!"; public static void main(String arg[])
{ 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
package demo; import java.util.*;
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
Object of Y is changed:3 Object of Y is changed:4
Object of Y is changed:5 Object of Y is changed:6
Object of Y is changed:7 Object of Y is changed:8
Object of Y is changed:9 Object of Y is changed:10
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.
package demo; import java.util.*;
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() {
i++; this.setChanged();
notifyObservers(this.i);
421
try{
Thread.sleep(100); }catch(InterruptedException e){}
}
}
class Demo {
public static void main(String arg[]) {
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:2 Object of Y is changed:3
Object of Y is changed:4 Object of Y is changed:5
Object of Y is changed:6
Object of Y is changed:7 Object of Y is changed:8
Object of Y is changed:9 Object of Y is changed:10
An object having multiple observers
package demo;
import java.util.*;
class X implements Observer{
public void update(Observable obs,Object obj)
422
{
System.out.println("Object of Y is changed:"+(Integer)obj); }
}
class Y extends Observable {
Integer i ;
void fun() {
i++; this.setChanged();
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:
Object of Y is changed:1
423
Object of Y is changed:101
Object of Y is changed:2 Object of Y is changed:102
Object of Y is changed:3 Object of Y is changed:103
Object of Y is changed:4 Object of Y is changed:104
Object of Y is changed:5 Object of Y is changed:105
Object of Y is changed:6 Object of Y is changed:106
Object of Y is changed:7 Object of Y is changed:107
Object of Y is changed:8 Object of Y is changed:108
Object of Y is changed:9
Object of Y is changed:109 Object of Y is changed:10
Object of Y is changed:110
Two Objects monitored two different Observers
package demo; import java.util.*;
class X implements Observer{
public void update(Observable obs,Object obj) {
System.out.println("Object of Y is changed:"+(Integer)obj); }
} class Z implements Observer{
public void update(Observable obs,Object obj) {
System.out.println("Object of Y is changed:"+(Integer)obj); }
}
class Y extends Observable {
424
Integer i ;
void fun()
{ i++;
this.setChanged(); 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(); Z d=new Z();
a.addObserver(b); c.addObserver(d);
for(int i=0;i<10;i++) {
a.fun();
c.fun(); }
} }
Output:
Object of Y is changed:1 Object of Y is changed:101
Object of Y is changed:2 Object of Y is changed:102
Object of Y is changed:3 Object of Y is changed:103
Object of Y is changed:4
425
Object of Y is changed:104
Object of Y is changed:5 Object of Y is changed:105
Object of Y is changed:6 Object of Y is changed:106
Object of Y is changed:7 Object of Y is changed:107
Object of Y is changed:8 Object of Y is changed:108
Object of Y is changed:9 Object of Y is changed:109
Object of Y is changed:10 Object of Y is changed:110
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
package demo; import java.util.*;
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);
try{ Thread.sleep(5000);
}catch(InterruptedException e){}
426
tm.cancel();
} }
Output: Hello World!!!
Hello World!!! Hello World!!!
Hello World!!! Hello World!!!
Hello World!!! Hello World!!!
Hello World!!! Hello World!!!
Hello World!!! Hello World!!!
Hello World!!!
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.*;
import java.applet.*;
/*
<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.applet.*;
import java.awt.*;
public class player extends Applet {
AudioClip a1;
public void init()
{
a1=getAudioClip(getCodeBase(),"sai.au");
}
public void start()
{
a1.play();
}
public void paint(Graphics g1)
{
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
import java.applet.*;
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);
b2.addActionListener(this);
add(b1);
add(b2);
}
public void actionPerformed(ActionEvent ae)
{
if(ae.getSource()==b1)
{
a1.play();
}else{
a1.stop();
}
442
}
public void paint(Graphics g1)
{
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.applet.*;
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
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.*;
import java.applet.*;
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)
public void paint(Graphics gph)
{
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.*;
import java.applet.*;
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);
}
public void paint(Graphics g)
{
gph.drawImage(img,25,100,this);
}
}
459
/*<applet code="Image123" width=300 height=300>
</applet>*/
Example-2
import java.awt.*;
import java.applet.*;
public class Image123 extends Applet
{
Image img;
public void init()
{
img=getImage(getDocumentBase(),"CAKE.jpg");
}
public void paint(Graphics gph)
{
gph.drawImage(im,30,50,this);
}
460
}
/*<applet code="Image123" width=300 height=300>
</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
signature of this class is:
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.
public void setLabel(java.lang.String)
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:
public void add(java.lang.String)
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
concerned scrollbar.
public void setMinimum(int)
Using this method, we can set the specified minimum value for the
concerned scrollbar.
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
signature of this class is:
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.*;
import java.applet.*;
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.
public void add(java.lang.String)
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.
The signature of this class is:
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.
public void setLabel(java.lang.String)
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.
The signature of this class is:
public class java.awt.CheckboxMenuItem extends extends
java.awt.Menutem implements java.awt.ItemSelectable,
javax.accessibility.Accessible
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);
}
public static void main(String args[])
{
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
javax.accessibility.Accessible
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
signature of this class is:
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.
The signature of this class is:
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);
}
public static void main(String args[])
{
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.*;
import java.awt.event.*;
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");
b1.addActionListener(this);
f.setLayout(new FlowLayout());
f.add(t1);f.add(t2);f.add(b1);
f.setVisible(true);
f.setSize(500,500);
}
public void actionPerformed(ActionEvent ae)
{
if(ae.getSource()==b1)
{
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);
}
public void actionPerformed(ActionEvent ae)
{
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);
}
public static void main(String args[])
{
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.applet.*;
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");
Button b2=new Button("Button-2");
Button b3=new Button("Button-3");
Button b4=new Button("Button-4");
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.*;
import java.awt.event.*;
import java.applet.*;
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);
Label l2=new Label("Panel-2");
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);
Label l3=new Label("Panel-3");
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");
b1.addActionListener(this);
b2=new Button("Previous");
b2.addActionListener(this);
add(p);
add(b1);
add(b2);
}
public void actionPerformed(ActionEvent ae)
{
if(ae.getSource()==b1)
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.*;
import java.applet.*;
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") ;
l1.setFont(new Font("Verdana",Font.BOLD,24));
l2=new Label("Enter Your Name");
511
l2.setFont(new Font("Verdana",Font.BOLD,14));
l3=new Label("Enter Your City");
l3.setFont(new Font("Verdana",Font.BOLD,14));
l4=new Label("Enter Your State");
l4.setFont(new Font("Verdana",Font.BOLD,14));
l5=new Label("Enter Mobile Number");
l5.setFont(new Font("Verdana",Font.BOLD,14));
tf1=new TextField(15);
tf2=new TextField(15);
tf3=new TextField(15);
tf4=new TextField(15);
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(l2,gbc) ;
gbc.gridwidth=GridBagConstraints.REMAINDER;
gbag.setConstraints(tf1,gbc);
gbc.gridwidth=GridBagConstraints.RELATIVE;
gbag.setConstraints(l3,gbc) ;
gbc.gridwidth=GridBagConstraints.REMAINDER;
gbag.setConstraints(tf2,gbc);
gbc.gridwidth=GridBagConstraints.RELATIVE;
gbag.setConstraints(l4,gbc) ;
gbc.gridwidth=GridBagConstraints.REMAINDER;
gbag.setConstraints(tf3,gbc);
gbc.gridwidth=GridBagConstraints.RELATIVE;
gbag.setConstraints(l5,gbc) ;
gbc.gridwidth=GridBagConstraints.REMAINDER;
gbag.setConstraints(tf4,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.applet.*;
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
b1.addActionListener(this);
b2.addActionListener(this);
b3.addActionListener(this);
add(b1);
add(b2);
add(b3);
}
//step-4
public void actionPerformed(ActionEvent ae)
{
if(ae.getSource()==b1)
{
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
java.util.EventListener
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.*;
import java.awt.event.*;
import java.applet.*;
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);
cb2.addItemListener(this);
cb3.addItemListener(this);
cb4.addItemListener(this);
add(cb1);
add(cb2);
add(cb3);
add(cb4);
}
520
public void itemStateChanged(ItemEvent ae)
{
repaint();
}
public void paint(Graphics g)
{
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
java.util.EventListener
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();
tf1=new TextField(18);
p1.add(tf1);
add(p1);
}
public void adjustmentValueChanged(AdjustmentEvent ae)
{
if(ae.getAdjustable()==h1)
{
h1.setValue(h1.getValue());
h2.setValue(h1.getValue());
tf1.setText("Horizontal Location :- "+h1.getValue());
523
}
if(ae.getAdjustable()==v1)
{
v1.setValue(v1.getValue());
v2.setValue(v1.getValue());
tf1.setText("Vertical Location :- "+v1.getValue());
}
if(ae.getAdjustable()==h2)
{
h2.setValue(h2.getValue());
h1.setValue(h2.getValue());
tf1.setText("Horizontal Location :- "+h2.getValue());
}
if(ae.getAdjustable()==v2)
{
v2.setValue(v2.getValue());
v1.setValue(v2.getValue());
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
java.util.EventListener
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.*;
import java.awt.event.*;
525
import java.applet.*;
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
java.util.EventListener
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
java.util.EventListener
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
java.util.EventListener
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
java.util.EventListener
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.*;
import java.applet.*;
import java.awt.event.*;
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();
gc.setLocation(x,y);
}
public void mouseEntered(MouseEvent me) {}
public void mouseExited(MouseEvent me) {}
public void mousePressed(MouseEvent me) {}
public void mouseReleased(MouseEvent me) {}
}
class GraphCanvas extends Canvas
{
public void paint(Graphics g)
{
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
java.util.EventListener
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
java.util.EventListener
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
java.util.EventListener
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.*;
import java.awt.event.*;
public class WindowDemo extends Frame implements
WindowListener
{
Frame f1;
public WindowDemo()
{
f1=new Frame("Winow Event");
f1.addWindowListener(this);
f1.setSize(200,200);
f1.setVisible(true);
}
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){}
public static void main(String args[])
{
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.*;
import java.awt.event.*;
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");
b1.addActionListener(this);
b2.addActionListener(this);
f1.add(b1);
f1.add(b2);
f1.setSize(200,200);
f1.setVisible(true);
f1.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent aw)
{
System.exit(0);
}
} );
}
public void actionPerformed(ActionEvent ae)
{
if(ae.getSource()==b1)
{
f1.setBackground(Color.red);
}else{
f1.setBackground(Color.blue);
536
}
}
public static void main(String args[])
{
Window1 w1=new Window1();
}
}
MouseAdapter, MouseMotionAdapter
import java.awt.*;
import java.applet.*;
import java.awt.event.*;
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();
gc.setLocation(x,y);
}
});
addMouseMotionListener(new MouseMotionAdapter()
{
public void mouseDragged(MouseEvent me)
{
x=me.getX();
y=me.getY();
gc.setLocation(x,y);
}
});
}
}
class GraphCanvas1 extends Canvas
538
{
public void paint(Graphics g)
{
g.setColor(Color.white);
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.*;
import java.awt.event.*;
import java.applet.*;
/*<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);
b1.addActionListener(this);
b2.addActionListener(this);
540
b3.addActionListener(this);
b4.addActionListener(this);
}
public void actionPerformed(ActionEvent ae)
{
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){}
}
}
public void paint(Graphics g)
{
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.*;
import java.awt.event.*;
import java.applet.*;
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);
tf1=new TextField(5);
tf2=new TextField(5);
b1=new Button("start");
b2=new Button("stop");
b3=new Button("pause");
b4=new Button("Resume");
544
b1.addActionListener(this);
b2.addActionListener(this);
b3.addActionListener(this);
b4.addActionListener(this);
setBackground(Color.black);
add(l1);
add(tf1);
add(l2);
add(tf2);
add(b1);
add(b2);
add(b3);
add(b4);
}
public void actionPerformed(ActionEvent ae)
{
if((ae.getSource()==b1)&&(t==null))
{
t=new Thread(this);
t.start();
}
else if((ae.getSource()==b2)&&(t!=null))
{
t.stop();
t=null;
}
545
else if((ae.getSource()==b3)&&(t!=null))
{
t.suspend();
}
else if((ae.getSource()==b4)&&(t!=null))
{
t.resume();
}
}
public void run()
{
for(;;)
{
try
{
repaint();
Thread.sleep(Integer.parseInt(tf1.getText()));
}
catch(Exception e){}
}
}
public void paint(Graphics g)
{
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.awt.event.*;
import java.applet.*;
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");
tf1=new TextField(5);
tf=new TextField(20);
b1=new Button("start");
b2=new Button("stop");
b3=new Button("pause");
b4=new Button("Resume");
b1.addActionListener(this);
b2.addActionListener(this);
b3.addActionListener(this);
b4.addActionListener(this);
add(l);
548
add(tf1);
add(tf);
add(b1);
add(b2);
add(b3);
add(b4);
}
public void actionPerformed(ActionEvent ae)
{
if((ae.getSource()==b1)&&(t==null))
{
update(getGraphics());
t=new Thread(this);
t.start();
}
else if((ae.getSource()==b2)&&(t!=null))
{
t.stop();
t=null;
}
else if((ae.getSource()==b3)&&(t!=null))
{
t.suspend();
}
else if((ae.getSource()==b4)&&(t!=null))
{
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)
{
}
}
}
public void paint(Graphics g)
{
i+=5;
if(i>=100)
i=5;
g.setColor(Color.white);
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);
}
}
/*<applet code="Image1" width=200 height=200>
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 {
public static void main(String a[])
{
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
import javax.swing.*;
public class window1 {
public static void main(String a[])
{
JFrame w1 = new JFrame(" WELCOME");
w1.setSize(300,300);
w1.setVisible(true);
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.awt.event.*;
import java.util.*;
import javax.swing.*;
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);
}
}
public static void main(String args[])
{
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 javax.swing.*;
import java.awt.*;
563
import javax.swing.*;
import java.awt.*;
public class window1 {
public static void main(String a[])
{
JFrame w1 = new JFrame(" WELCOME");
Container c1=w1.getContentPane();
c1.setBackground(Color.green);
w1.setSize(300,300);
w1.setVisible(true);
w1. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
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 javax.swing.*;
import java.awt.*;
class X extends JPanel{
public void paintComponent(Graphics g)
{
super.paintComponent(g);
g.drawString("Hello world",50,100);
565
}
}
public class window1 {
public static void main(String a[])
{
JFrame w1 = new JFrame(" WELCOME");
Container c1=w1.getContentPane();
X a1=new X();
c1.add(a1);
c1.setBackground(Color.green);
w1.setSize(300,300);
w1.setVisible(true);
w1. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
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 javax.swing.*;
import java.awt.*;
public class window1 extends JFrame {
JLabel l1;
567
window1()
{
l1 = new JLabel("hello world");
}
public static void main(String a[])
{
window1 w1 = new window1();
Container c1=w1.getContentPane();
c1.add(w1.l1);
c1.setBackground(Color.green);
w1.setSize(300,300);
w1.setVisible(true);
w1. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
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 java.awt.event.*;
import javax.swing.*;
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();
addWindowListener(myapp);
}
class myadapter extends WindowAdapter
{
public void windowCloseting(WindowEvent e)
{
System.exit(0);
}
}
public static void main(String args[])
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 javax.swing.*;
import java.awt.*;
public class window1 extends JFrame {
JButton b1;
window1()
{
b1 = new JButton("hello world");
}
public static void main(String a[])
{
window1 w1 = new window1();
Container c1=w1.getContentPane();
c1.add(w1.b1);
c1.setBackground(Color.green);
w1.setSize(300,300);
w1.setVisible(true);
w1. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
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.awt.event.*;
import java.util.*;
import javax.swing.*;
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);
myadapter myapp=new myadapter();
addWindowListener(myapp);
}
private class myadapter extends WindowAdapter
{
public void windowCloseing(WindowEvent e)
{
System.exit(0);
}
}
public static void main(String args[])
{
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 javax.swing.*;
import java.awt.*;
import java.awt.event.*;
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);
cbox2.addActionListener(this);
cbox3.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="";
}
public static void main(String a[])
{
window1 w1=new window1();
w1.setSize(500,500);
w1.setVisible(true);
}
577
}
Output:
Let us have another example for the checkbox.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
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);
myadapter myapp=new myadapter();
addWindowListener(myapp);
}
class myadapter extends WindowAdapter
{
public void windowClosing(WindowEvent e)
{
System . exit (0);
}
}
public void itemStateChanged(ItemEvent e)
{
if(e.getStateChange( )==ItemEvent.SELECTED)
setTitle(“checkbox selected ”);
579
else
setTitle(“Checkbox unselected”) ;
}
public static void main(String args[])
{
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 javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class window1 extends JFrame implements ActionListener {
JRadioButton cbox1,cbox2;
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 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
cbox1.addActionListener(this);
cbox2.addActionListener(this);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void actionPerformed(ActionEvent ae){
if(cbox1.getModel().isSelected())s1+="java";
if(cbox2.getModel().isSelected())s1+="C++";
tarea.setText(s1);
s1="";
}
public static void main(String a[])
{
window1 w1=new window1();
w1.setSize(500,500);
582
w1.setVisible(true);
}
}
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.*;
import java.awt.event.*;
import javax.swing.*;
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);
myadapter myapp=new myadapter();
addWindowListener(myapp);
}
584
class myadapter extends WindowAdapter
{
public void windowClosing(WindowEvent e)
{
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);
}
}
public static void main(String args[])
{
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 javax.swing.*;
import java.awt.*;
import java.awt.event.*;
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);
rb1.addItemListener(this);
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
");
if(rb2.getModel().isSelected())
UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLook
AndFeel");
if(rb3.getModel().isSelected())
UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.Windows
LookAndFeel");
SwingUtilities.updateComponentTreeUI(c);
}catch(Exception e){}
}
public static void amin(String[] args)
589
{
window1 w1=new window1();
w1.setSize(500,500);
w1.setTitle("My Window");
w1.setVisible(true);
}
}
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 javax.swing.*;
import java.awt.*;
import java.awt.event.*;
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) ;
}
private class myadapter extends WindowAdapter
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
}
void makePane(String thestring)
{
TabbedDemo newtab=new TabbedDemo();
newtab.setVisible (true) ;
593
newtab.setSize (400,400) ;
}
public static void main(String args[])
{
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 javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.plaf.*;
public class window1 extends JFrame implements ActionListener {
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)
{
window1 w1=new window1();
w1.setSize(500,500);
w1.setTitle("My Window");
w1.setVisible(true);
}
}
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.*;
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);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
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="";
}
public static void main(String a[])
{
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.*;
import java.awt.event.*;
import javax.swing.*;
class TogleButon extends JFrame implements ActionListener
{
JToggleButton j1;
ImageIcon image1;
TogleButon()
{
Container c1 = getContentPane();
c1.setLayout(new FlowLayout());
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);
}
public static void main(String a[])
{
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
of the progress bar.
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
of the progress bar.
7. setStringPainted() : this method is used to display the
percentage of the progress of the task bar.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
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 javax.swing.*;
import java.awt.event.*;
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");
}
public static void main(String args[])
{
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.*;
import java.awt.event.*;
import javax.swing.*;
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_F2) st1+=”The F2 key”;
if(keycode1==KeyEvent.VK_F3) st1+=”The F3 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)
C1 determines the visual object or the
frame to be poped-up and msg1
represents the message to be
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)
C1 determines the visual object or the
frame to be poped-up and msg1
represents the message to be
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.event.*;
import java.awt.*;
import java.lang.*;
public class MessagePaneDemo extends JPanel implements ActionListener
{
public MessagePaneDemo( )
{
JButton b1 = new JButton("Click here");
b1.addActionListener(this);
add(b1);
}
public void actionPerformed(ActionEvent e)
{
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
import javax.swing.*;
624
import java.awt.event.*;
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.setForeground(Color.black);
frame.setBackground(Color.lightGrey);
frame.addWindowListener (new WindowCloser ( ));
frame.getContentPane ( ).add(panel,”Center”);
frame.setSize(panel.getPreferredSize( ) );
frame.setVisible (true);
}
}
class WindowCloser extends WindowAdapter
{
public void windowCloseing(WindowEvent e)
{
626
Window win =e.getWindow( );
win.setVisible(false);
System.exit( 0);
}
}
Output:
Let us have another programming example which shows another task of the
JOptionPane.
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import java.lang.*;
public class InputDialogDemo extends JPanel implements ActionListener
{
627
public InputDialogDemo( )
{
JButton b1=new JButton("Click here");
b1.addActionListener(this);
add(b1);
}
public void actionPerformed(ActionEvent e)
{
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.setForeground(Color.black);
frame.setBackground(Color.gray);
frame.addWindowListener(new WindowCloser( ) );
frame.getContentPane( ).add(panel,"Center");
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
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;
public static void main(String args[])throws Exception
{
byte buffer[]=new byte[2300];
ds=new DatagramSocket(serverport);
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
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;
public static void main(String args[])throws Exception
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
{
public static void main(String args[])throws Exception
{
ServerSocket ss=null;
try{
ss=new ServerSocket(9999);
}catch(IOException ie)
{}
Socket s1=null;
try{
s1=ss.accept();
642
}catch(Exception e)
{}
PrintWriter out=new PrintWriter(s1.getOutputStream(),true);
BufferedReader stdin=new BufferedReader(new
InputStreamReader(System.in));
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
{
public static void main(String args[])throws Exception
{
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.awt.event.*;
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.setLayout(new FlowLayout());
f.setBackground(Color.orange);
b1=new Button("Send");
b1.setBackground(Color.pink);
b1.addActionListener(this);
tf=new TextField(15);
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
InputStreamReader(s.getInputStream()));
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
{
public void windowClosing(WindowEvent we)
647
{
System.exit(0);
}
}
public void actionPerformed(ActionEvent ae)
{
pw.println(tf.getText());
tf.setText("") ;
}
public void run()
{
while(true)
{
try{
ta.append(br.readLine() +"\n");
}catch(Exception e)
{
}
}
}
public static void main(String args[])
{
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.awt.event.*;
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.setLayout(new FlowLayout());
f.setBackground(Color.orange);
b=new Button("Send") ;
b.addActionListener(this);
f.addWindowListener(new W1());
tf=new TextField(15);
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
InputStreamReader(s.getInputStream()));
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
{
public void windowClosing(WindowEvent we)
{
System.exit(0);
}
}
public void actionPerformed(ActionEvent ae)
{
pw.println(tf.getText()) ;
tf.setText("") ;
}
public void run()
{
while(true)
651
{
try{
ta.append(br.readLine()+"\n") ;
}catch(Exception e) {}
}
}
public static void main(String args[])
{
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
{
public static void main(String args[])throws Exception
{
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
{
public static void main(String args[])throws Exception
{
URL u=new URL("http://localhost:8085/ex1.jsp");
BufferedReader br=new BufferedReader(new
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
public static void main(String args[])throws Exception
{
URL u=new URL("http://localhost:8085/ex1.jsp");
URLConnection uc=u.openConnection();
BufferedReader br=new BufferedReader(new
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
Example-3(Type-3 Driver)
import java.sql.*;
import java.util.Properties; import javax.naming.Context;
import javax.naming.InitialContext; import javax.sql.DataSource;
public class Type3 {
public static void main(String[] args) {
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;
Example-4(Type-4 Driver)
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);
System.out.println(s);
}
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
{
DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
682
System.out.println("Connection to the database…");
Connection cn=DriverManager.getConnection
("jdbc:oracle:thin:@rashmi:1521:orc11","sai","sai");
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{
Connection cn=DriverManager.getConnection
("jdbc:oracle:thin:@rashmi:1521:orc11","sai","sai");
System.out.println("Connected to the database");
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{
Connection cn=DriverManager.getConnection
("jdbc:oracle:thin:@rashmi:1521:orc11","sai","sai");
System.out.println("Connected to the database");
Statement st=cn.createStatement();
st.executeUpdate("drop table Trans");
System.out.println("Table Trans dropped");
}catch(Exeception ex)
{
System.out.println("The exception raised is:"+ex);
}
}
}
The out put is follows:
Connected to the database
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{
Connection cn=DriverManager.getConnection
("jdbc:oracle:thin:@rashmi:1521:orc11","sai","sai");
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();
}catch(Exception ex)
{
686
System.out.println(“The Exception raised is ” + ex);
}
}
}
The output is as follows:
Connected to the database
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
{
DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
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
Statement st=cn.createStatement();
str="update product set price = "+ updateValue + ","+"where
prodId ="+refValue ;
st.executeUpdate(str);
System.out.println("Row Updated");
st.close();
cn.close();
}catch(Exception ex)
{
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
{
DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
try{
Connection cn = DriverManager.getConnection
("jdbc:oracle:thin:@rashmi:1521:orc11","sai","sai");
System.out.println("Connected to the database");
Statement st=cn.createStatement();
st.executeUpdate("delete from Product where ProdId=105");
System.out.println("One row deleted");
689
}catch(Exeception ex)
{
System.out.println("The Exception raised is:" +ex);
}
}
}
The output is as follows:
Connected to the database
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
("jdbc:oracle:thin:@rashmi:1521:orc11","sai","sai");
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();
}catch(Exeception ex)
{
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{
Connection cn=DriverManager.getConnection
("jdbc:oracle:thin:@rashmi:1521:orc11","sai","sai");
cn.setAutoCommit(false);
Statement stm=cn.createStatement();
stm.executeUpdate("Insert into transaction values(103, 101, 6, 1, '3-
jan-09‟)");
Statement st=cn.createStatement();
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();
}catch(Exception ex)
{
System.out.println("The Exception raised is " + ex);
cn.rollback();
693
}
}
}
The output is as follows:
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 {
public static void main(String args[]) {
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{
public static void main(String args[]){
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
{
public static void main(String args[])
{
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
{
public static void main(String args[])
{
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");
}
}
public static void main(String args[]) {
try {
aMethod();
} catch (Exception e) {
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 {
public static void main(String[] args) {
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
{
public static void main(String args[])
{
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 {
public static void main(String[] args) {
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();
System.out.println(j);
}
}
What is the result?
A. 0
B. 1
C. 2
D. Compilation fails.
QUESTION 13
public class Test{
public static void main(String args[]){
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
{
public static void main(String args[])
{
byte b=10;
byte c=15;
b=(byte)(b^c) ;
System.out.println(b);
}
}
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{
public static void main(String args[]){
int i = 0;
for (; i <4; i += 2) {
System.out.print(i + "");
}
System.out.println(i);
}
}
What is the result?
A. 0 2 4
B. 0 2 4 5
C. 0 1 2 3 4
D. Compilation fails.
E. An exception is thrown at runtime.
QUESTION 17
public class SwitchTest {
public static void main(String[] args) {
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 {
public static void main(String[] args) {
try {
return;
} finally {
709
System.out.println( "Finally" );
}
}
}
What is the result?
A. Finally
B. Compilation fails.
C. The code runs with no output.
D. An exception is thrown at runtime.
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
C. Compilation fails.
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); }
public static void main(String[] args) {
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
E. Compilation fails.
QUESTION 21
public class Test {
public static String output ="";
public static void foo(int i) {
try {
if(i==1) {
throw new Exception();
}
output += "1";
}
catch(Exception e) {
output += "2";
return;
}
finally {
output += "3";
}
output += "4";
}
public static void main(String args[]) {
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 {
public static void main( String[] args ) {
new Alpha();
new Base();
}
}
What is the result?
A. Base
B. BaseBase
C. Compilation fails.
D. The code runs with no output.
E. An exception is thrown at runtime.
713
QUESTION 23
public class Test{
public static void main(String args[]){
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
E. Compilation fails.
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
E. Compilation fails.
Answer: C
715
QUESTION 25
public class Test{
public static void main(String args[]){
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
E. Compilation fails.
QUESTION 26
public class X {
public static void main(String [] args) {
716
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() {
throw new RuntimeException();
}
}
What is the result?
A. AB
B. BC
C. ABC
D. BCD
E. Compilation fails.
QUESTION 27
717
public class Test{
public static void main(String args[]){
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
E. Compilation fails.
Answer: D
QUESTION 28
public class Conditional
{
public static void main(String args[])
{
718
int x=4;
System.out.println(“Value is ”+((x>4) ? ) 99.9 : 9);
}
}
What is the output ?
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
C. Compilation fails.
D. En exception is thrown at runtime.
QUESTION 30
class Super {
public int getLenght()
{
return 4;
}
}
public class Sub extends Super {
public long getLenght()
{
return 5;
}
public static void main(String[] args) {
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
E. Compilation fails.
QUESTION 31
class Test
{
static int x=10;
static{
x+=5;
}
public static void main(String args[])
{
System.out.println(x);
}
static{
x/=5;
}
}
721
What is the output ?
A. Compile time error
B. 10 C. 15
D. 3
QUESTION 32
public class X {
public static void main(String [] args) {
try {
badMethod();
System.out.print("A");
}
catch (RuntimeException ex) {
System.out.print("B");
}
catch (Exception ex1) {
System.out.print("C");
}
finally {
System.out.print("D");
}
System.out.print("E");
}
public static void badMethod() {
throw new RuntimeException();
722
}
}
What is the result?
A. BD
B. BCD
C. BDE
D. BCDE
E. ABCDE
F. Compilation fails.
QUESTION 33
public class Test
{
public static void main(String args[])
{
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
D. Compilation fails.
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
E. Compilation fails.
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 class Sub extends Super {
public Sub(String text) {
i = 2;
}
726
public static void main(String args[]) {
Sub sub = new Sub("Hello");
System.out.println(sub.i);
}
}
What is the result?
A. 0
B. 1
C. 2
D. Compilation fails.
QUESTION 38
public class Test{
public static void main(String args[]){
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
{
public static void main(String args[])
{
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”);
}
}
}
What is the output ?
A. Message One B. Message Two
C. Message Three D. Message Four
QUESTION 40
public class X {
public static void main(String [] args) {
try {
badMethod();
System.out.print("A");
}
catch (Exception ex) {
System.out.print("C");
}
finally {
System.out.print("B");
729
}
System.out.print("D");
}
public static void badMethod() {
throw new Error();
}
}
What is the result?
A. ABCD
B. Compilation fails.
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 {
public static void main(String args[]) {
try {
throw new Exc1();
} catch (Exc0 e0) {
System.out.println("Ex0 caught");
} catch (Exception e) {
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");
}
public static void main(String[] args) {
new A();
}
}
What is the result?
A. Class A
B. Compilation fails.
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();
}
public static void main( String[] args ) {
Beta b = getIt();
System.out.println( b.testIt() );
}
}
What is the result?
A. Tested
B. Compilation fails.
C. The code runs with no output.
D. An exception is thrown at runtime.
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
E. Compilation fails.
QUESTION 46
public class Test{
public static void main(String ar[]){
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
E. Compilation fails.
QUESTION 47
public class Test{
public static void main(String args[]){
try {
int x = 0;
int y = 5 / x;
} catch (Exception e) {
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
C. Compilation fails.
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
D. Compilation fails.
736
E. The code runs with no output.
F. An exception is thrown at runtime.
QUESTION 49
public class Test{
public static void main(String args[]){
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
E. Compilation fails.
Answer: B
QUESTION 50
737
public class X {
private static int a;
public static void main(String [] args) {
modify(a);
System.out.println(a);
}
public static void modify(int a) {
a++;
}
}
What is the result?
A. 0
B. 1
C. Compilation fails.
D. An exception is thrown at runtime.
QUESTION 51
public class Test {
public static void add3 (Integer i) {
int val = i.intValue();
val += 3;
i = new Integer(val);
}
public static void main(String args[]) {
738
Integer i = new Integer(0);
add3(i);
System.out.println(i.intValue());
}
}
What is the result?
A. 0
B. 3
C. Compilation fails.
D. An exception is thrown at runtime.
QUESTION 52
public class Test{
public static void main(String ar[]){
String a = null;
a.concat("abc");
a.concat("def");
System.out.println(a);
}
}
What is the result?
A. abc
B. null
739
C. abcdef
D. Compilation fails.
E. The code runs with no output.
F. An exception is thrown at runtime.
QUESTION 53
public class Test {
public static void main(String [] args) {
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
C. Compilation fails.
D. An exception is thrown at runtime.
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;
}
public static void main(String args[]) {
B b = new B();
System.out.println(b.getNumber());
}
}
What is the result?
A. 1
B. 2
C. An exception is thrown at runtime.
D. Compilation fails.
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 {
public static void main(String args[]) {
A a = new B();
}
}
What is the result when main is executed?
A. Compilation fails.
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");
}
public static void main(String[] args) {
new Thread(new MyThread()).start();
}
}
What is the result?
A. AAA
B. BBB
C. Compilation fails.
D. The code runs with no output.
QUESTION 58
public class X implements Runnable {
private int x;
private int y;
public static void main(String [] args) {
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?
A. Compilation fails.
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");
}
}
public static void main(String[] args) {
(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;
public static void main(String[] args) {
System.out.println(x[0]);
747
}
}
What is the result?
A. 0
B. null
C. Compilation fails.
D. A NullPointerException is thrown at runtime.
E. An ArrayIndexOutOfBoundsException is thrown at runtime.
QUESTION 61
public class Test{
public static void main(String[] args) {
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];
public static void main(String args[]) {
System.out.println("f[0] = " + f[0]);
}
}
What is the result?
A. f[0] = 0
B. f[0] = 0.0
C. Compilation fails.
D. An exception is thrown at runtime.
QUESTION 63
public class Test {
public static void main(String[] args) {
String str = NULL;
System.out.println(str);
}
}
749
What is the result?
A. NULL
B. Compilation fails.
C. The code runs with no output.
D. An exception is thrown at runtime.
QUESTION 64
public class Test{
public static void main(String ar[]){
System.out.println(Math.sqrt(-4D));
}
}
What is the result?
A. -2
B. NaN
C. Infinity
D. Compilation fails.
E. An exception is thrown at runtime.
QUESTION 65
public class Test{
public static void main(String args[]){
750
String a = "ABCD";
String b = a.toLowerCase();
b.replace('a', 'd');
b.replace('b', 'c');
System.out.println(b);
}
}
What is the result?
A. abcd
B. ABCD
C. dccd
D. dcba
E. Compilation fails.
F. An exception is thrown at runtime.
QUESTION 66
public class Foo {
public static void main (String [] args) {
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 {
public static void main (String [] args) {
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 {
public static void main(String args[]) {
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;
public static void main(String args[])throws Exception
{
756
new A().make();
}
public A()
{
x=5;
start();
}
public void make()throws Exception
{
join();
x=x-1;
System.out.println(x);
}
public void run()
{
x*=2;
}
}
What is the output?
QUESTION 73
public class Loop
{
static String o="";
757
public static void main(String args[])
{
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
}
public static void main(String args[])
{
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
{
public static void main(String args[])
{
}
}
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
{
public static void main(String args[])
{
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
{
public static void main(String args[])
{
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
{
public static void main(String argts[])
{
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++");
y++;
763
z=x/y;
}
System.out.println("I am executed");
}
}
What is the output?
QUESTION 79
public class Demo1
{
public static void main(String argts[])
{
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)
{
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");
}
}
public static void main(String args[])
{
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";
}
public static void main(String args[])
{
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
{
String getName(String n)
{
name=n;
return name;
}
int getRoll(int r)
{
roll=r;
return roll;
}
}
public static void main(String args[])
{
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};
public static void main(String args[])
{
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);
}
public static void main(String args[])
{
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”);
}
public static void main(String args[])
{
((Test1)new Test()).start();
}
}
What is the output?
QUESTION 88
interface Task1
{
String toString();
}
public class Task
{
public static void main(String args[])
{
System.out.println(new Task1()
{
772
public String toString()
{
return "Java";
}
});
}
}
What is the output?
QUESTION 89
public class Check
{
public static void main(String args[])
{
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;
System.out.println(i);
}
public static void main(String args[])
{
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");
}
public static void main(String args[])
{
Boot1 b=new Boot1();
System.out.println(b.s+"\t"+b.i);
}
}
What is the output?
776
QUESTION 92
public class N1
{
public static void main(String args[])
{
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
public static void main(String args[])
{
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;
}
public static void main(String args[])
{
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();
}catch(IOException ie)
{
System.out.println("Exception");
}
}
}
What is the output?
QUESTION 97
public class Process
{
static class A
{
void process()throws Exception
{
throw new Exception();
}
}
static class B extends A
{
void process()
781
{
System.out.println("B") ;
}
}
public static void main(String args[])
{
new B().process();
}
}
What is the output?
QUESTION 98
public class Ex1
{
static void test()throws RuntimeException
{
try{
System.out.print("Test") ;
throw new RuntimeException();
}catch(Exception e)
{
System.out.println("Caught");
}
}
public static void main(String args[])
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();
public static void main(String args[])
{
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);
}
public static void main(String args[])throws Exception
{
Serial s1=new Serial(12,7);
s1.readObject(ois);
s1.writeObject(oos);
}
}
What is the output?
top related