Java

PROGRAMMING IN JAVA
UNIT –I:
Introduction: Introduction to Java-Java & Internet- Byte codes -Features of Java–
Java Development Environment – Java Character set-Operators- Control Statements-Simple
Programs-Java History & features- Java Development Kit(JDK)-Java Tokens-Java
Statements-Arrays& Vectors-Strings & String buffers.
UNIT-II:
Classes , Interfaces and packages: Classes -Objects- Wrapper Classes- Packages
and Interfaces.
UNIT-III:
Inheritance: Inheriting Extending classes-abstract and Final classes- Interfaces and
Inheritance.
UNIT -IV:
Exception Handling: Error Handling- Exception Types and Hierarchy-Try Catch
blocks-use of Throw, Throws and finally-programmer Defined Exceptions.
UNIT-V:
Applet and Graphics: Fundamentals of Applets-Graphics. AWT and Event
Handling: AWT Components and Event Handlers – AWT Controls and Event Handling –
Types and Examples-Swing introduction. Input and output: files –streams. Multithreading
and networking: multiple threads- networking basics.
TEXT BOOK:
1) Patrick Naughton, Herbert Schildt, “JAVA2- The Complete Reference”, Tata
McGraw Hill, fifth Edition, New Delhi, 2002.
2) Hubbard John R, “ Schaum’s Outline of theory and problems of programming
with Java”,Tata McGraw Hill , Second Edition, New Delhi,2004.
-1-
UNIT I
INTRODUCTION: INTRODUCTION TO JAVA:
 Many programming languages approaches have been tried.

 These include techniques such as modular programming, top-down programming,
bottom-up programming and structured programming.
 The primary motivation in each case has been the concern to handle the increasing
complexity of programs that are reliable and maintainable.
 Object-oriented programming(OOP) is an approach to program organization and
development, which attempts to eliminate some of the pitfalls of conventional
programming methods by incorporating the best of structured programming features
with several new concepts.
 It is a new way of organizing and developing programs and has nothing to do with
any particular language.
JAVA AND INTERNET:
 The Java programming language enables the Web documents authors to deliver small
application programs to anyone browsing the pages of the html documents.
 The page becomes alive because it can create game score boards, execute animated
cartoons, audio files and video clippings.
 In addition, it changed the way internet and WWW worked by allowing

architecturally neutral compiled code to be dynamically loaded from anywhere in the
network of heterogeneous systems and executed transparently.
-2-
BYTE CODES:
 Byte code is the intermediate representation of Java programs just as assembler is the
intermediate representation of C or C++ programs.
 The most knowledgeable C and C++ programmers know the assembler instruction
set of the processor for which they are compiling.
 This knowledge is crucial when debugging and doing performance and memory
usage tuning.
 Knowing the assembler instructions that are generated by the compiler for the source
code you write, helps you know how you might code differently to achieve memory
or performance goals.
 In addition when tracking down a problem, it is often useful to use a debugger to
disassemble the source code and step through the assembler code that is executing.
 Java is the bytecode that is generated by the javac compiler.
 Understanding bytecode and what bytecode is likely to be generated by a java
compiler helps the java programmer in the same way that knowledge of assembler
helps the C or C++ programmer.
 The bytecode is your program.
 Consider that the more bytecode you have, the bigger the .class file is and the more
code that has to be compiled by a JIT or Hotspot runtime.
FEATURES OF JAVA:
Sun Microsystems officially describes java with the following attributes:
 Compiled and Interpreted
 Platform-Independent and Portable
 Object-Oriented
 Robust and Secure
 Distributed
 Familiar, Simple and Small
 Multithreaded and Interactive
 High performance
 Dynamic and Extensible
-3-
- A computer language is either complied or interpreted.
- Java combines both theses approaches thus making Java a two-stage system.
- First, Java compiler translates source code into byte code instructions.
- Second, Java interpreter generate machine code that can be directly executed
in the machine that is running the Java program.
- The most significant contribution of java over other languages is its
portability.
- Java programs can be easily moved from one computer system to another,
anywhere and anytime.
- Changes and upgrades in Os and processors will not force any changes in java
programs.
- Java ensures portability in two ways. First, Java compiler generates byte code
instructions that can be implemented on any machine.
- Second, the size of the primitive data types is machine independent.
 Object-Oriented
- Java is a true object-oriented language.
- Everything in java is an object.
- All programs and data reside within objects and classes.
- Java comes with an extensive set of classes, arranged in packages, that can be
used by inheritance.
- Java is a robust language.
- It provides many safeguards to ensure reliable code.
- It has strict compile time and run time checking for data types.
- Java also incorporates the concept of exception handling which captures series
errors and eliminates any risk of crashing the system.
- Security becomes an important issue for a language that ensures no viruses are
communicated with an applet.
-4-
 Distributed
- Java is designed as a distributed language for creating applications on
networks.
- It has the ability to share both data and programs.
- This enables multiple programmers at multiple remote locations to collaborate
and work together on a single project.
 Simple, Small and Familiar
- Java is a small and simple language. Many features of C and C++ are not part
of java.
- Java does not use pointers, preprocessor header files, goto statement and many
others.
- It also eliminates operator overloading and multiple inheritance.
- Java is a simplified version of C++.
- Multithreaded means handling multiple tasks simultaneously.
- Java supports multithreaded programs. This means that we need not wait for
the application to finish one task before beginning another.
- This feature greatly improves the interactive performance f graphical
applications.
- Java architecture is also designed to reduce overheads during runtime.
- The incorporation of multithreading enhances the overall execution speed of
java programs.
- Java is a dynamic language. Java is capable of linking in new class libraries,
methods, and objects.
- Java programs support functions written in other languages such as C and C+
+. These functions are known as native methods.
-5-
Java Development Environment :
- Java environment includes a large number of development tools and hundreds
of classes and methods.
- The development tools are part of the system known as Java Development Kit
(JDK) and the classes and methods are part of the Java Standard Library
(JSL), also known as the Application Programming Interface(API).
CHARACTER SET:
 Characters are the smallest unit of java language.
 These are used to write java tokens.
 Java characters are defined by Unicode character set.
 The Unicode is a 16 bit character coding system and currently supports more than
34,000 defined characters derived from 24 languages.
JAVA OPERATORS:
- Java supports a rich set of operators.
- Java operators can be classified as unary, binary or ternary-meaning taking
one, two, or three arguments, respectively.
- A unary operator may appear before (prefix) its argument or after(postfix) its
argument.
- A binary or ternary operator appears between its arguments.
- An operator is a symbol that tells the computer to perform certain
mathematical or logical manipulations.
- Java operators can be classified into a number of related categories as below:
1. Arithmetic operators
2. Relational operators
3. Logical operators
4. Assignment operators
5. Increment and decrement operators
6. Conditional operators
7. Bitwise operators
-6-
8. Special operators
1. Arithmetic operators
- Java provides all the basic arithmetic operators.
- The operators +, -, *, and / all work the same way as they do in other
languages.
Operator Meaning
+ Addition
- Subtraction
* Multiplication
/ Division
% Modulo division
- Ex: a+b, a-b, -a*b

- Here a and b are may be variables or constants and are known as operands.
Integer Arithmetic
- When both the operands in a single arithmetic expression such as a+b are
integers, the expression is called an integer expression, ant the operation is
called integer arithmetic.
- A=14, b=4 , we have the following results:
A – b = 10
A + b = 18
A * b = 56
A/ b=3
A%b=2
Real Arithmetic
- An arithmetic operation involving only real operands is called real arithmetic.
- A real operand may assume values either in decimal or exponential notation.
Ex:
A = 20.5, b = 6.4
-7-
A + b = 26.9
A – b = 14.1
Mixed-mode Arithmetic
- When one of the operands is real and the other is integer, the expression is
called a mixed-mode arithmetic expression.
- Ex: a=10, b=3.5
A+b=13.5
a-b=6.5
2. Relational Operators
- We often compare two quantities, and depending on their relation, take
certain decisions.
- These comparisons can be done with the help of relational operators.
Operator Meaning
< is less than
<= is less than or equal to
> is greater than
>= is greater than or equal to
== is equal to
!= is not equal to
- A simple relational expression contains only one relational operator and is of

the following form:
Ae-1 relational operator ae-2
Ex:
A>b
A +b = = c + d
-35 > = 0
Logical Operator
- In addition to the relational operators, java has three logical operators, which
are given below:
-
-8-
Operator Meaning
&& logical AND

|| logical OR
! logical NOT
- An expression of this kind which combines two or more relational expressions

is termed as a logical expression or a compound relational expression..
- Some examples:
1. if (age > 55 && salary < 1000)
2. if (num < 0 || num >100)
Assignment operators
- Assignment operators are used to assign the value of an expression to a
variable.
- We have seen the usual assignment operator, ‘ = ‘.
- Java has a set of ‘shorthand’ assignment operators which are used in the form
V op= exp;
- where v is a variable, exp is an expression and op is a java binary operator.

Ex: x += 1 is equal to x = x + 1
- Advantages:
1. What appears on the left hand side need not be repeated and therefore it
becomes easier to write.
2. The statement is more concise and easier to read.
3. Use of shorthand operator results in a more efficient code.
Increment and Decrement Operator

- The increment and decrement operators are ++ and --.
- The operator ++ adds 1 to the operand while – subtracts 1.
- Both are unary operators and are used in the following form:
-9-
++m or m++;
--m or m—
++m; is equal to m = m + 1; or m += 1;
- A prefix operator first adds 1 to the operand and then the result is assigned to
the variable on left.
- A postfix operator first assigns a value to the variable on left and then
increments the operand.
Conditional Operator
- The character pair ?: is a ternary operator available in java.
- This operator is used to construct conditional expression of the form
Exp1 ? exp2 : exp3
Where exp1, exp2, exp3 are expressions.

- This works as follows: exp1 is evaluated first. If it is true, then the expression
exp2 is evaluated and becomes the value of the conditional expression. If exp1
is false, exp3 is evaluated and it becomes the value of the conditional
expression.
Ex: a = 10;
b = 15;
x = (a > b) ? a : b;
Bitwise Operators
- These operators are used for manipulation of data at values of bit level.
- These are used for testing the bits, or shifting them to the right or left.
- These may not be applied to float or double.
Operator Meaning
& bitwise AND
! bitwise OR
^ bitwise exclusive OR
~ one’s complement
<< Shift left
>> Shift right
>>> Shift right with zero fill
- 10 -
Special Operators
- Java supports some special operators of interest such as instanceof and
member selection operator (.)
 Instanceof Operator
- The instanceof is an object reference operator and returns true if the object on
the left-hand side is an instance of the class given on the right hand side.
- This operator allows us to determine whether the object belongs to particular
class or not.
Ex:
person instanceof student
- is true if the object person belongs to the class student; otherwise it is false.
 Dot Operator
- The dot operator is used to access the instance variables and methods of class
objects.
- Ex:
Person1.age // Reference to the variable age
Person1.salary // Reference to the method salary
CONTROL STATEMENTS:
- A java program is a set of statements, which are normally executed
sequentially in the order in which they appear.
- When a program breaks the sequential flow and jumps to another part of the
code, it is called branching.
- When the branching is based on a particular condition, it is known as
conditional branching.
- If branching takes place without any decision, it is known as unconditional
branching.
- 11 -
- Java supports the following statements known as control or decision making
statements.
1. If statement
2. switch statement
3. Conditional operator statement
IF statement
- The if statement is a powerful decision making statement and is used to
control the flow of execution of statements.
- It is basically a two-way decision statement and is used in conjunction with an
expression.
- It takes the following form:
If (test expression)
- It evaluates the computer to evaluate the expression first and then depending
on whether the value of an expression is ‘true’ or ‘false’, it transfers the
control to a particular statement.
- This has two paths to follow, one for the true and the other for the false.
Entry
False
Test
expres
sion ?
True
Ex:
1. If (bank balance is zero)
Borrow money
2. If (room is dark)
- 12 -
Put on lights
The if statement may be implemented in different forms:

1. Simple if statement
2. if…else statement
3. Nested if…else statement
4. else…if ladder
Simple IF statement
- The general form of a simple if statement is
If (test expression)
{
statement-block;
}
statement-x;
- If the test expression is true, the statement-block will be executed; otherwise

the statement-block will be skipped and the execution will jump to the
statement-x.
Ex:
If (category = = sports)
{
marks = marks + bonus_marks;
}
System.out.println(marks);
……….
The IF…ELSE statement
- The if…else statement is an extension of the simple if statement. The general
form is
If (test expression)  --
{
True-block statement (s)
}
else
{
- 13statement
False-block - (s)
}
statement-x;
- If the test expression is true, then the true-block statements immediately
following the if statement, are executed; Otherwise the false-block statements
are executed.
- In either case, either true-block or false-block will be executed, not both.
- In both the cases, the control is transferred to the statement-x.
Ex:
………..
if (code = = 1)
boy = boy + 1;
else
girl = girl + 1;
xxx;
………….
Nesting of IF…Else statements

- When a series of decisions are involved, we may have to use more than one
if…else statements in nested form as follows:
If (test condition1)
{
if (test condition2)
{
statement-1;
}
else
{
statement-2;
}
}
else
{
statement-3;
}
- 14 -
statement-x;
- If the condition-1 is false, the statement-3 will be executed; otherwise it
continues to perform the second test.
- If the condition-2 is true, the statement-1 will be evaluated; otherwise the
statement-2 will be evaluated and then the control is transferred to the
statement-x.
Ex:
……..
if (sex is female)
{
if(balance > 5000)
bonus = 0.05 * balance;
else
}
else
{
}
balance = balance + bonus;
……………
……………
The ELSE IF Ladder

- There is another way of putting ifs together when multipath decisions are
involved.
- A multipath decision is a chain of ifs in which the statement associated with
each else is an if.
- It takes the following form
If (condition 1)
Statement-1;
- 15 -
Else if (condition 2)
Statement-2;
Else if (condition 3)
Statement-3;
……………
else if (condition n)
statement-n;
else
default-statement;
statement-x;
- This construct is known as the else if ladder.

- The conditions are evaluated from the top, downwards.
- As soon as the true condition is found, the statement associated with it is
executed and the control is transferred to the statement-x.
- When all the n conditions become false, then the final else containing the
default-statement will be executed.
Ex:
If (marks > 79)
Grade = “Honours”;
Else if (marks > 59)
Grade = “First division”;
Grade = “Second division”;
Grade = “Third division”;
Else
Grade = “Fail”;
System.out.println (“Grade: “+ grade);
The Switch statement
- 16 -
- The switch statement tests the value of a given variable against a list of case
values and when a match is found, a block of statements associated with that
case is executed.
- The general form of the switch statement is as shown below:
Switch (expression)
{
case value-1:
block-1
break;
case value-2:
block-2
break;
………
………
default:
default-block
break;
}
statement-x;
- When the switch is executed, the value of the expression is successively

compared against the values value-1, value-2,.
- If a case is found whose value matches with the value of the expression, then
the block of statements that follow the case are executed.
- The break statement at the end of each block signal the end of a particular case
and causes an exit from the switch statement, transferring the control to the
statement-x following the switch.
Ex:
……………
index = marks/10;
switch (index)
{
case 10:
case 9:
case 8:
grade = “Honours”;
break;
- 17 -
case 7:
case 6:
grade = “First division”;
break;
case 5:
grade = “Second division”;
break;
case 4:
grade = “Third division”;
break;
default:
grade = “Fail”;
break;
}
system.out.println(grade);
…………
…………
Repetition Statements:
Looping
- The process of repeatedly executing a block of statements is known as looping.
- The java language provides for three constructs for performing loop operations.
1. The while statement
2. The do statement
3. the for statement
The WHILE statement

- The simplest of all the looping structures in java is the while statement.
- The basic format of the while statement is
Initialization;
While (test condition)
{
body of the loop
- 18 -
}
- The while is entry-controlled loop statement.
- The test condition is evaluated and if the condition is true, then the body of the
loop is executed.
- This process of repeated execution of the body continues until the test
condition becomes false and the control is transferred out of the loop.
Ex:
………….
sum = 0;
n =1;
while (n <= 10)
{
sum = sum + n * n;
n = n + 1;
}
system.out.println(“Sum = “ + sum);
The DO statement
- It has the following form
Initialization;
do
{
body of the loop
}
While (test condition)
- On reaching the do statement, the program proceeds to evaluate the body of

the loop first.
- At the end of the loop, the test condition is evaluated.
- If the condition is true, the program continues to evaluate the body of the loop
once again.
- 19 -
- When the condition becomes false, the loop will be terminated and the control
goes to the statement that appears immediately after the while statement.
Ex:
………….
I =1;
Sum = 0;
Do
{
sum = sum + I;
I = I + 2;
}
while (sum < 40 || I <10);
……………
The FOR statement

- The for loop is another entry-controlled loop that provides a more concise
loop control structure.
- The general form of the loop is
For (initialization; test condition; increment)

{
Body of the loop
}
- The execution of the for statement is as follows:

1. Initialization of the control variables is done first, using assignment
statements such as I =1 and count =0.
2. The value of the control variable is tested using the test condition.
3. When the body of the loop is executed, the control is transferred back to the
for statement after evaluating the last statement in the loop.
Ex:
For (x = 0; x < = 9; x = x + 1)
{
system.out.println(x);
- 20 -
}
Additional features of for loop

1. More than one variable can be initialized at a time in the for statement.
2. The increment section may also have more than one part.
Ex: for(n=1, m=50; n<=m; n=n+1,m=m-1)
3. The test condition may have any compound relation and the testing need not be
limited only to the loop control variable.
4. To use expressions I the assignment statements of initialization and increment section.
Ex: for (x=(m+n0/2; x>0; x=x/2)
5. One or more sections can be omitted.
Ex: m=5;
For (;m != 100;)
Jumps in Loops
- Loops perform a set of operations repeatedly until the control variable fails to
satisfy the test condition.
- Java permits a jump from one statement to the end or beginning of a loop as
well as a jump out of a loop.
Jumping out of a loop

- An early exit from a loop can be accomplished by using the break statement.
- When the break statement is encountered inside a loop, the loop is
immediately exited and the program continues with the statement immediately
following the loop.
- The break will exit only a single loop.
Do
{
………
………
if(condition)
break;
……….
}while(…….)
…………….
- 21 -
For(……..)
{
.……..
For (………)
{
if (condition)
break;
………..
}
…………..
}
Skipping a part of a loop

- The continue causes the loop to be continued with the next iteration after
skipping any statements in between.
- The continue statement tells the compiler, “SKIP THE FOLLOWING
STATEMENTS AND CONTINUE WITH THE NEXT ITERATION”.
- The format of the continue statement is simply
Continue;
For (………)
{
………..
if (condition)
continue;
………..
}
- 22 -
Return statements:
 It is a special branching statement that transfers the control to the caller of the
method.
 This statement is used to return a value to the caller method and terminates execution
of method.
 This has two forms: one that returns a value and the other that can not return, the
returned value type must match the return type of method.
Syntax:
return:
return values;
return; // this returns nothing . so this can be used when method

is declared with void return type.
Return expression; // it returns the value evaluated from the expression.
Simple Java program

 public : access by any other class anywhere.
 protected: accessible by the package classes and any subclasses that are in other
packages.
 Default –(also known as “ package private”) accessible to classes in the same package
but not by classes in other packages, even if these are subclasses.
 private- accessible only within the class. Even methods in subclasses in the same
package do not have access.
- The best way to learn a new language is to write a few simple example
programs and execute them.
- 23 -
Ex:
Class sampleone
{
public static void main(String args[])
{
System.out.println(“Java is better than c++”);
}
}
Class Declaration:
- The first line Class sampleone declares a class. Everything must be placed
inside a class.
- Class name is a valid keyword.
Opening Brace:
- Every class definition in java begins with an opening brace “{“ and ends with
a matching closing brace “}”.
The Main line:

- The third line
Public static void main(String args[])
Main - A java application can have any number of classes but only one of them
must include a main method to initiate the execution.
Public – It is an access specifier that declares the main method as unprotected
and making it accessible to other classes.
Static – The keyword static, which declares this method as one that belongs to
the entire class and not a part of any objects of the class.
Void – Void states that the main method does not return any value.
- 24 -
The Output line:
- The only executable statement in the program is
System.out.println(“Java is better than C++’);
- This is similar to the printf() statement of C or cout << construct of C++.
- The println method is a member of the out object, which is a static data
member of System class.
- Every java statement must end with a semicolon.
JAVA HISTORY & FEATURES:

 Around 1990 James Gosling, Bill Joy and others at Sun Microsystems began
developing a language called Oak.
 The wanted it primarily to control microprocessors embedded in consumer items
such as cable set-top boxes, VCR’s toasters, and also for Personal Data Assistants
(PDA).
 To serve these goals Oak needed to be:
o Platform independent(since multiple manufacturers involved)
o Extremely reliable
o Compact
 However as of 1993, interactive TV and PDA markets had failed to take off.
 Then the internet and web explosion began, so sun shifted the target market to
internet applications and changed the name of the project to Java.
 By 1994 Sun’s HotJava browser appeared.
 Written in Java in only a few months.
 Riding along with the explosion of interest and publicity in the internet, java quickly
received widespread recognition and expectations grew for it to become the dominant
software for browser and consumer applications.
 Java has also become quite common on small platform such as cell phones and PDAs.
 Java is now used in several hundred cell phone models.
 Over 600 million JavaCards, smartcards with additional features provided by java,
have been sold as of the summer of 2004.
- 25 -
Sun Microsystems officially describes java with the following attributes:
 Object-Oriented
 Distributed
 Familiar, Simple and Small
JAVA DEVELOPMENT KIT:
- The Java development Kit comes with a collection of tools that are used for
developing and running java programs. They include
- Appletviewer (for viewing java applets)-this tool can be used to run and debug
java applets without a web browser.
- Javac (java compiler) , which converts source code into Java bytecode.
- Java (java interpreter)
- Javap (java disassembler)
- Javah (for C header files)
- Javadoc (for creating HTML documents)
- Jdb (Java debugger)
- 26 -
Text Editor
Java Source HTML

Code javadoc
files
Javac
Java Class File Header

javah
files
Java Jdb
Java Program
output
Application Programming Interface

- The Java standard library includes hundreds of classes and methods grouped
into several functional packages.
- Most commonly used packages are:
 Language Support Package: A collection of classes and methods required for
implementing basic features of java.
 Utilities Package: A collection of classes to provide utility functions such as
date and time functions.
 Input/Output Package: A collection of classes required for input/output
manipulation.
 Networking Package: A collection of classes for communicating with other
computers via internet.
 AWT Package: The Abstract Window Tool Kit package contains classes that
implements platform-independent graphical user Interface.
- 27 -
 Applet Package: This includes a set of classes that allows us to create Java
applets.
JAVA TOKENS:
 A token is an individual element in a program.
 More than one token can appear in a single line separated by white spaces.
 Keywords , identifiers, operators, separators, literals.
 Java character set: Characters are the smallest unit of java language.
 These are used to write java tokens.
 Java characters are defined by Unicode character set.
KEYWORDS:
 Keywords are words which belong to java language.
 They have standard predefined meaning. These words should be used only for their
intended purpose. The keywords should be written in lowercase. Some of the
keywords are:
o For , do, while, goto, if ,else, int, char, byte, switch, void, try, catch,
public,protected, private, static, throw, throws.
IDENTIFIERS:
 Identifiers are names given to classes, methods, variables, objects,
arrays, packages, and interfaces in a program. These are user defined names.
Rules:
 Identifiers are formed with alphabets, digits, underscore, and dollar
sign characters.
 The first character must be an alphabet.
 They can be any length.
 They are case sensitive.
LITERALS:
 Literals are names that represent constant values.
 A constant is a quantity that does not change during program execution. There are
five types of literals. They are
- 28 -
o Interger literal
o Floating point literals
o Character literals
o String literals
o Boolean literals
Operators:
 An operator is a symbol which represents some operation that can be
performed on data.
 There are eight operators in java.
 They are Arithmetic operators, relational,logical,short hand assignment
,increment and decrement operators, conditional, bitwise, special operators.
Separators:
 Separators are symbols which belong to java language.
 These are used to indicate where group of codes are divided and arranged.
 There are six operators available. They are
o ( ) Parenthesis – used to enclose arguments.
o { } braces – used to enclose block of codes.
o [ ] bracksets – used in arrays.
o ; Semicolon-used to separate statements.
o , comma- used separate variable in declaration.
o .Period – used to separate package names from sub-packages and classes.
JAVA STATEMENTS:
 The java statements in java are like sentences in natural languages.
 A statement is an executable combination of tokens ending with a
semicolon(;) mark.
 Statements are usually executed in sequence in the order in which they
appear.
List of Statement:
- 29 -
1) Empty Statement – These do nothing and are used during program development as a
place holder.
2) Labelled Statement – Any statement may begin with a label. Such labels must not be
keywords.
3) Expression Statement – Most statements are expression statements.
Statements : Assignment, pre-increment,pre-decrement,post-increment,post-decrement,
method call and allocation Expression.
4) Selection Statement – Theae select one of several control flows. There are 3 types of
selection statements in java: if, if-else and switch.
5) Iteration Statement – These specify how and when looping will take place. There are
3 types of iteration statements: while, do, and for.
6) Jump Statement – It pass control to the beginning or end of the current block, or to a
labeled statement. Such labels must be in the same block, and continue, return, throw.
7) Synchronization Statement – Used for handling issues with multi-threading.
8) Guarding Statement – It used for safe handling of code that may cause exceptions.
ARRAYS & VECTORS:

Arrays:
- An array is a group of contiguous or related data items that share a common
name.
- A particular value is indicated by writing a number called index number or
subscript in brackets after the array name.
For ex, salary[10] represents the salary of the 10th employee.
- While the complete set of values is referred to as an array, the indidual values
are called elements.
- Array can be of any variable type.
One dimensional array
- A list of items can be given one variable name using only one subscript and
such a variable is called a single-subscripted variable or a one-dimensional
array.
- The subscript can begin with number 0. That is x[0] is allowed.
- For example, if we want to represent a set of five numbers, say(35,40,20,57,19)
by array variable number, then we may create the variable number as follows
- 30 -
Int number[] = new int[5];
- and the computer reserves five storage locations as shown below:
number[0]
number[1]
number[2]
number[3]
number[4]
- The values to the array elements can be assigned as follows:

Number[0] = 35;
Number[1] = 40;
Number[2] = 20;
Number[3] = 57;
Number[4] = 19;
This would cause the array number to store the values shown as follows:
Number[0] 353
35
Number[1] 40
Number[2] 20
Number[3]
57
Number[4] 19
Creating an Array
- Arrays must be declared and created in the computer memory before they are
used.
- Creation of an array involves three steps:
1. Declare the array

2. Create memory locations
3. Put values into the memory locations.
- 31 -
Declaration of Arrays
- Arrays in Java may be declared in two forms:
Form1
Type arrayname[];
Form2
Type[] arrayname;
Examples:
- Int number[];
- Float average[];
- Int[] counter;
Creation of Arrays
- After declaring an array, we need to create it in the memory.
- Java allows creating arrays using new operator only, as shown below.
Arrayname = new type[size];
Examples:
Number = new int[5];
Average = new float [10];
Initialization of Arrays
- The final step is to put values into the array created. This process is known as
initialization.
- This is done using the array subscripts as shown below.
Arrayname [subscript] = value;
- We can also initialize arrays automatically in the same way as the ordinary
variables when they are declared, as shown below.
- 32 -
Type arrayname[] = (list of values);
- The array initializer is a list of values separated by commas and surrounded by

curly braces.
Array length
- In java, all arrays store the allocated size in a variable named length.
- We can access the length of the array a using a.length.
- Example: int a Size = a.length;
Example:
Class NumberSorting
{
{
int num[] = {55, 40, 80, 65, 71};
int n = num.length;
System.out.print(“Given list:”);
For(int I = 0; I < n; i++)
{
system.out.print(“ “ + num[i]);
}
system.out.println(“\n”);
for(int I = 0; I < n; i++)
{
for (int j = I + 1; j < n; j++){
if(num[i] < num[j])
{
int temp = num[i];
num[i] = num[j];
num[j] = temp;
}
- 33 -
}
}
system.out.print(“Sorted list :”);
For(int I = 0; I < n; i++){
system.out.print(“ “ + num[i]);
}
system.out.println(“ ”);
}
}
Output:
Given list : 55 40 80 65 71
Sorted list : 80 71 65 55 40
Two dimensional arrays

- In mathematics, we represent a particular value in a matrix by using two
subscripts such as vij . Here v denotes the entire matrix and v ij refers to the
value in the ith row and jth coloumn.
- Ex: v[4][3];
- For creating two-dimensional arrays, we must follow the same steps as that of
simple arrays. We may create a two-dimensional array like this:
Int myArray[][];
myArray = new int[3][4];
-This creates a table that can store 12 integer values, four across and three
down.
Variable Size Arrays
- Java treats multidimensional arrays as “arrays of arrays”.

- It is possible to declare a two-dimensional array as follows:
Int x[][] = new int[3][];
- 34 -
X[0] = new int[2];
X[1] = new int[4];
X[2] = new int[3];
- These statements create a two-dimensional array as having different lengths
for each row as shown below:
X[0][1]
X[0]
X[1] x[1][3]
X[2]
X[2][2]
VECTORS:
 C and C++ programmers will know that generic utility functions with variable
arguments can be used to pass different arguments depending upon the calling
situations.
 Java does not support the concept of variable arguments to a function.
 This feature can be achieved in java through the use of the Vector class contained
in the java.util package.
 This class can be used to create a generic dynamic array known as vector that can
hold objects of any type and any number.
 The objects do not have to be homogenous.
 Arrays can be easily implemented as vectors.
 Vectors are created like arrays as follows:
o Vector intVect = new Vector( ); // declaring without size
o Vector list = new Vector(3); // declaring with size
 A vector can be declared without specifying any size explicitly.
 A vector can accommodate an unknown number of items.
 Vectors possess a number of advantages over arrays:
1. It is convenient to use vectors to store objects.
2. A vector can be used to store a list of objects that may vary in size.
3. we can add and delete objects from the list as and when required.
- 35 -
 A major constraint in using vectors is that we cannot
directly store simple data types in a vector; we can only store objects.
 We need to convert simple types to objects.
 The vector class supports a number of methods that can be
used to manipulate the vectors created.
 Important Vector methods:
List.addElement(item) - Adds the item specified to the list at the end
List.elementAt(10) - gives the name of the 10th object
List.size() - Gives the number of objects present
List.removeElement(item) - Removes the specified item from the list
List.removeElementAt(n) - Removes the item stored in the nth position of
the list
List.removeAllElements() - Removes all the elements in the list
List.copyInto(array) - copies all items from list to array
List.insertElementAt(item , n) - inserts the item at nth position
Example programs:
Import java.util.*;
Class languageVector
{
{
Vector list = new Vector();
int length = args.length;
for(int i=0; i< length; i++)
{
List.addElement(args[i]);
}
list.insertElementAt(“COBOL”,2);
int size = list.size();
String listArray[] = new String[size];
- 36 -
list.copyInto(listArray);
System.out.println(“list of languages”);
for(int i=0 ; i< size; i++)
{
System.out.println(listArray[i]);
}
}
}
STRINGS & STRING BUFFERS:

STRINGS:
 String manipulation is the most common part of many java programs.
 Strings represent a sequence of characters.
 The easiest way to represent a sequence of characters in java is by using a
character array.
 Example:
Char charArray[] = new char[4];
charArray[0] = ‘J’;
charArray[1] =’a’;
charArray[2] =’v’;
charArray[3]=’a’;
 Strings are class objects and implemented using two classes, namely String and
StringBuffer.
 A java string is an instantiated object of the String class.
o String stringName;
o StringName = new String(“ string”);
Example:
String firstName;
firstName = new String(“Anil”);
These two statements may be combined as follows:
String firstName = new String(“Anil”);
- 37 -
Like arrays it is possible to get the length of string using the length method of the string
class.
int m = firstName.length( );
String Buffer:
 StringBuffer is a peer class of String.
 While String creates strings of fixed_length, StringBuffer creates strings of flexible
length that can be modified in terms of both length and content.
 We can insert characters and substrings in the middle of a string, or append another
string to the end.
StringBuffer Methods:
o S1. setChartAt(n, ‘x’) -Modifies the nth character to x
o S1.append(s2) - Appends the string s2 to s1 at the end
o S1.insert(n, s2) - Inserts the string s2 at the position n of the string s1
o S1.setLength(n) -Sets the length of the string s1 to n. if n<s1.length()
s1 is truncated. If n>s1.length() zeros are added to s1
UNIT II
CLASSES,INTERFACES AND PACKAGES:
CLASSES:
- 38 -
- Class provides a convenient method for packing together a group of logically
related data items and functions that work on them.
- In java, the data items are called fields and the functions are called methods.
- Class is a template for an object, and an object is an instance of a class.
Defining a Class
- Once the class type has been defined, we can create ‘variables’ of that type using
declarations that are similar to the basic type declarations.
- In java, these variables are termed as instances of classes.
- The basic form of a class definition is:
Class classname [extends superclassname]

{
[ variables declaration; ]
[ methods declaration; ]
}
- Everything inside the square brackets is optional.

- Classname and superclassname are any valid java identifiers.
Adding variables
- Data is encapsulated in a class by placing data fields inside the body of the class
definition.
- These variables are called instance variables because they are created whenever
an object of the class is instantiated.
- We can declare the instance variables exactly the same way as we declare local
variables.
- Instance variables are also known as member variables.
Ex:
Class Rectangle
{
- 39 -
int length;
int width;
}
Adding Methods
- A class with only data fields has no life.
- Methods are declared inside the body of the class but immediately after the
declaration of instance variables.
- The general form of a method declaration is
Type methodname (parameter-list)

{
Method-body;
}
- Method declarations have four basic parts:

 The name of the method (method name)
 The type of the value the method returns (type)
 A list of parameters (parameter-list)
 The body of the method
- Let us consider the Rectangle class again and add a method getData ( ) to it.
Class Rectangle
{
int length;
int width;
void getData(int x , int y)
{
length = x;
length = y;
}
}
- The getData method is added to provide values to the instance variables.
- 40 -
- We want to compute the area of the rectangle defined by the class. This can be
done as follows:
Class Rectangle
{
int length, width;
void getData (int x, int y)
{
length = x;
width = y;
}
int rectArea ( )
{
int area = length * width;
return (area);
}
}
OBJECTS:
Creating Objects
- Creating an object is also referred to as instantiating an object.
- Objects in java are created using the new operator. The new operator creates an
object of the specified class and returns a reference to that object.
- Example of creating an object of type Rectangle.
Rectangle rect1; // declare
Rect1 = new Rectangle ( ); // instantiate
- The first statement declares a variable to hold the object reference and the second
one assigns the object reference to the variable.
- Both statements can be combined into one as shown below:
Rectangle rect1 = new Rectangle ( );
Accessing Class members

- All variables must be assigned values before they are used.
- Since we are outside the class, we cannot access the instance variables and the
methods directly.
- 41 -
- To do this, we must use the concerned object and the dot operator as shown
below:
Objectname. Variable name

Objectname. Methodname (parameter- list);
- The instance variables of the Rectangle class may be accessed and assigned
values as follows:
Rect1.length = 15;
Rect1.width = 10;
Rect2.length = 20;
Rect2.width = 12;
Constructors
- It would be simpler and more concise to initialize an object when it is first
created.
- Java supports a special type of method, called a constructor, that enables an
object to initialize itself when it is created.
- Constructors have the same name as the class itself. They do not specify a return
type, not even void.
Ex:
Class rectangle
{
int length;
int width;
Rectangle (int x, int y) // constructor method
{
length = x;
width = y;
}
int rectArea( )
{
return (length * width);
- 42 -
}
}
Parameterized Constructor
- When a default constructor is used in a class, all the objects of the class will have the
same default values for their member data.
- Consider three objects of integer class which are declared as follows:
Integer a, b, c;
- A constructor, which takes arguments, is called parameterized constructor.
- The arguments are then assigned to the members of the class.
- The general form of a parameterized constructor in class A is as follows:
A(type arg1, type arg2,…., type argn)
{
member1 = arg1;
member2 = arg2;
:
membern = argn;
}
WRAPPER CLASSES:
 Vectors cannot handle primitive data types like int, float,long,char and double.
 Primitive data types may be converted into object types by using the wrapper classes
contained in the java.lang package.
Wrapper Classes for Converting Simple Types:

Simple Type Wrapper Class
boolean Boolean
char Character
double Double
float Float
int Integer
long Long
- 43 -
 The wrapper classes have a number of unique methods for handling primitive data
types and objects.
Converting Primitive Numbers to Object Numbers Using Constructor Methods:
Constructor calling Conversion Action

Integer IntVal = new Integer(i); Primitive integer to Integer object
Float FloatVal = new Float(f); Primitive float to Float object
Double DoubleVal= new Double(d); Primitive double to Double object
Long LongVal = new Long(1); Primitive long to Long object
Converting Object Numbers to Primitive Numbers Using typeValue() method:
Method Calling Conversion Action

int i = IntVal.intValue( ); Object to primitive integer
float f= FloatVal.floatValue( ); Object to primitive float
long l = LongVal.longValue( ); Object to primitive long
double d = DoubleVal.doubleValue( ); Object to primitive double
Converting Numbers to Strings Using to String() method:
str = Integer.toString(i) Primitive integer to string
str = Float.toString(f) Primitive float to string
str = Double.toString(i) Primitive double to string
str = Long.toString(i) Primitive long to string
Converting String Objects to Numeric Objects Using the static Method ValueOf():
DoubleVal = Double.ValueOf(str); Converts string to Double object
FloatVal = Float.ValueOf(str); Converts string to Float object
IntVal = Integer.ValueOf(str); Converts string to Integer object
LongVal= Long.ValueOf(str); converts string to Long object
Convertin Numeric Strings to Primitive Numbers Using Parsing Methods:

int i= Integer.parseInt(str); Converts string to primitive integer
- 44 -
long i= Long.parseLong(str); Converts string to primitive long
Packages and Interfaces:

Packages
- Packages are java’s way of grouping a variety of classes and/or interfaces together.
- Packages act as “container” for classes.
- By organizing our classes into packages we achieve the following benefits:
1. The classes contained in the packages of other programs can be easily reused.
2. In packages, classes can be unique compared with classes in other packages. That is,
two classes in two different packages can have the same name.
3. Packages provide a way to “hide” classes thus preventing other programs or packages
from accessing classes that are meant for internal use only.
4. Packages also provide a way for separating “design” from “coding”.
- Java packages are classified into two types. The first category is known as Java API
packages and the second is known as user defined packages.
Creating Packages
- Let us see how to create our own packages.
- We must first declare the name of the package using the package keyword followed
by a package name.
- This must be the first statement in a java source file, then we define a class.
Ex:
Package firstpackage; // package declaration
Public class Firstclass // class definition
{
body of the class
}
- Creating our own package involve the following steps:
1. Declare the package at the beginning of a file using the form
package packagename;
2. Define the class that is to be put in the package and declare it public.
- 45 -
3. Create a subdirectory under the directory where the main source files are stored.
4. Store the listing as the classname.java file in the subdirectory created.
5. Compile the file. This creates .class file in the subdirectory.
Ex: package firstpackage.secondpackage;
Accessing a package
- Java system package can be accessed either using a fully qualified class name or
using a shortcut approach through the import statement.
- The import statement can be used to search a list of packages for a particular class.
- The general form of import statement for searching a class is as follows:
Import package1 [.package2] [.package3] .classname;
- Here package1 is the name of the top level package, package2 is the name of the
package that is inside the package1, and so on.
- We can have any number of packages in a package hierarchy. Finally, the explicit
classname is specified.
- Multiple import statements are allowed. The statement must end with a semicolon (;).
Ex: import firstpackage.secondpackage.Myclass;
- We can use another approach as follows:
Import packagename.*;
- The star( *) indicates that the compiler should search this entire package hierarchy
when it encounters a class name.
Drawback – It is difficult to determine from which package a particular member came
Advantage – We need not have to use long package names repeatedly in the program.
Using a Package
- The listing below shows a package named package1 containing a single class
ClassA.
- 46 -
Package package1
Public class ClassA
{
public void displayA( )
{
System.out.println (“Class A”);
}
}
- The source file should be named ClassA.java and stroed in the subdirectory package1
as stated earlier. The resultant ClassA.class will be stored in the same subdirectory.
Import package1.ClassA
Class PackageTest1
{
public static void main(String args[])
{
ClassA objectA = new ClassA ( );
objectA.displayA( );
}
}
- Now let us consider package named package2 containing again a single class as
shown below:
Package package2;
Public class ClassB
{
protected int m = 10;
public void displayB( )
{
System.out.println (“Class B”);
System.out.println(“m = “ + m);
}
}
- 47 -
- As usual, the source file and the compiled file of this package are located in the
subdirectory package2.
- The following program uses classes contained in both the packages and therefore it
imports package1 and package2.
Import package1.ClassA
Import package2.*;
class packageTest2
{
public static void main (String args[])
{
ClassA objectA = new ClassA ( );
ClassB objectB = new ClassB ( );
objectA.displayA ( );
objectB.displayB ( );
}
}
The output will be as under

Class A
Class B
m = 10
Interfaces
- Java does not support multiple inheritance. That is, classes in java cannot have more
than one superclass.
Class A extends B extends C
{
……………
} is not permitted in java.
- Java provides an alternate approach known as interfaces to support the concept of
multiple inheritance.
- 48 -
- Although a java cannot be subclass of more than one superclass, it can implement
more then one interface
Defining Interfaces
- An interface is a kind of class. Like classes, interface contain methods and variables
but with a major difference.
- The interfaces only define abstract methods and final fields.
- The syntax for defining an interface is very similar to that for defining a class.The
general form of an interface definition is:
Interface InterfaceName
{
variables declaration;
methods declaration;
}
- Variables are declared as follows:
Static final type VariableName = Value;
- Methods declaration will contain only a list of methods without any body statements.
Return-type methodName2 (parameter_list);
- Here is an example of an interface definition

Ex:
Interface Item
{
static final int code = 1001;
static final String Name = “Fan”;
void display( );
}
Extending Interfaces
- 49 -
- Like classes, Interfaces can also be extended. That is, an interface can be
subinterfaced from other interface.
- The new subinterface will inherit all the members of the superinterface in the manner
similar to subclasses.
- This is achieved using the keyword extends as shown below:
Interface name2 extends name1

{
body of name2
}
Ex:
Interface Itemconstants
{
int code = 1001;
string name = “Fan”;
}
interface Item extends Itemconstants
{
void display( );
}
- We can also combine several interfaces together into a single interface.

Ex:
Interface Itemconstants
{
int code = 1001;
string name = “Fan”;
}
Interface itemMethods
{
void display( );
}
- 50 -
Interface item extends Itemconstants, ItemMethods
{
…………….
}
- While interfaces are allowed to extend to other interfaces, subinterfaces
cannot define the methods declared in the superinterfaces.
Implementing Interfaces
- Interfaces are used as “superclasses” whose properties are inherited by classes. It is
necessary to create a class that inherits the given interface.
- This is done as follows:
Class classname implements InterfaceName

{
body of classname
}
- A more general form of implementation may looks like this:
Class classname extends superclass implements interface1,

Interface2 …
Ex: Interface
{ Area // Interface denied
{ body of classname;
}
final static float pi = 3.14F;
float comoute ( float x, float y);
}
class Rectangle implements Area // interface implemented
{
public float compute ( float x, float y)
{
return ( x * y );
}
}
class Circle implements Area // Another implementation
- 51 -
{
public float compute ( float x, float y)
{
return ( x * y );
}
}
class InterfaceTest
{
public static void main (String args[]){
Rectangle rect = new Rectangle( );
Circle cir = new Circle ( );
Area area; // Interface object
Area = rect;
System.out.println (“Area of Rectangle = “ + area.compute (10,20));
Area = cir;
System.out.println (“Area of Circle = “ + area.compute (10,0));
}
}
The output is as follows:
Area of Rectangle = 200
Area of Circle = 314
Nested Interface
- An interface can be declared a member of a class or another interface. Such an
interface is called a member interface or a nested interface.
- A nested interface can be declared as public, private, or protected.
- When a nested interface is used outside of its enclosing scope, it must be qualified by
the name of the class or interface of which it is a member.
UNIT III
INHERITANCE: EXTENDING A CLASS:

- 52 -
- Inheritance is one of the cornerstones of OOPs.
- Java support this concept. Java classes can be reused in several ways.
- This is basically done by creating new classes, reusing the properties of existing
ones.
- The mechanism of deriving a new class from an old one is called inheritance.
- The old class is known as the base class or superclass or parent class and the new
class is called the subclass or derived class or child class.
- The class that does the inheriting is called a subclass. Therefore, a subclass is a
specialized version of a superclass.
- It inherits all of the instance variables and methods defined by the superclass and
add its own, unique elements.
Types of Inheritance :
 Single level Inheritance(only one super class)
 Multiple Inheritance(several super classes)
 Multilevel Inheritance(derived from a derived class)
 Hierarchical Inheritance(one super class, many subclasses)
 Java does not directly implement multiple inheritance.
Defining a subclass:
A subclass is defined as follows:
Class subclassname extends superclassname
{
Variable declaration;
Methods declaration;
}
 Single level Inheritance

- if only two classes are involved in the derivation then it is called single level
inheritance. The following programs illustrate single level inheritance.
-
A
- 53 -
 Multilevel Inheritance
- Suppose a, B and C are three classes, if the class is derived from A and in turn C is
derived from the class B, it is said to exhibit multilevel inheritance.
- It is symbolically denoted as follows:
 Hierarchical Inheritance
- Suppose A , B and C are three classes and the classes B and C are derived from the
class A. It is said to exhibit hierarchical inheritance.
- In hierarchical inheritance, there is only one base class and more than one derived
class.
- In essence hierarchical inheritance is the reverse of multiple inheritance.
- It is symbolically denoted as follows:
A Base Class
B C Derived Class
 Hybrid Inheritance
- There arise some situations where we need to combine two or more types of
inheritance to satisfy the requirements.
- The combination of two or more types of inheritance leads to what is known as
hybrid inheritance.
- Suppose A, B, C and D are the classes where class B is derived from A, class C is
derived from both B and D.
- Symbolically which is depicted as follows:
- 54 -
A
B D
Inheritance Basics
- To inherit a class, you simply incorporate the definition of one class into another
by using the extends keyword.
- The following program creates a superclass called A and a subclass called B.
Ex:
Class A
{
int i, j;
void showij( )
{
System.out.println(“I and j : “ + i + “ “ + j);
}
}
Class B extends A
{
int k;
void showk( )
{
System.out.println(“K: “ + k);
}
void sum ( )
{
System.out.println(“i+j+k: “ + (i+j+k));
}
- 55 -
}
Abstract Methods and Classes:

- We have seen that by making a method final we ensure that the method is not
refined in a subclass.
- That is, the method can never be classed.
- Java allows us to do something that is exactly opposite to this.
- We can indicate that a method must always be refined in a method, thus making
overriding compulsory.
- This is done using the modifier keyword abstract in the method definition.
Ex:
Abstract class Shape
{
………….
………….
abstract void draw ( );
……….
……….
}
- When a class contains one or more abstract methods, it should also be declared
abstract as shown below:
- While using abstract classes, we must satisfy the following conditions:
 We cannot use abstract classes, we must satisfy the following conditions:
Shape s = new shape ( )
Is illegal because shape is an abstract class.
 The abstract methods of an abstract class must be defined in its subclass.
 We cannot declare abstract constructors or abstract static methods.
Final Classes:
- Sometimes we may like to prevent a class being further subclassed for security
reasons.
- A class that cannot be subclassed is called a final class.
- This is achieved in java using the keyword final as follows:
- 56 -
Final class Aclass {…………..}
Final class Bclass extends Someclass {……….}
- Any attempt to inherit these classes will cause an error and the compiler will not
allow it.
Declaring a class final prevents any unwanted extensions to the class.
INTERFACES AND INHERITANCE:

INTERFACES:
 Classes how they can be inherited by other classes.
 Java does not support multiple inheritance. That is classes in java cannot have more
than one superclass.
Class A extends B extends C

{
……………..
…………….
}
 Is not permitted in java. Multiple inheritance proves difficult and adds complexity to
the language, java provides an alternate approach known as interfaces to support the
concept of multiple inheritance.
 Java class cannot be a subclass of more than one superclass, it can implement more
than one interface.
Defining interfaces:
 An interface is basically a kind of class. Like classes interfaces contain methods and
variables but with a major difference.
 The difference is that interface define only abstract methods and final fields.
 This means interfaces do not specify any code to implement these methods and data
fields contain only constants.
- 57 -
The general form of an interface definition is:
Interface interfaceName
{
Variables declaration;
Methods declaration;
}
 Interface is the key word and interfaceName is any valid java variable.
Static final type VariableName = Value;
Note that all variables are declared as constants.
Return-type methodName1 (parameter_list);
Interface item
{
Static final int code = 1001;
Static final String name = “Fan”;
Void display( );
}
EXTENDING INTERFACES:
 Interfaces can also be extended. That is an interface can be subinterfaced from
other interfaces.
 The new subinterfaces will inherit all the members of the superinterface in the
manner similar to subclasses.
Interface name2 extends name1
{
Body of name2
}
Example:
- 58 -
Interface ItemConstants
{
Int code = 1001;
String name = “Fan”;
}
Interface Item extends ItemConstants
{
Void display( );
}
IMPLEMENTING INTERFACES:
 Interfaces are used as “superclasses” whose properties are inherited by classes. It is
therefore necessary to create a class that inherits the given interface.
Syntax:
(i) Class classname implements interfacename
{
Body of classname;
}
(ii) Class classname extends superclass implements interface1, interface2,…..
{
Body of classname;
}
Example for implementing interfaces:
Public class main{
Public static void main(String[] args)
{
Shape circleshape = new circle();
Circleshape.Draw();
}
}
Interface shape
- 59 -
{
Public String baseclass=”shape”;
Public void Draw();
}
Class circle implements shape
{
Public void Draw() {
System.out.println(“Drawing Circle here”);
}
}
ACCESSING INTERFACE VARIABLES:
 Interface can be used to declare a set of constants that can be used in different classes.
 The values can be used in any method, as part of any variable declaration, or
anywhere where we can use a final value.
For Example:
Interface A
{
Int m = 10;
Int n= 50;
}
Class B implements A
{
Int x=m;
Void method(int size)
{
………………..
…………………
If(size<n)
…………………
}
}
Interface A
- 60 -
implementation
Class B
Extension
Class C
UNIT-IV
Exception Handling:
Fundamentals:
- An exception is a condition that is caused by a run-time error in the program.
- When the java interpreter encounters an error such as dividing an integer by zero, it
creates an exception object and throws it.
- If the exception object is not caught and handled properly, the interpreter will display
an error message and will terminate the program.
- If we want the program to continue with the execution of the remaining code, then we
should try to catch the exception object thrown by the error condition and then
display an appropriate message for taking corrective actions. This task is known as
exception handling.
- The purpose of exception handling mechanism is to provide a means to detect and
report an “exceptional circumstance” so that appropriate action can be taken.
- The mechanism suggests incorporation of a separate error handling code that
performs the following tasks:
1. Find the problem (Hit the exception)
2. Inform that an error has occurred (Throw the exception)
3. Receive the error information 9Catch the exception)
4. Take corrective actions (Handle the exception)
- 61 -
ERROR HANDLING:
- Errors are the wrongs that can make a program go wrong.
- An error may produce an incorrect output or may terminate the execution of the
program abruptly or even may cause the system to crash.
- To detect and manage properly all the possible error conditions in the program so that
the program will not terminate or crash during execution.
TYPES OF ERRORS:
 Compile-time errors
 Run-time errors
Compile-Time Errors:
 All syntax errors will be detected and displayed by the Java compiler and therefore
these errors are known as compile-time errors.
 Whenever the compiler displays an error, it will not create the .class file.
Example:
Class Error1
{
{
System.out.println(“Hello Java!”) // Missing
}
}
 Most of the compile time errors are due to typing mistakes. Typographical errors
are hard to find.
 We may have to check the code word by word, or even character by character.
 The most common problems are:
o Missing semicolons
o Missing brackets in classes and methods
o Misspelling of identifiers and keywords
o Missing double quotes in strings
- 62 -
o Use of undeclared variables
o Incompatible types in assignments/initialization
o Bad references to objects
o Use of = in place of == operator
o And so on
Run-Time Errors:
 A program may compile successfully creating the .class file but
may not run properly.
 Programs may produce wrong results due to wrong logic or may
terminate due to errors such as stack overflow.
 Most common run-time errors are:
 Dividing an integer by zero

 Accessing an element that is out of the bounds of an array
 Trying to store a value into an array of an incompatible
class or type
 Trying to cast an instance of a class to one of its subclasses.
 Passing a parameter that is not in a valid range or value for
a method.
 Trying to illegally change the state of a thread
 Attempting to use a negative size for an array
 Converting invalid string to a number
 Accessing a character that is out of bounds of a string.
Example:
Class Error2
{
{
int a =10;
- 63 -
int b=5;
int c= 5;
int x= a/(b-c); // Division by zero
System.out.println(“x=”+x);
Int y=a/(b+c);
}
}
- The error handling code basically consists of two segments, one to detect errors and
to throw exceptions and the other to catch exceptions and to take appropriate actions.
- Java exception handling is managed via five keywords: try, catch, throw, throws and
finally.
The general form of an exception handling block:

try{
// block of code to monitor for errors
}
catch (ExceptionType1 exOb){
// exception handler for exception Type1
}
catch (ExceptionType2 exOb){
// exception handler for exception Type2
}
//…..
finally( ){
// block of code to be executed after try block ends
}
Exception Types and Hierarchy:
- 64 -
- All exception types are subclasses of the built-in class Throwable. Throwable is at
the top of the exception class hierarchy.
- Immediately below Throwable are two subclasses that partition exceptions into two-
distinct branches.
- One branch is headed by Exception. This class can be used for exceptional conditions
that user programs should catch.
- There is important subclass of Exception, called RuntimeException.
- Exceptions of this type are automatically defined for the programs that you write and
include things such as division by zero and invalid array indexing.
- The other branch is topped by Error, which defines exceptions that are not expected
to be caught under normal circumstances by your program.
- Exceptions of type Error are used by the java run-time system to indicate errors
having to do with the run-time environment, itself.
Uncaught Exceptions
- When the java interpreter encounters an error such as dividing an integer by zero, it
creates an exception object and throws it.
- If the exception object is not caught and handled properly, the interpreter will display
an error message and will terminate the program.
Try and Catch blocks:

- Java uses a keyword try to preface a block of code that is to cause an error condition
and “throw” an exception.
- A catch block defined by the keyword catch “catches” the exception “thrown” by the
try block and handles it appropriately.
- The catch block is added immediately after the try block.
………..
………..
try
{
statement; // generates an exception
- 65 -
}
catch (Exception-type e)
{
statement; // processes the exception
}
……………
- The try block can have one or more statements that could generate an exception. If
any one statement generates an exception, the remaining statements in the block are
skipped and exception jumps to the catch block that is placed next to the try block.
- The catch statement is passed a single parameter, which is reference to the exception
object thrown by the try block.
- If the catch parameter matches with the type of exception object, then the exception is
caught and statements in the catch block will be executed.
- Otherwise, the exception is not caught and the default exception handler will cause
the execution to terminate.
Ex:
Class Error3
{
public static void main (String args[ ])
{
int a = 10;
int b = 5;
int c = 5;
int x, y;
try
{
x = a / (b – c); // Exception here
}
catch (ArithmeticException e)
{
System.out.println (“division by zero”);
- 66 -
}
y = a / (b + c);
System.out.println( “y = “ + y);
}
}
Output:
Division by zero
y =1
Multiple Catch Clauses
- It is possible to have more than one catch statement in the catch block as illustrated
below:
……………
……………
try
{
statement; // generates an exception
}
catch (Exception-Type-1 e)
{
statement; // processes exception type 1
}
catch (Exception-Type-2 e)
{
statement; // processes exception type 2
}
.
.
catch (Exception-Type-N e)
{
statement; // processes exception type N
}
…………….
- 67 -
…………….
Example:
Class Error4
{
public static void main (String args[ ])
{
int a[ ] = { 5, 10 };
int b = 5;
try
{
int x = a[2] / b – a[1];
}
catch (ArithmeticException e)
{
System.out.println(“Divison by zero”);
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println(“Array index error”);
}
catch (ArrayStoreException e)
{
System.out.println(“Wrong data type”);
}
int y = a[1] / a[0];
System.out.println (“y =” + y);
}
}
Output:
Array Index error
Y=2
- 68 -
Nested try statements
- The try statement can be nested.
- A try statement cab be inside the block of another try.
- Each time a try statement is entered, the context of that exception is pushed on the
stack.
- If an inner try statement does not have a catch handler for a particular exception, the
stack is unwound and the next try statement’s catch handlers are inspected for a
match. This continues until one of the catch statements succeeds, or until the entire
nested try statements are exhausted.
- If no catch statement matches, then the Java run-time system will handle the
exception.
Use of Throw:
- It is possible to throw an exception using the throw statement.
- The general form of throw is shown here:
Throw ThrowableInstance
ThrowableInstance
- Here, ThrowableInsatnce must be an object of type Throwable or a subclass of

throwable.
- There are two ways you can obtain a Throwable object : using a parameter in a catch
clause, or creating one with the new operator.
- The flow of execution stops immediately after the throw statement.
Throws
- If a method is capable of causing an exception that it does not handle, it must specify
this behavior so that callers of the method can guard themselves against that
exception.
- You do this by including a throws clause in the method’s declaration.
- A throws clause lists the types of exceptions that a method might throw.
- 69 -
- This is necessary for all exceptions, except those of type Error or
RuntimeException, or any of their subclasses.
- All other exceptions that a method can throe must be declared in the throws clause.
- The general form of a method declaration that includes a throws clause.
type method-name(parameter-list) throws exception-list

{
// body of method.
}
Using finally Statement:

 Java support another statement known as finally statement that can be used to handle
an exception that is not caught by any of the previous catch statements.
 Finally block can be used to handle any exception generated within a try block.
 It may be added immediately after the try block or after the last catch block.
(i) Try
{
…………….
……………
}
Finally
{
……………..
……………..
}
(iii) try
{
…………
…………
Catch(………)
{
……………
……………
}
Catch(……)
{
…………..
…………..
}
- 70 -
.
.
.
.
Finally
{
…………..
……….....
}
PROGRAMMER DEFINED EXCEPTION:
 The exception-handling can be used to hide errors from rest of the program.
 It is possible that the programmers may misuse this technique for hiding errors rather
than debugging the code.
 Exception handling mechanism may be effectively used to locate the type and place
of errors.
 Once we identify the errors, we must try to find out these errors occur before we
cover them up with exception handlers.
Example:
Class invalidIntegerException extends Exception
{
invalidIntegerException(String s)
{
Super;
}
invalidIntegerException()
{
This(“ ”);
}
}
- 71 -
UNIT V
APPLETS AND GRAPHICS:
APPLET FUNDAMENTALS:
 Applets are small applications that are accessed on an Internet Server, transported
over the Internet, automatically installed, and run as part of a web document.
 Applets differ from console-based applications in several key areas.
Import java.awt.*;
Import java.applet.*;
Public class simpleApplet extends Applet
{
public void paint(Graphics g)
{
g.drawString(“A simple Applet”, 20,20);
}
}
 This applet begins with two import statements. The first imports the Abstract Window
Toolkit(AWT) classes.
 Applets interact with the user through the AWT, not through the console based I/O
classes.
- 72 -
 The AWT contains support for a window-based, graphical user interface.
 Applets can also use Swing to provide the graphical user interface.
 The second import statement imports the applet package, which contains the class
Applet.
 After you enter the source code for SimpleApplet compile in the same way that you
have been compiling programs.
 Running simpleapplet involves a different process.
 There are two ways in which you can run an applet:
o Executing the applet within a Java-compatible web browser.
o Using an applet viewer, such as the standard tool, appletviewer
o An appletviewer executes your applet in a window. This is generally the
fastest and easiest way to test your applet.
<applet code = “simpleApplet” width=200 height=60>

</applet>
 To execute SimpleApplet with an applet viewer, you may also execute the HTML file
C:\>appletviewer RunApp.html
 Applet development by using these three steps:
1. Edit a Java source file

2. Compile your program
3. Execute the applet viewer, specifying the name of your applet’s source
file. The applet viewer will encounter the APPLET tag within the
comment and execute your applet.
 Applets do not need a main( ) method.

 Applets must be run under an applet viewer or a Java-compatible browser.
 User I/O is not accomplished with Java’s stream I/O classes.
 Applets use the interface provided by the AWT or Swing.
- 73 -
Transient and Volatile modifiers:
 Java defines two interesting type modifiers: TRANSIENT and VOLATILE.
 These modifiers are used to handle somewhat specialized situations.
 When an instance variable isdeclared as transient, then its value need not persist when
an object is stored.
 For example:
Class T
{
transient int a; // will not persist
int b; // will persist
}
 Here if an object of type T is written to a persistent storage area, the contents of a
would not be saved, but the contents of b would.
 The Volatile modifier tells the compiler that the variable modified by volatile can be
changed unexpectedly by other parts of your program.
 One of these situations involves multithreade programs.
 Multithread program, sometimes two or more threads share the same variable.
APPLET BASICS:
 All applets are subclasses of Applet. Applets are not stand-alone programs.
 They run within either a web browser or an applet viewer.
 Execution of an applet does not begin at main( ). Actually few applets even have
main( ) methods.
 Execution of an applet is started and controlled with an entirely different mechanism,
which will be explained .
 Input is also handled differently than in a console application.
 The applet will be executed by a java-enabled web browser when it encounters the
APPLET tag within the HTML file.
<applet code = “MyApplet” width=200 height =60>
</applet>
 This comment contains an APPLET tag that will run an applet called MyApplet in a
window that is 200 pixels wide and 60 pixels high.
- 74 -
The Applet Class:
 Applet provides all necessary support for applet execution, such as starting and
stopping.
 It also provides methods that load and display images, and methods that load and play
audio clips.
 Applets extends the AWT class Panel.
 Panel extends Container, which extends Component.
Method Description
Void destroy( ) Called by the browser just before an applet is
terminated.Your applet will override this
method if it needs to perform any cleanup
prior to its destruction.
AccessibleContext Returns the accessibility context for the
getAccessibleContext( ) invoking object.
AppletContext get AppletContext( ) Returns the context associated with the
applet.
String getAppletinfo( ) Returns a string that describes the applet.
AudioClip getAudioClip( URL url) Returns an AudioClip object that
encapsulates the audio clip found at the
location specified by url.
URL getCodeBase( ) Returns the URL associated with the
invoking applet.
URL getDocumentBase( ) Returns the URL of the HTML document
that invokes the applet.
Image getimage(URL url) Returns an image object that encapsulates the
image found at the location specified by url.
Void init( ) Called when an applet begins execution. It is
the first method called for any applet.
Void start( ) Called by the browser when an applet should
start execution. It is automatically called
after init( ) when an applet first begins.
Void stop( ) Called by the browser to suspend execution
of the applet. Once stopped, an applet is
- 75 -
restarted when the browser calls start( ).
BUILDING APPLET CODE:

 The applet code uses the services of two classes namely Applet and Graphics
from the java class library.
 The Applet class which is contained in theThe Applet class which is contained
in the java.applet package provides life and behaviour to the applet through its
methods such as init(), start() and paint().
 Java calls the main() method directly to initiate the execution of the program,
when an applet is loaded, java automatically calls a series of Applet class
methods for starting, running, and stopping the applet code.
 The applet class therefore maintains the lifecycle of an applet.
 The Paint() method of the applet class, when it is called, actually displays the
result of the applet code on the screen.
 The output may be text, graphics, or sound.
 The Paint() method, which requires a Graphics object as an argument is
defined:
 Public void paint(Graphics g)
 This requires that the applet code imports the java.awt package that contains
the Graphics class.
Import java.awt.*;
…………
………….
Public class appletclassname extends Applet
{
……………..
…………….
Public void paint(Graphics g)
{
……………..
…………….. //applet operations code
- 76 -
}
……………
}
 The appletclassname is the main class for the applet.
 When the applet is loaded, java creates an instance of this class, and then a
series of Applet class methods are called on that instance to execute the code.
Import java.awt.*;
Public class HelloJava extends applet
{
{
g.drawString(“Hello Java”,10,100);
}
}
OUTPUT:
- 77 -
Java.applet.Applet
java.awt.Panel
Java.lang.Object
java.awt.Component
java.awt.Container
APPLET LIFE CYCLE:

 Java Applet inherits a set of default behaviours from the Applet class.
 The applet states include:
o Born or Initialization state
o Running state
o Idle state
o Dead or destroyed state
- 78 -
Begin
(load Applet) Initialization
stop()
Display
Paint()
Stopped
Destroy()
Start()
Destroyed End
Exit of Browser
An applet’s state transition diagram
Initialization State:
 Applets enters the initialization state when it is first loaded.
 This is achieved by calling the init() method of applet Class.
 The applet is born. At this stage we may do the following, if required
o Create objects needed by the applet
o Set up initial values
o Load images or fonts
o Set up colors.
 The initialization occurs only once in the applet’s life cycle.
- 79 -
 To provide any of the behaviours mentioned above, we must override the init()
method.
Public void init()
{
…………….
……………(Action)
……………
}
Running State:
 Applet enters the running state when the system calls the start() method of applet
class.
 This occurs automatically after the applet is initialized.
 Starting can also occur if the applet is already in “stopped”(Idle) state.
 For example we may leave the Web page containing the applet temporarily to another
page and return back to the page.
 This again starts the applet running.
 Init() method, the start() method may be called more than once.
 We may override the start() method to create a thread to control the applet.
Public void start( )
{
…………….
…………….(Action)
…………….
}
Idle or Stopped State:

 An applet becomes idle when it is stopped from running.
 Stopping occurs automatically when we leave the page containing the
currently running applet.
 If we use a thread to run the applet, then we must use stop() method to
terminate the thread.
- 80 -
Public void stop()
{
………..
……….(Action)
………
}
Dead State :
 An applet is said to be dead when it is removed from memory.
 This occurs automatically by invoking the destroy() method when we quit the
browser.
 Destroying stage occurs only once in the applet’s life cycle.
Public void destroy( )
{
...........
………(action)
………..
}
Display State:
 Applets moves to the display state whenever it has to perform some output
operations on the screen.
 This happens immediately after the applet enters into the running state.
 The paint() methods is called to accomplish this task.
Public void paint (Graphics g)
{
...……..
……….
}
 It is to be noted that the display state is not considered as a part of the applet’s
life cycle.
GRAPHICS PROGRAMMING:
- 81 -
The Graphics Class:
 Java’s Graphics class includes methods for drawing many different types of
shapes, from simple lines to polygons to text in a variety of fonts.
 The most commonly used drawing methods in the Graphics class.
X
(0,0) (80,0)
(20,20)
(60,60)
(0,80) (80,80)
Method Description
clearRect( ) Erases a rectangle area of the canvas.
copyArea( ) Copies a rectangular area of the canvas to another area.
drawArc( ) Draws a hollow arc.
drawLine( ) Draws a straight line
drawOval( ) Draws a hollow oval.
drawPolygon( ) Draws a hollow polygon.
drawRect( ) Draws a hollow rectangle.
drawRoundRect( ) Draws a hollow rectangle with rounded corners.
drawString( ) Displays a text string
fillArc( ) Draws a filled arc.
fillOval( ) Draws a filled oval.
fillPolygon( ) Draws a filled polygon.
fillRect( ) Draws a filled rectangle.
fillRoundRect( ) Draws a filled rectangle with rounded corners.
getColor( ) Retrieves the current drawing colour.
getFont( ) Retrieves the currently used font.
getFontMetrics( ) Retrieves information about the current font.
setColor( ) Sets the drawing colour.
setFont( ) Sets the font.
- 82 -
LINES AND RECTANGLES:
 The simplest shape we can draw with the Graphics class is a line.
 The drawLine( ) Method takes two pair of coordinates, (x1,y1) and (x2,y2) as
arguments and draws a line between them.
 For example the following statement draws a straight line from the coordinate
point(10,10) to (50,50):
g.drawLine(10,10,50,50);
 The g is the Graphics object passed to paint( ) method.
 We can draw rectangle using the drawRect( ) method. This method takes four
arguments.
 The first two represent the x and y coordinates of the top left corner of the
rectangle, and the remaining two represent the width and the height of the
rectangle.
g.drawREct(10,60) 40,30)
(x,y) height
Rectangle
 We can draw a solid box by using the method fillRect( ).
 This also takes four parameters corresponding to the starting point, the width and the
height of the rectangle.
g.fillRect(60,10,30,80);
example program:
import java.awt.*;
import java.applet.*;
public class LineRect extends Applet
- 83 -
{
{
g.drawLine(10,10,50,50);
g.drawRect(10,60,40,30);
g.fillRect(60,10,30,80);
g.drawRoundRect(10,100,80,50,10,10);
g.fillRoundRect(20,110,60,30,5,5);
g.drawLine(100,10,230,140);
g.drawLine(100,140,230,10);
}
}
LineRect.html file
<APPLET
CODE = lineRect.class
WIDTH = 250
HEIGHT= 200>
</APPLET>
CIRCLES AND ELLIPSES:

 The Graphics class does not have any method for circles or ellipses.
 The drawOval( ) method can be used to draw a circle or an ellipse.
 The drawOval( ) method takes four arguments. The first two represent the top
left corner of the imaginary rectangle and the other two represent the width
and height of the oval itself.
 The drawOval ( ) method draws outline of an oval, and the fillOval( ) method
draws a solid oval.
- 84 -
{
g.drawOval(20,20,200,120);
g.setColor(Color.green);
g.fillOval(70,30,100,100); // this is a circle.
}
g.setColor(Color.green);
After setting the color, all drawing operations will occur in that color.
USING CONTROL LOOPS IN APPLETS:

 We can use all control structures in an applet.
 It uses a for loop for drawing circles repeatedly.
Using control loops in applets:

Import java.awt.*;
- 85 -
{
for(int i=0; i<=4; i++)
{
if(i%2)= = 0)
g.drawOval (120, i*60+10 , 50,50);
else
g.fillOval (120, i*60+10 , 50, 50);
}
}
}
Appletloader started.
DRAWING BAR CHARTS:

 Applets can be designed to display bar charts, which are commonly used in
comparative analysis of data.
- 86 -
 These values may be placed in a HTML file as a PARAM attributes and then used in
an applet for displaying a bar chart.
Year 1991 1992 1993 1994

Turnover 110 150 100 170
(Rs. Crores)
 The method getParameter( ) is used to fetch the data values from the HTML
file.
 The method getParameter( ) returns only string values and therefore we use
the wrapper class method parseInt( ) to convert strings to integer values.
Example Program:
Import java.awt.*;
Public class Barchart extends Applet
{
int n=0;
String label[ ];
Int value[ ];
Public void init( )
{
try
{
n = Integer.parseInt(getParameter(“columns”));
label = new String[n];
value = new int [n];
label[0] = getParameter(“label1”);
value[0] = Integer.parseInt(getParameter(“c1”));
- 87 -
}
catch ( NumberFormatException e) { }
}
{
for(int i=0; i<n; i++)
{
g.setColor(Color.red);
g.drawString(label[i],20,i*50+30);
g.fillRect(50,i*50+10,value[i],40);
}
}
}
HTML file for running the Barchart applet:

<HTML>
<APPLET
CODE=Barchar.class
WIDTH=300
HEIGHT = 250>
<PARAM NAME = “columns” VALUE=”4”>
<PARAM NAME=”c1” VALUE=”110”>
<PARAM NAME=”label1” VALUE=”91”>
</APPLET>
</HTML>
- 88 -
INPUT OUTPUT: FILES- STREAMS:
STREAMS:
 Java programs perform I/O through streams.
 A Stream is an abstraction that either produces or consumes information.
 A stream is linked to a physical device by the Java I/O system.
 All streams behave in the same manner, even if the actual physical devices to which
they are linked differ.
 The same I/O classes and methods can be applied to any type of device.
 This means that an input stream can abstract many different kinds of input: from a
disk file, a keyboard, or a network socket.
 An output stream may refer to the console, a disk file, or a network connection.
 Java implements streams within class hierarchies defined in the java.io package.
Byte Streams and Character Streams:
- 89 -
 Java defines two types of streams: byte and character .
 Byte streams provide a convenient means for handling input and output of bytes.
 Byte streams are used for example, when reading or writing binary data.
 Character streams provide a convenient means for handling input and output of
characters.
 They use Unicode and therefore can be internationalized.
 Character streams are more efficient than byte streams.
 One other point: at the lowest level all I/O is still byte-oriented.
 The character-based streams simply provide a convenient and efficient means for
handling characters.
Stream Class Meaning

BufferedInputStream Buffered input Stream
BufferedOutputStream Buffered Output stream
ByteArrayInputStream Input stream that reads from a byte array.
ByteArrayOutputStream Output stream that writes to a byte array
DataInputStream An input stream that contains methods for reading the
Java standard data types.
DataOutputStream An output stream that contains methods for writing the
Java standard data types.
FileInputStream Input stream that reads from a file.
FileOutputStream Output stream that writes to a file.
FilterInputStream Implements InputStream
FilterOutputStream Implements OutputStream
InputStream Abstract class that describes stream input
ObjectInputStream Input stream for objects
ObjectOutputStream Output stream for objects
OutputStream Abstract class that describes stream output
PipedInputStream Input pipe
PipedOutputSteam Output pipe
PrintStream Output stream that contains print() and println()
Pushbackinputstream Input stream that supports one-byte “unget” which returns
a byte to the input stream
RandomAccessFile Supports random access file I/O
SequenceInputStream Input stream that is a combination of two or more input
streams that will be read sequentially, one after the other.
- 90 -
The Character Stream Classes:
 Character streams are defined by using two class hierarchies.
 At the top are two abstract classes, Reader and writer.
 These abstract classes handle Unicode character streams . Java has several concrete
subclasses of each of these.
 The abstract classes reader and writer define several key methods that the other
stream classes implement.
Stream class Meaning
BufferedReader Buffered input character stream
BufferedWriter Buffered output character stream
CharArrayReader Input stream that reads from a character array
CharArrayWriter Input stream that Writes from a character array
FileReader Input stream that reads from a file
FileWriter Output stream that writes to a file
FilterReader Filtered reader
Filterwriter Filtered writer
File Handling and Input/Output:

Java.io.package:
 Classes related to input and output are present in the Java language package java.io.
 Java technology uses “streams” as a general mechanism of handling data.
 Input streams act as a source of data.
 Output streams act as a destination of data.
File class:
 The file class is used to store the path and name of a directory or file.
 The file object can be used to create rename, or delete the file or directory it
represents.
 The file class has the following constructors:
o File(String pathname); // pathname could be file or a directory name
o File(String dirPathname, String filename);
o File(File directory, String filename);
o File(File directory, String filename);
 The file class provides the getName() method which returns the name
of the file excluding the directory name.
- 91 -
 String getName();
Byte Streams:
Byte streams are defined by using two class hierarchies.
 At the top are two abstract classes: InputStream and OutputStream.
 Each of these abstract classes has several concrete subclasses that handle the
differences between various devices, such as disk files, network connections, and
even memory buffers.
 The abstract classes InputStream and OutputStream define several key methods
that the other stream classes implement.
 Two of the most important are read( ) and Write( ) which respectively read and
write bytes of data.
InputStream class hierarchy(partial)

InputStream(abstract)
Object InputStream FilterInputStream FileInputStream
DataInputStream BufferedInputStream
OutputStream class hierarchy(partial)

outputStream(abstract)
objectOutputStream FilterOutputStream FileOutputStream
- 92 -
DataOutputStream BufferedOutputStream
READ and WRITE Methods:
1. InputStream class defines the following methods for reading bytes

2. intread()throwsIOException
3. intread(byteb[])throwsIOException
4. intread(byteb[]intoffset,intlength)throwsIOException
5. Subclasses of InputStream implement the above mentioned
methods.
OutputStream class defines the following methods for writing bytes
1. voidwrite(intb)throwsIOException
2. voidwrite(byteb[])throwsIOException
3. voidwrite(byteb[],intoffset,intlength)throwsIOException
4. Subclasses of OutputStream implement the above mentioned methods.
Reader and Writer classes:

 The InputStream and OutputStream class hierarchies for reading and
writing bytes, Java technology provides class hierarchies rooted at Reader and Writer
classes for reading and writing characters.
 A Character encoding is a scheme for internal representation of characters.
 Java programs use 16 bit Unicode character encoding to represent
characters internally.
 Other platforms may use a different character set (for example ASCII) to
represent characters.
Reader
- 93 -
InputStreamreader CharArrayReader FilterReader
File Reader
Writer
OutputStreamWriter CharArrayWriter FilterWriter
FileWriter
MULTITHREADING AND NETWORKING:
 We term a sequence of instructions a Thread

 Every program has at least one thread
o Starts executing main()
 The Thread class provides means to create other threads
o When started, executes run() method
o Run() method defined in Thread is empty
 Two ways of structuring a thread
o Create a subclass of Thread
o Implement Runnable interface
o Override run() method in each case
 Executing a thread:
o In another thread(possibly main())
o First create an instance of a thread
- 94 -
 Pass it a runnable object
 Or subclass
 Call start() method
o Actually creates separate execution space
o Starts executing appropriate run()
Thread states:
 During the life time of a thread, there are many states it can enter. They
include:
 Newborn state
 Runnable state
 Running state
 Blocked state
 Dead state
A thread is always in one of these five states. It can move from one state to another via a
variety of ways.
State transition diagram of a thread:
New thread
NewBorn
Running
Running
DEAD
- 95 -
Idle Thread Blocked
(Not Runnable)
Newborn State:
 When we create a thread object, the thread is born and is said to be in newborn state.
 The thread is not yet scheduled for running.
o Schedule it for running using start( ) method.
o Kill it using stop( ) method.
 If we attempt to use any other method at this stage, an exception will be thrown.
New
born
Start Stop
Run Dea
nabl d
e state
state
Runnable State:
 The runnable state means that the thread is ready for execution and is waiting for the
availability of the processor.
 The thread has joined the queue of threads that are waiting for execution.
 If all threads have equal priority then they are given time slots for execution in round
robin fashion i.e. first-come, first-serve manner.
 The thread that relinquishes control joins the queue at the end and again waits for its
turn.
 This process of assigning time to threads is known as time slicing.
yield
- 96 -
. Running Runnable Threads
Thread
Relinquishing control using yield( ) method
Running State:
 Running means that the processor has given its time to the thread for its
execution.
 The thread runs until it relinquishes control on its own or it is preempted by a
higher priority thread.
 A running thread may relinquish its control in one of the following situations.
1. It has been suspended using suspend( ) method. A suspended thread can be
revived by using the resume( ) method. This approach is useful when we want
to suspend a thread for some time due to certain reason, but do not want to kill
it.
suspend
resume
Running Runnable Suspended

Relinquising control using suspend( ) method
2 It has been made to sleep. We can put a thread to sleep for a specified time period
using the method sleep(time) where time is in milliseconds. This means that the
thread is out of the queue during this time period. The thread re-enters the runnable
state as soon as this time period is elapsed.
Sleep(t)
After t
- 97 -
Running Runnable Sleeping
Relinquishing control using sleep( ) method
3. It has been told to wait until some event occurs. This is done using the wait( )
method. The thread can be scheduled to run again using the notify( ) method.
Wait
Notify
Running Runnable Waiting

Relinquishing control using wait ( ) method.
Blocked State:
 A thread is said to be blocked when it is prevented from entering into the runnable
state and subsequently the running state.
 This happens when the thread is suspended, sleeping, or waiting in order to satisfy
certain requirements.
 A blocked thread is considered “not runnable” but not dead and therefore fully
qualified to run again.
Dead State:
 Every thread has a life cycle. A running thread ends its life when it has completed
executing its run( ) method. It is a natural death.
 A thread can be killed as soon it is born, or while it is running, or even when it is in
“not runnable”(blocked) condition.
THREAD PRIORITY:
 Each thread is assigned a priority which affects the order in which it is scheduled
for running.
 The threads of the same priority are given equal treatment by the java scheduler and
therefore they share the processor on a first-come, first-serve basis.
ThreadName.setPriority(intNumber);
- 98 -
 The intNumber is an integer value to which the thread’s priority is set.
 The Thread class defines several priority constants:
MIN_PRIORITY = 1
NORM_PRIORITY = 5
MAX_PRIORITY = 10
 The intNumber may assume one of these constants or any value between 1 and 10.
 The default setting is NORM_PRIORITY.
 Most user-level processes should use NORM_PRIORITY, plus or minus 1.
 Back-ground tasks such as network I/O and screen repainting should use a value very
near to the lower limit.
 By assigning priorities to threads, we can ensure that they are given the attention they
deserve.
 Whenever multiple threads are ready for execution the Java chooses the highest
priority thread and executes it.
 It stops running at the end of run( ).
 It is made to sleep using sleep( ).
 It is told to wait using wait( ).
 if another thread of a higher priority comes along, the currently running thread will be
preempted by the incoming thread thus forcing the current thread to move to the
runnable state.
 The highest priority thread always preempts any lower priority threads.
NETWORKING:
NETWORKING BASICS:
 Java’s networking support is the concept of a socket.

 A socket identifies an endpoint in a network.
 Sockets are at the foundation of modern networking because a socket allows a single
computer to serve many different clients at once, as well as to serve many different
types of information.
- 99 -
 This is accomplished through the use of a port, which is a numbered socket on a
particular machine.
 A server process is said to “listen” to a port until a client connects to it.
 Socket communication takes place via a protocol.
 Internet Protocol (IP) is a low-level routing protocol that breaks data into small
packets and sends them to an address across a network, which does not guarantee to
deliver said packets to the destination.
 Transmission Control Protocol(TCP) is a higher – level protocol that manages to
robustly string together these packets, sorting and retransmitting them as necessary to
reliably transmit data.
 UDP User Datagram Protocol sits next to TCP and can be used directly to support
fast, connectionless, unreliable transport of packets.
 Once a connection has been established, a higher-level protocol ensures , which is
dependent on which port you are using.
 Port number 21 is for FTP; 23 is for Telnet ; 25 is for e-mail; 43 is for whois;79 is for
finger; 80 is for HTTP;119 is for netnews.
 It is up to each protocol to determine how a client should interact with the port.
 For example, HTTP is the protocol that web browsers and servers use to transfer
hypertext pages and images.
 It is a quite simple protocol for a basic page browsing web server.
 The numbers of an IP address describe a network hierarchy, the name of an Internet
address, called its domain name, describe a machine’s location in a name space.
 An internet domain name is mapped to an IP address by the Domain Naming
Service(DNS).
InetAddress:
 The InetAddress class is used to encapsulate both the numerical IP address and the
domain name for that address.
 You interact with this class by using the name of an IP host, which is more convenient
and understandable than its IP address.
 The InetAddress class hides the number inside. InetAddress can handle both IPv4 and
IPv6 addresses.
Factory Methods:
- 100 -
 The InetAddress class has no visible constructors.
 To create an InetAddress object, you have to use one of the available factory
methods.
 Factory methods are merely a convention whereby static methods in a class return
an instance of that class.
 Three commonly used InetAddress factory methods are shown here:
 Static InetAddress getLocalHost( )
Throws UnknownHostException
 Static InetAddress getByName(String hostname) throws
UnknownHostException
 Static InetAddress[ ] getAllByName(String hostname) throws
UnknownHostException
 The getLocalHost The getLocalHost() method simply returns the InetAddress object
that represents the local host.
 The getByName() method returns an InetAddress for a host name passed to it.
 If these methods are unable to resolve the host name, they throw an
UnknownHostException.
 The getAllByName() factory method returns an array of InetAddress that represents
aa of the addresses that a particular name resolves to.
EX: Prints the addresses and names of the local machine and two well-known internet Web
sites.
Import java.net.*;
Class InetAddressTest
{
public static void main(String args{}) throws UnknownHostException

{
InetAddress Address = InetAddress.getLocalHost();
- 101 -
System.out.println(Address);
Address = InetAddress.getByName(“asborne.com”);
InetAddress SW[] = InetAddress.getAllByName(“www.nba.com”) ;
for(int i=0; i<SW.length; i++)
System.out.println(SW[i]);
}
}
Output:
default/206.148.209.138
osborne.com/198.45.24.162
www.nba.com/64.5.96.214
www.nba. com/64.5.96.216
Instance Methods:
Boolean equals(Object other) Returns true if this object has the same
Internet address as other.
Byte[] getAddress() Returns a byte array that represents the
object’s IP address in network byte order.
String getHostAddress() Returns a string that represents the host
address associated with the InetAddress
object.
String getHostName() Returns a string that represents the host
name associated with the InetAddress
object.
Boolean isMulticastAddress() Returns true if this address is a multicast
address.
String toString() Returns a string that lists the host name and
the IP address for convenience.
Subclasses of InetAddress:
 Inet4Address- it represents a traditional style IPv4 address.

 Inet6Address- it encapsulates a new style IPv6 address.
- 102 -
 Java was able to add IPv6 functionality without breaking the existing code.
TCP/IP Client Sockets:
 TCP/IP sockets are used to implement reliable, bidirectional, persistent, point-to-

point, stream-based connections between hosts on the internet.
 A socket can be used to connect java’s I/O system to other programs that may reside
either on the local machine or on any other machine on the Internet.
 There are two kinds of TCP sockets in Java.
 One is for Servers ,and the other is for clients.
 The ServerSocket class is designated to be a “listener” which waits for clients to
connect before doing anything.
 ServerSocket is for servers.
 The socket class is for clients. It is designed to connect to server sockets and initiate
protocol exchanges.
 Because client sockets are the most commonly used by Java Applications, they are
examined.
 The creation of a socket object implicitly establishes a connection between the client
and server.
Socket(String hostname. Int port) throws Creates a socket connected to the named
UnknownHostException, IOException host and port.
Socket(InetAddress ipAddress, int port) Creates a socket using preexisting
throws IOException InetAddress object and a port.
 Socket defines several instance methods. For example a socket can be examined
at any time for the address and port information associated with it by use the
following methods:
InetAddress getInetAddress( ) Returns the InetAddress associated with the

socket object. It returns null if the socket is
not connected.
- 103 -
Int getPort( ) Returns the remote port to which the
invoking socket object is connected. It
returns 0 if the socket is not connected.
Int getLocalport( ) Returns the local port to which the
invoking socket object is bound. It returns
-1 if the socket is not found.
 The input and output streams associated with a socket by use of the
getInputStream( ) and getOutputStream methods.
 Each can thrown an IOException if the socket has been invalidated by a loss of
connection.
InputStream getInputStream( ) throws Returns the InputStream associated with

IOException the invoking socket.
OutputStream getOutputStream( ) throws Returns the OutputStream associated with
IOException the invoking socket.
- 104 -

Java

Uploaded by

Java

Uploaded by

PROGRAMMING IN JAVA

INTRODUCTION: INTRODUCTION TO JAVA:

 Many programming languages approaches have been tried.

JAVA AND INTERNET:

 In addition, it changed the way internet and WWW worked by allowing

- Ex: a+b, a-b, -a*b

- A simple relational expression contains only one relational operator and is of

Ae-1 relational operator ae-2

&& logical AND

- An expression of this kind which combines two or more relational expressions

- where v is a variable, exp is an expression and op is a java binary operator.

Increment and Decrement Operator

Exp1 ? exp2 : exp3

Where exp1, exp2, exp3 are expressions.

The if statement may be implemented in different forms:

- If the test expression is true, the statement-block will be executed; otherwise

Nesting of IF…Else statements

The ELSE IF Ladder

- This construct is known as the else if ladder.

The Switch statement

- When the switch is executed, the value of the expression is successively

The WHILE statement

- On reaching the do statement, the program proceeds to evaluate the body of

The FOR statement

For (initialization; test condition; increment)

- The execution of the for statement is as follows:

Additional features of for loop

Jumping out of a loop

Skipping a part of a loop

return; // this returns nothing . so this can be used when method

Simple Java program

The Main line:

JAVA HISTORY & FEATURES:

JAVA DEVELOPMENT KIT:

Java Source HTML

Java Class File Header

Application Programming Interface

ARRAYS & VECTORS:

- The values to the array elements can be assigned as follows:

1. Declare the array

Arrayname = new type[size];

Arrayname [subscript] = value;

- The array initializer is a list of values separated by commas and surrounded by

Two dimensional arrays

Variable Size Arrays

- Java treats multidimensional arrays as “arrays of arrays”.

STRINGS & STRING BUFFERS:

Class classname [extends superclassname]

- Everything inside the square brackets is optional.

Type methodname (parameter-list)

- Method declarations have four basic parts:

- The getData method is added to provide values to the instance variables.

Accessing Class members

Objectname. Variable name

Wrapper Classes for Converting Simple Types:

Constructor calling Conversion Action

Converting Object Numbers to Primitive Numbers Using typeValue() method:

Method Calling Conversion Action

Convertin Numeric Strings to Primitive Numbers Using Parsing Methods:

Packages and Interfaces:

Ex: package firstpackage.secondpackage;

Import package1 [.package2] [.package3] .classname;

The output will be as under

- Variables are declared as follows:

Static final type VariableName = Value;

Return-type methodName2 (parameter_list);

- Here is an example of an interface definition

Interface name2 extends name1

- We can also combine several interfaces together into a single interface.

Class classname implements InterfaceName

- A more general form of implementation may looks like this:

Class classname extends superclass implements interface1,

INHERITANCE: EXTENDING A CLASS:

 Single level Inheritance

Abstract Methods and Classes:

INTERFACES AND INHERITANCE: