Java Notes - Copy

SUIET 2022-23 21SCS34
OBJECT ORIENTED PROGRAMMING USING JAVA
Sub Code : 21SCS34 IA Marks : 50

Hrs./ Week : 3 Exam Hours : 2
Credits : 3 Exam Marks: 50
Mode of Delivery : RM Total Hours : 40
Course Objectives:
 Describe and Analyze the fundamental features of object oriented language and JAVA.
 Develop Java JDK environment to create, debug and run simple Java programs.
 Explain object oriented concepts using programming examples.
 Illustrate the concepts of importing of packages and exception handling mechanism.
 Discuss the String Handling examples with Object Oriented concepts.
Course Outcomes:
On Completion of this Course students are able to,

CO1: Explain the object-oriented concepts and JAVA.
CO2: Develop computer programs to solve real world problems in Java.
CO3: Develop simple GUI interfaces for a computer program to interact with users and to
understand the event-based GUI handling principles using Applets and swings.
CO4: Create multi-threaded programs and event handling mechanisms.
CO5: Develop simple GUI Using applets concepts

TEXT/REFERENCE BOOKS:
T/R BOOK TITLE/AUTHORS/PUBLICATION
T1 Introduction to the Design and Analysis of Algorithms, AnanyLevitin:2nd
Edition, 2009( Pearson)
T2 Computer Algorithms/C++, Ellis Horowitz, SatrajSahni and Rajasekaran, 2nd Edition, 2014,
Universities Press
R1 Introduction to Algorithms, Thomas H Cormen, Charles E Leiserson, Ronal L Rivest, Clifford Stein,
3rd Edition, PHI
R2 Design and Analysis of Algorithms , S Sridhar, Oxford (Higher Education)
Faculty Member HOD

Date:
Object oriented programming using java Page 1

SUIET 2022-23 21SCS34
MODULE I
An Overview of Java: Object-Oriented Programming, A First Simple Program, A Second Short

Program, Two Control Statements, Using Blocks of Code, Lexical Issues, The Java Class
Libraries, Data Types, Variables, and Arrays: Java Is a Strongly Typed Language, The Primitive
Types, Integers, Floating-Point Types, Characters, Booleans, A Closer Look at Literals, Variables,
Type Conversion and Casting, Arrays, A Few Words About Strings.
Teaching Methodology: Chalk and talk using PPT and Demo to explain the Concept .
08 Hours
MODULE II
Operators: Arithmetic Operators, The Bitwise Operators, Relational Operators, Boolean Logical
Operators, The Assignment Operator, The ? Operator, Operator Precedence, Using Parentheses,
Control Statements: Java’s Selection Statements, Iteration Statements, Jump Statements.
08 Hours
MODULE III
Introducing Classes: Class Fundamentals, Declaring Objects, Assigning Object Reference

Variables, Introducing Methods, Constructors, The this Keyword, Garbage Collection, The finalize(
) Method, A Stack Class, A Closer Look at Methods and Classes: Overloading Methods, Using
Objects as Parameters, A Closer Look at Argument Passing, Returning Objects, Recursion,
Introducing Access Control, Understanding static, Introducing final, Arrays Revisited, Inheritance:
Inheritance, Using super, Creating a Multilevel Hierarchy, When Constructors Are Called, Method
Overriding, Dynamic Method Dispatch, Using Abstract Classes, Using final with Inheritance and
with Object Class.
08 Hours
MODULE IV
Packages and Interfaces: Packages, Access Protection, Importing Packages, Interfaces, Exception
Handling: Exception-Handling Fundamentals, Exception Types, Uncaught Exceptions, Using try
and catch, Multiple catch Clauses, Nested try Statements, throw, throws, finally, Java’s Built-in
Exceptions, Creating Your Own Exception Subclasses, Chained Exceptions, Using Exceptions.
08 Hours
MODULE V

SUIET 2022-23 21SCS34
Enumerations, Type Wrappers, I/O, Applets, and Other Topics: I/O Basics, Reading Console
Input, Writing Console Output, The PrintWriter Class, Reading and Writing Files, Applet
Fundamentals, The transient and volatile Modifiers, Using instance of, strictfp, Native Methods,
Using assert, Static Import, Invoking Overloaded Constructors Through this( ), String Handling: The
String Constructors, String Length, Special String Operations, Character Extraction, String
Comparison, Searching Strings, Modifying a String, Data Conversion Using valueOf( ), Changing
the Case of Characters Within a String , Additional String Methods, String Buffer, String Builder.
08 Hours
Continuous Internal Assessment (CIA) Method:
Sl. Type of Assessment Mode of Assessment Marks
No.
Solving Challenging Problems/Case
1 Regular mode of Assessment 15
Study
One Open Book written Exam at Regular mode of
2 10
theend of the Module 4 Assessment
Assignments on Advanced
3 Topics(group of size 2)/individual) Regular mode of Assessment 10
2 marks for eachModule
4 MCQ at the end of each module 10
As per the guidelines given in
5 Attendance 5
the regulations
Total 50
Scheme of Examination for End Semester Examination of 50 Marks:

PART A: TEN Multiple Choice Questions (MCQs) to be set for ONE MARK each. 1
Marks x 10 = 10 Marks
PART B: TWO question to be set from each module.
Students have to answer FIVE full questions. Choosing at least ONE full question from each
module. 08 Marks x 05 Question = 40 Marks.
TEXT BOOKS:
1. JAVA, The Complete Reference, Herbert Schildt, 7th Edition, Tata McGraw Hill, 2007.
REFERENCE BOOKS:
1. Programming with JAVA, Mahesh Bhave and Sunil Patekar, First Edition, Pearson Education
2008.
2. Object oriented Programming with JAVA, Rajkumar Buyya,S Thamarasi selvi, xingchen

SUIET 2022-23 21SCS34
chu, Tata McGraw Hill education private limited, 2010.

3. JAVA One step Ahead, Anita Seth and B L Juneja, Oxford University Press, 2017.
TEACHING/LESSON PLAN (ODD Semester 2022-23)
Lesson/Teaching Plan of the Course:
Mode
Ho Text/
of
ur Topic to be covered Reference
Deliv
No. book
ery
Module 1
An Overview of Java:Object oriented Chak Java
1 programming and complete
talk reference
A First Simple Program, A Second Short Java
2 Program, Two Control Statements, ppt complete
reference
Using Blocks of Code, Lexical Issues Java
3 ppt complete
reference
The Java Class Libraries, Data Types, Variables, Java
4 and Arrays ppt complete
reference
Java Is a Strongly Typed Language, The Java
Primitive Types, Integers, Floating-Point Types, complete
5 ppt
Characters reference
Booleans, A Closer Look at Literals, ppt Java

6 complete
reference
Variables, Type Conversion and Casting ppt Java
7 complete
reference
Arrays, A Few Words About Strings ppt Java
8 complete
reference
9 Module2
Arithmetic Operators Java
10 ppt complete
reference
The Bitwise Operators, Relational Operators Java
11 ppt complete
reference

SUIET 2022-23 21SCS34
Boolean Logical Operators Chalk Java

12 and complete
talk reference
The Assignment Operator, The ? Operator Java
13 ppt complete
reference
Operator Precedence, Using Parentheses Java
14 ppt complete
reference
Control Statements: Chalk Java
15 and complete
talk reference
Java’s Selection Statements Java
16 ppt complete
reference
Iteration Statements Java
17 ppt complete
reference
Jump Statements. chalk Java
18 and complete
talk reference
19 Module 3
Class Fundamentals, Declaring Objects, Assigning Chalk Java
20 Object Reference Variables and complete
talk reference
Introducing Methods, Constructors, The this Java
21 Keyword ppt complete
reference
Garbage Collection, The finalize( ) Method, A Java
Stack Class, A Closer Look at Methods and complete
22 ppt
Classes: reference
Overloading Methods, Using Objects as Java

23 Parameters,ACloser Look at Argument Passing ppt complete
reference
Returning Objects, Recursion, Introducing Access Chalk Java
24 Control and complete
talk reference
Understanding static, Introducing final, Arrays Java
25 Revisited ppt complete
reference
Inheritance: Inheritance, Using super, Creating a Chalk Java
26 Multilevel Hierarchy and complete
talk reference
When Constructors Are Called, Method Java
27 Overriding, Dynamic Method Dispatch ppt complete
reference

SUIET 2022-23 21SCS34
Using Abstract Classes, Using final with Java

28 Inheritance and with Object Class. Ppt complete
reference
Module 4
003 Packages, Access Protection, Importing Java
332 Packages, Interfaces ppppt complete
93 reference
Exception-Handling Fundamentals, Exception Java
30 Types, Uncaught Exceptions ppt complete
reference
Using try and catch, Multiple catch Clauses, Java
Nested try Statements, Chalk
31 complete
and tak
reference
throw, throws, finally, Java’s Built-in Exceptions Java
32 ppt complete
reference
Creating Your Own Exception Subclasses Chalk Java
33 and complete
talk reference
Chained Exceptions, Chalk Java
34 and complete
talk reference
Using exceptions Java
35 ppt complete
reference
36 Module 5
I/O Basics, Reading Console Input Java
37 ppt complete
reference
I/O Basics, Reading Console Input, Chalk Java
38 and complete
talk reference
Writing Console Output, The PrintWriter Class Java
39 ppt complete
reference
Reading and Writing Files, Applet Fundamentals Java
40 ppt complete
reference
The transient and volatile Modifiers Java
41 ppt complete
reference
Using instance of, strictfp, Native Methods, Using Java
42 assert ppt complete
reference
Static Import, Invoking Overloaded Constructors Java
43 Through this( ), ppt complete
reference

SUIET 2022-23 21SCS34
String Handling: The String Constructors, String Java

44 Length, Special String Operations ppt complete
reference
Character Extraction, String Comparison, ppt Java
45 Searching Strings, Modifying a String complete
reference
Data Conversion Using valueOf( ), Changing the ppt Java
Case of Characters Within a String , Additional complete
46
String Methods, String Buffer, String Builder reference

SUIET 2022-23 21SCS34
TABLE OF CONTENTS
SI.NO CONTENTS PAGE NO

1 MODULE 1
2 MODULE 2
3 MODULE 3
4 MODULE 4
5 MODULE 5

SUIET 2022-23 21SCS34
MODULE I
An Overview of Java
Object-Oriented Programming
 Object-oriented programming (OOP) is at the core of Java.
 In fact, all Java programs are to at least some extent object-oriented.
Two Paradigms
Process-oriented model:
 This approach characterizes a program as a series of linear steps.
 The process-oriented model can be thought of as code acting on data.
 Produral languages such as C employ this model to considerable success
Object-oriented programming:
 Object-oriented programming organizes a program around its data (that is objects) and a set of well-
defined interfaces to that data.
 Object-oriented program can be characterized as data controlling access to code.
Abstraction
 An essential element of object-oriented programming is abstraction.
 Humans manage complexity through abstraction.
 A powerful way to manage abstraction is through the use of hierarchical classifications.
Example: For example, people do not think of a car as a set of tens of thousands of individual parts. They
think of it as a well-defined object with its own unique behaviour. This abstraction allows people to use a car to
drive to the grocery store without being overwhelmed by the complexity of the parts that form the car. They
can ignore the details of how the engine, transmission, and braking systems work. Instead, they are free to
utilize the object as a whole.
The Three OOP Principles

All object-oriented programming languages provide mechanisms that help you implement
the object-oriented model. They are encapsulation, inheritance, and polymorphism
Encapsulation
Encapsulation is the mechanism that binds together code and the data it manipulates, and keeps both safe from
outside interference and misuse. One way to think about
Encapsulation is as a protective wrapper that prevents the code and data from
being arbitrarily accessed by other code defined outside the wrapper.
Access to the code and data inside the wrapper is tightly controlled through a well-defined interface.
i) In Java, the basis of encapsulation is the class.
ii) A class defines the structure and behaviour (data and code) that will be shared by a set of objects.
iii) Each object of a given class contains the structure and behaviour defined by the class, as if it were stamped
out by a mould in the shape of the class.
iv) Objects are sometimes referred to as instances of a class. Thus, a class is a logical construct; an object has
physical reality.
SUIET 2022-23 21SCS34
v) Since the purpose of a class is to encapsulate complexity, there are mechanisms for hiding the complexity
of the implementation inside the class.
a) Private: Private members can only be accessed within the class.
b) Public: Public members can access outside of the class.
Inheritance
i) Inheritance is the process by which one object acquires the properties of another object.
ii) It supports the concept of hierarchical classification.
iii) For example, a Golden Retriever is part of the classification dog, which in turn is part of the mammal class,
which is under the larger class animal.
Animal
Mammal
Golden retriever
iv) In the above example Animal Class is a Super class and Mammal and Golden retriever classes are derived
classes.
Polymorphism
i) Polymorphism (from Greek, meaning “many forms”) is a feature that allows one interface to be used for a
general class of actions.
ii) More generally, the concept of polymorphism is often expressed by the phrase “one interface, multiple
methods.” This means that it is possible to design a generic interface to a group of related activities.
iii) An excellent real time example of polymorphism is your Smartphone. The smartphone can act as phone,
camera, music player and what not, taking different forms and hence polymorphism.
A First Simple Program

Let’s start by compiling and running the short sample program as shown here.
/*
This is a simple Java program.
Call this file "Example.java".
*/
class Example {
// Your program begins with a call to main().
public static void main(String args[]) {
System.out.println("This is a simple Java program.");

SUIET 2022-23 21SCS34
To compile use the following command
C:\> javac Example.java
The javac compiler creates a file called Example.class that contains the byte code version of the program.
 Java bytecode is the intermediate representation of the program that contains instructions the Java Virtual
Machine will execute.
 javac is not code that can be directly executed.
To actually run the program, you must use the Java application launcher, called java.
To do so, pass the class name Example as a command-line argument, as shown here:
C:\>java Example
When the program is run, the following output is displayed:
A Closer Look at the First Sample Program
i) The program begins with the following lines
/*
Call this file "Example.java".
*/
This is a multiline comment in which it is ignored by the compiler.

ii) The next line of code in the program is shown here:
class Example {
This line uses the keyword class to declare that a new class is being defined.
Example is an identifier that is the name of the class.
The entire class definition, including all of its member will be between the opening curly brace ({) and
the closing curly brace (}).
iii) The next line in the program is the single-line comment, shown here:
// Your program begins with a call to main().
iv) The next line of code is shown here:

SUIET 2022-23 21SCS34
This line begins the main( ) method. As the comment preceding it suggests, this is the line at which the
program will begin executing. All Java applications begin execution by calling main( ). The keyword static
allows main( ) to be called without
having to instantiate a particular instance of the class. This is necessary since main( ) is called by the Java
Virtual Machine before any objects are made. The keyword void simply tells the compiler that main( ) does not
return a value. String args[ ] declares a parameter named args, which is an array of instances of the class
String.
v) The next line of code is shown here. Notice that it occurs inside main( ).
System.out.println("This is a simple Java program.");

This line outputs the string “This is a simple Java program.” followed by a new line on the screen. Output is
actually accomplished by the built-in println( ) method. In this case, println( ) displays the string which is
passed to it.
A Second Short Program

/*
Here is another short example.
Call this file "Example2.java".
*/
class Example2 {
int num; // this declares a variable called num
num = 100; // this assigns num the value 100
System.out.println("This is num: " + num);
num = num * 2;
System.out.print("The value of num * 2 is ");
System.out.println(num);
}
}
When you run this program, you will see the following output:
This is num: 100
The value of num * 2 is 200

SUIET 2022-23 21SCS34
Following is the general form of a variable declaration:
type var-name;
Here, type specifies the type of variable being declared, and var-name is the name of the variable.
Two Control Statements
The if Statement
The Java if statement works much like the IF statement in any other language.
Syntax:
if(condition)
statement;
Here, condition is a Boolean expression. If condition is true, then the statement is executed. If condition is
false, then the statement is bypassed.
Here is an example:
if(num < 100)
System.out.println("num is less than 100");
In this case, if num contains a value that is less than 100, the conditional expression is true, and println( ) will
execute. If num contains a value greater than or equal to 100, then the println( ) method is bypassed.
Operator using in conditional statement and its
< Less than
> Greater than
== Equal to
Here is a program that illustrates the if statement:

/*
Demonstrate the if.
Call this file "IfSample.java".
*/
class IfSample {
int x, y;
x = 10;
y = 20;
if(x < y) System.out.println("x is less than y");
x = x * 2;
if(x == y) System.out.println("x now equal to y");
x = x * 2;
if(x > y) System.out.println("x now greater than y");
// this won't display anything
if(x == y) System.out.println("you won't see this");
}
}
The output generated by this program:
x is less than y
x now equal to y

SUIET 2022-23 21SCS34
x now greater than y
The for Loop

Syntax:
for(initialization; condition; iteration) statement;
The initialization portion of the loop sets a loop control variable to an initial value. The condition is a Boolean
expression that tests the loop control variable. If the outcome of that test is true, the for loop continues to
iterate. If it is false, the loop terminates. The iteration expression determines how the loop control variable is
changed each time the loop iterates.
Here is a short program that illustrates the for loop:
/*
Demonstrate the for loop.
Call this file "ForTest.java".
*/
class ForTest {
int x;
for(x = 0; x<10; x = x+1)
System.out.println("This is x: " + x);
}
}
This program generates the output:
This is x: 0
This is x: 1
This is x: 2
This is x: 3
This is x: 4
This is x: 5
This is x: 6
This is x: 7
This is x: 8
This is x: 9
In this example, x is the loop control variable. It is initialized to zero in the initialization portion of the for. At
the start of each iteration (including the first one), the conditional test x < 10 is performed. If the outcome of
this test is true, the println( ) statement is executed, and then the iteration portion of the loop is executed. This
process continues until the conditional test is false.The increment operator is ++. The increment operator
increases its operand by one. By use of the increment operator, the preceding statement can be written like this:
x++;
Thus, the for in the preceding program will usually be written like this:
for(x = 0; x<10; x++)
Using Blocks of Code

Java allows two or more statements to be grouped into blocks of code, also called code blocks. This is done by
enclosing the statements between opening and closing curly braces. Once a block of code has been created, it
becomes a logical unit that can be used any place that a single statement can. For example, a block can be a
target for Java’s if and for statements.

SUIET 2022-23 21SCS34
Consider this if statement:

if(x < y) { // begin a block
x = y;
y = 0;
} // end of block
Let’s look at another example. The following program uses a block of code as the target of a for loop.
/*
Demonstrate a block of code.
Call this file "BlockTest.java"
*/
class BlockTest {
int x, y;
y = 20;
// the target of this loop is a block
for(x = 0; x<10; x++) {

System.out.println("This is x: " + x);
System.out.println("This is y: " + y);
y = y - 2;
}
}
}
The output of the program is :
This is x: 0
This is y: 20
This is x: 1
This is y: 18
This is x: 2
This is y: 16
This is x: 3
This is y: 14
This is x: 4
This is y: 12
This is x: 5
This is y: 10
This is x: 6
This is y: 8
This is x: 7
This is y: 6
This is x: 8
This is y: 4
This is x: 9
This is y: 2
In this case, the target of the for loop is a block of code and not just a single statement.Thus, each time the loop

SUIET 2022-23 21SCS34
iterates, the three statements inside the block will be executed.
Lexical Issues
Whitespace
Java is a free-form language. This means that you do not need to follow any special indentation rules. In Java
whitespace is a space, tab, or newline.
Identifiers
Identifiers are used for class names, method names, and variable names. An identifier may be any descriptive
sequence of uppercase and lowercase letters, numbers, or the underscore and dollar-sign characters. They must
not begin with a number, lest they be confused with a numeric literal. Again, Java is case-sensitive, so VALUE
is a different identifier than Value.
Some examples of valid identifiers are-
AvgTemp
count
a4
$test
this_is_ok
Invalid identifier names include these:

2count
high-temp
Not/ok
Literals
A constant value in Java is created by using a literal representation of it. For example, here are some literals:
100 –integer literal
98.6 – floating-point literal
'X' –character constant
"This is a test"-string
Comments:
Java supports three types of comments
i) Single line comment
ii) Multiline comment
iii) Documentation comment
The third type is called a documentation comment. This type of comment is used to produce an HTML file that
documents your program. The documentation comment begins with a /** and ends with a */.
Separators
In Java, there are a few characters that are used as separators.
Symbol Name Purpose

SUIET 2022-23 21SCS34
() Parentheses Used to contain lists of

parameters in method
definition and invocation
Also used for defining
precedence in expressions,
in control statements, and
surrounding cast types
{} Braces Used to contain the values
of automatically initialized
arrays. Also used to define a
block of code, for classes,
methods, and local scopes.
[] Brackets Used to declare

array types. Also used when
dereferencing array values.
; Semicolon Terminates statements.
, Comma Separates consecutive

identifiers in a variable
declaration. Also used to
chain statements together
inside a for statement.
. Period Used to separate package
names from sub packages
and classes used to separate
a variable or method from a
reference variable.
The Java Keywords
abstract continue For new switch

Assert default Goto package synchronized
Boolean do If private this
Break double Implements protected throw
Byte else Import public throws
Case enum Instaceof return Transient
Catch extends Int short try
Char final Interface static void
Class finally Long strictfp volatile
Const float Native super while
There are 50 keywords currently defined in the Java language .These keywords are
combined with the syntax of the operators and separators, form the foundation of the Java language. These
keywords cannot be used as names for a variable, class, or method.

SUIET 2022-23 21SCS34
The Java Class Libraries
The two of Java’s built-in methods: println( ) and print( ) and these methods are members of the System
class, which is a class predefined by Java that is automatically included in your programs. In the larger view,
the Java environment relies on several built-in class libraries that contain many built-in methods that provide
support for such things as I/O, string handling, networking, and graphics. The standard classes also provide
support for windowed output.
Data Types
The Primitive Types
Java defines eight primitive types of data:

1) byte
2) short
3) int
4) long
5) char
6) float
7) double
8) boolean.
The primitive types are also commonly referred to as simple types, and both terms will be used in this book.
These can be put in four groups:
In Integer Fl floating- Characters Boolean
point
byte float char boolean
short
long double
ss
Integers
Java defines four integer types: byte, short, int, and long. All of these are signed, positive and negative values.
Java does not support unsigned, positive-only integers.
Name Width Range

Long 64 –
9,223,372,036,854,775,808
to
9,223,372,036,854,775,807
Int 32 –2,147,483,648 to
2,147,483,647
Short 16 –32,768 to 32,767
Byte 8 –128 to 127
Example program:
// Compute distance light travels using long variables.

SUIET 2022-23 21SCS34
class Light {
int lightspeed;
long days;
long seconds;
long distance;
// approximate speed of light in miles per second
lightspeed = 186000;
days = 1000; // specify number of days here
seconds = days * 24 * 60 * 60; // convert to seconds
distance = lightspeed * seconds; // compute distance
System.out.print("In " + days);
System.out.print(" days light will travel about ");
System.out.println(distance + " miles.");
}
}
This program generates the following output:

In 1000 days light will travel about 16070400000000 miles.
Floating-Point Types
Floating-point numbers, also known as real numbers, are used when evaluating expressions that require
fractional precision. There are two types:
Name Width Bits Approximation

Range
Double 64 64 4.9e–324 to 1.8e+308
Float 32 1.4e–045 to 3.4e+038
Example program:
// Compute the area of a circle.
class Area {
double pi, r, a;
r = 10.8; // radius of circle
pi = 3.1416; // pi, approximately
a = pi * r * r; // compute area
System.out.println("Area of circle is " + a);
}
}
Characters
In Java, the data type used to store characters is char.
Here is a program that demonstrates char variables:
// Demonstrate char data type.

SUIET 2022-23 21SCS34
class CharDemo {
char ch1, ch2;
ch1 = 88; // code for X
ch2 = 'Y';
System.out.print("ch1 and ch2: ");
System.out.println(ch1 + " " + ch2);
}
}
Output:
ch1 and ch2: X Y
Boolean
Java has a primitive type, called boolean, for logical values. It can have only one of two possible values, true
or false.
Here is a program that demonstrates the boolean type:

// Demonstrate boolean values.
class BoolTest {
boolean b;
b = false;
System.out.println("b is " + b);
b = true;
System.out.println("b is " + b);
// a boolean value can control the if statement
if(b) System.out.println("This is executed.");

b = false;
if(b) System.out.println("This is not executed.");
// outcome of a relational operator is a boolean value
System.out.println("10 > 9 is " + (10 > 9));
}
}
Output:
b is false
b is true
This is executed.
10 > 9 is true
A Closer Look at Literals

Integer Literals:
Integers are probably the most commonly used type in the typical program. Any whole number value is an
integer literal.

SUIET 2022-23 21SCS34
Floating-Point Literals:
Floating-point numbers represent decimal values with a fractional component. They can be expressed in either
standard or scientific notation. Standard notation consists of a whole number component followed by a decimal
point followed by a fractional component.
Boolean Literals
Boolean literals are simple. There are only two logical values that a boolean value can have, true and false.
The values of true and false do not convert into any numerical representation. The true literal in Java does not
equal 1, nor does the false literal equal 0. In Java, they can only be assigned to variables declared as boolean,
or used in expressions with Boolean operators.
Character Literals
Characters in Java are indices into the Unicode character set. They are 16-bit values that can
be converted into integers and manipulated with the integer operators, such as the addition
and subtraction operators.
String Literals
String literals in Java are specified like they are in most other languages—by enclosing
a sequence of characters between a pair of double quotes. Examples of string literals are
“Hello World”
“two\nlines”
“\”This is in quotes\”“
Character Escape Sequences:
Escape Sequence Description

\ddd Octal character (ddd)
\uxxx Hexadecimal Unicode character
\’ Single quote
\” Double quote
\\ Backslash
\r Carriage return
\n New line
\f Form feed
\t Tab
\b Backspace
Variables
The variable is the basic unit of storage in a Java program. A variable is defined by the combination of an
identifier, a type, and an optional initializer. In addition, all variables have a scope, which defines their
visibility, and a lifetime.
Declaring a Variable

SUIET 2022-23 21SCS34
In Java, all variables must be declared before they can be used. The basic form of a variable declaration is
shown here:
type identifier [ = value][, identifier [= value] ...] ;
To declare more than one variable of the specified type, use a comma separated list.
Dynamic Initialization
Although the preceding examples have used only constants as initializers, Java allows variables to be initialized
dynamically, using any expression valid at the time the variable is declared.
Example program:
Class DynInit {
double a = 3.0, b = 4.0;
// c is dynamically initialized
double c = Math.sqrt(a * a + b * b);
System.out.println("Hypotenuse is " + c);
}
}
The Scope and Lifetime of Variables

In Java, the two major scopes
 defined by a class
 defined by a method.
// Demonstrate block scope.
class Scope {
int x; // known to all code within main
x = 10;
if(x == 10) { // start new scope
int y = 20; // known only to this block
// x and y both known here.
System.out.println("x and y: " + x + " " + y);
x = y * 2;
}
// y = 100; // Error! y not known here
// x is still known here.
System.out.println("x is " + x);
}
}

SUIET 2022-23 21SCS34
Type Conversion and Casting
Type conversion
Java’s Automatic Conversions
When one type of data is assigned to another type of variable, an automatic type conversion will take place if
the following two conditions are met:
• The two types are compatible.
• The destination type is larger than the source type.
Casting
Casting Incompatible Types

Here, target-type specifies the desired type to convert the specified value to. For example, the following
fragment casts an int to a byte. If the integer’s value is larger than the range of a byte, it will be reduced
modulo (the remainder of an integer division by the) byte’s range.
int a;
byte b;
b = (byte) a;
The following program demonstrates some type conversions that require casts:
// Demonstrate casts.
class Conversion {
byte b;
int i = 257;
double d = 323.142;
System.out.println("\nConversion of int to byte.");
b = (byte) i;
System.out.println("i and b " + i + " " + b);
System.out.println("\nConversion of double to int.");
i = (int) d;
System.out.println("d and i " + d + " " + i);
System.out.println("\nConversion of double to byte.");
b = (byte) d;
System.out.println("d and b " + d + " " + b);
}
}
Output:
Conversion of int to byte.
i and b 257 1
Conversion of double to int.
d and i 323.142 323

SUIET 2022-23 21SCS34
Conversion of double to byte.

d and b 323.142 67
Arrays
An array is a group of like-typed variables that are referred to by a common name. Array element is accessed
by its index. Arrays offer a convenient means of grouping related information.
One-Dimensional Arrays
A one-dimensional array is, essentially, a list of like-typed variables. To create an array, you first must create
an array variable of the desired type. The general form of a one-dimensional array declaration is
type var-name[ ];
Example:
int a[];
Array allocation is done is done using new

array_var = new type[size];
Example:
a=new int[10];
Example program:
Here is an example that uses a one-dimensional array. It finds the average of a set
of numbers.
// Average an array of values.
class Average {
double nums[] = {10.1, 11.2, 12.3, 13.4, 14.5};
double result = 0;
int i;
for(i=0; i<5; i++)
result = result + nums[i];
System.out.println("Average is " + result / 5);
}
}
Multidimensional Arrays
Multidimensional arrays are arrays of arrays.
Declaring multidimensional array : int twoD [] [] = new int [4] [5];
// Demonstrate a two-dimensional array.
class TwoDArray {
int twoD[][]= new int[4][5];
int i, j, k = 0;
for(i=0; i<4; i++)
for(j=0; j<5; j++) {
twoD[i][j] = k;
k++;
}

SUIET 2022-23 21SCS34
for(i=0; i<4; i++) {

for(j=0; j<5; j++)
System.out.print(twoD[i][j] + " ");
System.out.println();
}
}
}
output:
01234
56789
10 11 12 13 14
15 16 17 18 19
When you allocate memory for multi-dimensional array, you need to specify the memory for the first
dimension. Remaining dimensions separately
Ex : int twoD[][] = new int[4][];
twoD[0] = new int[5];
Initializing two dimensional array

Example :
// Initialize a two-dimensional array.
class Matrix {
double m[][] = {
{ 0*0, 1*0, 2*0, 3*0 },
{ 0*1, 1*1, 2*1, 3*1 },
{ 0*2, 1*2, 2*2, 3*2 },
{ 0*3, 1*3, 2*3, 3*3 }
};
int i, j;
for(i=0; i<4; i++) {
for(j=0; j<4; j++)
System.out.print(m[i][j] + " ");
System.out.println();
}
}
}
When you run this program, you will get the following output:
0.0 0.0 0.0 0.0
0.0 1.0 2.0 3.0
0.0 2.0 4.0 6.0
0.0 3.0 6.0 9.0
Alternative array declaration syntax
type[ ] var-name;
Example:
int[] arr = new int[5];
int arr[] = new int[5];
SUIET 2022-23 21SCS34
Char twod1[ ] [ ] = new char [3] [4];

Char [ ] [ ] twod2 = new char [3] [4];
A Few Words About Strings

The String type is used to declare string variables. You can also declare arrays of strings.
Aquoted string constant can be assigned to a String variable. A variable of type String can
be assigned to another variable of type String. You can use an object of type String as an
argument to println( ).
Example:
String str = "this is a test";
System.out.println(str);
Here, str is an object of type String. It is assigned the string “this is a test”. This string is
displayed by the println( ) statement.
MODULE II

SUIET 2022-23 21SCS34
Operators
Java provides rich set of operators, mainly divided into four groups viz. arithmetic, bitwise, relational and
logical. These operators are discussed here.
Arithmetic Operators
Arithmetic operators are used in mathematical expressions in the same way that they are used in
algebra. The following table lists the arithmetic operators:
Opera Meaning
tor
+ Addition
- Subtraction
* Multiplication
/ Division
% Modulus
++ Increment
-- Decrement
+= Addition assignment
-= Subtraction
assignment
*= Multiplication
assignment
/= Division assignment
%= Modulus assignment
The operands of the arithmetic operators must be of a numeric type. You cannot use them on boolean
types, but you can use them on char types, since the char type in Java is a subset of int.
Note down following few points about various operators:

 Basic arithmetic operators like +, -, * and / behave as expected for numeric data.
 The – symbol can be used as unary operator to negate a variable.
 If / is operated on two integer operands, then we will get only integral part of the result by
truncating the fractional part.
 The % operator returns the remainder after division. It can be applied on integer and floating-pointtypes.
For example,
int x=57; double y= 32.8;
System.out.println(“on integer “ + x%10); //prints 7
System.out.println(“on double “ + y%10); //prints 2.8
 Compound assignment operators like += will perform arithmetic operation with assignment. That is,
a+=2; a=a+2;
 Increment/decrement operators (++ and -- ) will increase/decrease the operand by 1. That is,
a++; a=a+1;
b--; b=b-1;
The ++ and -- operators can be used either as pre-increment/decrement or post-

increment/decrement operator. For example,
x= 5;
y=x++; //post increment
Now, value of x (that is 5) is assigned to y first, and x is then incremented to become 6. x= 5;
y=++x; //pre-increment

SUIET 2022-23 21SCS34
Now, x is incremented to 6 and then 6 is assigned to y.
NOTE that in C/C++, the % operator cannot be used on float or double and should be used only on integer
variable.
Bitwise Operators
Java defines several bitwise operators that can be applied to long, int, short, char, and byte. These operators
act upon the individual bits of their operands. They are summarized in the following table:
Opera Meaning
tor
~ Bitwise unary NOT
& Bitwise AND
| Bitwise OR
^ Bitwise exclusive OR
>> Shift right
>>> Shift right zero fill
<< Shift left
&= Bitwise AND assignment
|= Bitwise OR assignment
^= Bitwise exclusive OR
assignment
>>= Shift right assignment
>>>= Shift right zero fill assignment
<<= Shift left assignment
Since bitwise operators manipulate the bits within the integer, let us first understand the bit- representation of
integer data in Java.
All of the integer types are represented by binary numbers of varying bit widths. For example, the byte value
for 42 in binary is 00101010, where each position represents a power of two, starting with 2 0 at the rightmost
bit. All of the integer types are signed integers. Java uses an encoding known as two’s complement, which
means that negative numbers are represented by inverting (changing 1’s to 0’s and vice versa) all of the bits in
a value, then adding 1 to the result. For example, –42 is represented by inverting all of the bits in 42, or
00101010, which yields 11010101, then adding 1, which results in 11010110, or –42. To decode a negative
number, first invert all of the bits, and then add 1. For example,
–42, or 11010110 inverted, yields 00101001, or 41, so when you add 1 you get 42.
Bitwise Logical Operators

The bitwise logical operators are &, |, ^ and ~. Following table shows the result of each operation.

SUIET 2022-23 21SCS34
A B A&B A|B A^B ~A

0 0 0 0 0 1
0 1 0 1 1 1
1 0 0 1 1 0
1 1 1 1 0 0
Bitwise NOT
A unary NOT operator ~, also called as bitwise complement inverts all the bits of the operand. For example,
the number 42, which has the following bit pattern: 00101010 becomes 11010101 after the NOT operator is
applied.
Bitwise AND
As the name suggests, initially, operands are converted into binary-format. Then, the AND (&) operation is
performed on the corresponding bits of operands. Consider an example –
int x=5, y=6,z;

z= x & y;
Now, this operation is carried out as –
x 0000 0101
y 0000 0110
z 0000 0100
Thus, z will be decimal equivalent of 0000 0100, which is 4.
Bitwise OR
Here, the OR (|) operations is performed on individual bit of operands. For example –
int x=5, y=6,z;

z= x | y;
x 0000 0101
y 0000 0110
z 0000 0111
Bitwise XOR
In XOR operation, if both bits are same (either both are 1 or both 0), then the resulting bit will be 0 (false).
Otherwise, the resulting bit is 1 (true).
For example –
int x=5, y=6,z;

SUIET 2022-23 21SCS34
z= x ^ y;
x 0000 0101
y 0000 0110
z 0000 0011
Left Shift
The left shift operator, <<, shifts all of the bits in a value to the left by a specified number of times. It has this
general form:
value << num
For each shift, one higher order bit is shifted out (or lost) and extra zero is appended as the lower order bit.
Thus, for int, after 31 shifts, all the bits will be lost and result will be 0, whereas for long, after 63 shifts,
all bits will be lost.
Java’s automatic type promotions produce unexpected results when you are shifting byte and short values. As
you know, byte and short values are promoted to int when an expression is evaluated. Furthermore, the result
of such an expression is also an int. This means that the outcome of a left shift on a byte or short value will be
an int, and the bits shifted left will not be lost until they shifted for 31 times. To avoid this problem, we should
use type-casting as shown in the following example.
Program 2.1: Demonstration of left-shift operator

class ShiftDemo
{
public static void main(String args[])
{
byte a = 64, b;int i;
i = a << 2;
b = (byte) (a << 2); System.out.println("Original value of a: " + a);System.out.println("i and b: " + i + " " + b);
}
}
The result would be –

Original value of a: 64 i and b: 2560
Since a is promoted to int for evaluation, left-shifting the value 64 (0100 0000) twice results in i containing
the value 256 (1 0000 0000). However, the value in b contains 0 because after the shift, the low-order byte is
now zero.
Each left shift can be thought of as multiplying the number by 2. But, one should be careful because once the
number crosses its range during left shift, it will become negative. Consider an illustration –

SUIET 2022-23 21SCS34
Program
class ShiftDemo1
{

{
int i;
int num = 0xFFFFFFE;for(i=0; i<4; i++)
{
num = num << 1; System.out.println(num);
}
}
}
The output would be –

536870908
1073741816 //twice the previous value2147483632 //twice the previous value
-32 //crosses the range of int and hence negative
Right Shift
The right shift operator, >> shifts all of the bits in a value to the right by a specified number of times. It has
this general form:
value >> num
For each shift, one lower order bit is shifted out (or lost) and extra zero is appended as the higher orderbit.
For example,
int a = 35; //00100011 is the binary equivalent
a = a >> 2; // now, a contains 8
Each right shift can be thought of as dividing the number by 2. When you are shifting right, the top (leftmost)
bit is filled with the previous content of the top bit. This is called sign extension and is needed to preserve the
sign of negative numbers when you shift them right. For example, –8 >> 1 is –4, which, inbinary, is
11111000 (–8)
>>1
11111100 (–4)
Unsigned Right Shift

We have seen that right shift always fills the highest order bit with the previous content of the top bit. But when
we are using shift operation on non-numeric data, sign-bit has no significance. To ignore the sign- bit, we will
go for unsigned right shift. The following code fragment demonstrates the >>>. Here, a is setto –1, which sets
all 32 bits to 1 in binary. This value is then shifted right 24 bits, filling the top 24 bits with zeros, ignoring
normal sign extension. This sets a to 255.
int a = -1;
a = a >>> 24;
Here is the same operation in binary form to further illustrate what is happening:
11111111 11111111 11111111 11111111 –1 in binary as an int

>>>24
00000000 00000000 00000000 11111111 255 in binary as an int

SUIET 2022-23 21SCS34
Bitwise Operator Compound Assignment

We can use compound assignment even with bitwise operators. That is, a<<=2; implies a=a<<2;
a^=3; implies a=a^3; and so on.
Relational Operators
The relational operators determine the relationship between two operands. Specifically, they determine equality
and ordering among operands. Following table lists the relational operators supported by Java.
Opera Meaning
tor
== Equal to (or
comparison)
!= Not equal to
> Greater than
< Less than
>= Greater than or equal
to
<= Less than or equal to
The outcome of these operations is a boolean value. Any type in Java, including integers, floating-point
numbers, characters, and Booleans can be compared using the equality test, ==, and the inequality test,
!=. Only numeric types can be compared using the ordering operators. That is, only integer, floating- point, and
character operands may be compared to see which is greater or less than the other. For example, the following
code fragment is perfectly valid:
int a = 4;int b = 1;
boolean c = a < b;
In this case, the result of a<b (which is false) is stored in c.
Note that in C/C++ we can have following type of statement –

int flag;
……. if(flag)
//do something
In C/C++, true is any non-zero number and false is zero. But in Java, true and false are Boolean values and
nothing to do with zero or non-zero. Hence, the above set of statements will cause an error in Java. We should
write –
int flag;
……….. if(flag==1)
//do some thing
Boolean Logical Operators

The Boolean logical operators shown here operate only on boolean operands. All of the binary logical
operators combine two boolean values to form a resultant boolean value.
Operator Meaning
& Logical AND

SUIET 2022-23 21SCS34
| Logical OR
^ Logical OR
|| Short-circuit AND
&= AND assignment
|= OR assignment
^= XOR assignment
== Equal to
!= Not equal
?: Ternary if-then-else
The truth table is given below for few operations:
A B A| A A !A
B & ^B
B
Fa Fa Fa Fa Fa Tr
lse lse lse lse lse ue
Fa Tr Tr Fa Tr Tr
lse ue ue lse ue ue
Tr Fa Tr Fa Tr Fa
ue lse ue lse ue lse
Tr Tr Tr Tr Fa Fa
ue ue ue ue lse lse
Program to demonstrate Boolean Logical operators

class BoolLogic
{
{
boolean a = true; boolean b = false;boolean c = a | b;boolean d = a & b;boolean e = a ^ b;
boolean f = (!a & b) | (a & !b);boolean g = !a;
System.out.println(" a = " + a); System.out.println(" b = " + b); System.out.println(" a|b = " + c);
System.out.println(" a&b = " + d); System.out.println(" a^b = " + e); System.out.println("!a&b|a&!b = " + f);
System.out.println(" !a = " + g);
boolean h = b & (a=!a);
System.out.println("b & (a=!a) =" +h);System.out.println("New a is "+a);

}
}

SUIET 2022-23 21SCS34

a = true b = false a|b = true
a&b = false
a^b = true
!a&b|a&!b = true
!a = false
b & (a=!a) =falseNew a is false
Note: In C/C++, the logical AND/OR operations never evaluates the second operand if the value of first
operand itself can judge the result. That is, if the first operand is false, then second operand is not evaluated in
AND operation and result will be false. Similarly, if the first operand is true in OR operation, without
evaluating the second operand, it results true. But in Java, Boolean logical operators will not act so. Even if the
first operand is decisive, the second operand is evaluated. This can be observed in the above program while
evaluating h= b& (a= !a). Here, b is false and hence ANDed with anything results false. But, still the second
operand (a= !a) is evaluated resulting a as false.
If we don’t want the second operand to be evaluated, we can use short-circuit logical operators.
Short-Circuit Logical Operators

The short-circuit AND (&&) and OR (||) operators will not evaluate the second operand if the first is decisive.
For example,
int x=0, n=5;
……..
if(x!=0 && n/x > 0)
//do something
Here, the first operand x!= 0 is false. If we use logical AND (&) then the second operand n/x>0 will be
evaluated and we will get DivisionByZero Exception. So, to avoid this problem we use && operator which will
never evaluated second operand if the first operand results into false.
It is standard practice to use the short-circuit forms of AND and OR in cases involving Boolean logic, leaving
the single-character versions exclusively for bitwise operations. However, there are exceptions to this rule. For
example, consider the following statement:
if(c==1 & e++ < 100)d = 100;
Here, using a single & ensures that the increment operation will be applied to e whether c is equal to 1 ornot.
The Assignment Operator

The assignment operator is the single equal sign, =. It has this general form:
var = expression;
Here, the type of var must be compatible with the type of expression. It allows you to create a chain of
assignments. For example, consider this fragment:
int x, y, z;
x = y = z = 100; // set x, y, and z to 100
This fragment sets the variables x, y, and z to 100 using a single statement. This works because the = isan
operator that yields the value of the right-hand expression. Thus, the value of z = 100 is 100, which isthen

SUIET 2022-23 21SCS34
assigned to y, which in turn is assigned to x. Using a “chain of assignment” is an easy way to set a group of
variables to a common value.
The ?: Operator
Java supports ternary operator which sometimes can be used as an alternative for if-then-else statement. The
general form is –
var = expression1 ? expression2 : expression3;
Here, expression1 is evaluated first and it must return Boolean type. If it results true, then value of
expression2 is assigned to var, otherwise value of expression3 is assigned to var. For example,
int a, b, c ;
……….
c= (a>b)?a:b; //c will be assigned with biggest among a and b
Operator Precedence
Following table describes the precedence of operators. Though parenthesis, square brackets etc. are separators,
they do behave like operators in expressions. Operators at same precedence level will be evaluated from left to
right, whichever comes first.
Highest (), [ ], .
++, --, ~, !
*, /, %
+, -
>>, >>>, <<
>, >=, <, <=
==, !=
&
^
|
&&
||
?:
=, op=
Lowest
Using Parentheses
Parentheses always make the expression within them to execute first. This is necessary sometimes. For

SUIET 2022-23 21SCS34
example,
a= b – c * d;
Here, c and d are multiplied first and then the result is subtracted from b. If we want subtraction first, we
should use parenthesis like
a= (b-c)*d;
Sometimes, parenthesis is useful for clarifying the meaning of an expression and for making readers to
understand the code. For example,
a | 4 + c >> b & 7 can be written as (a | (((4 + c) >> b) & 7))
In such situations, though parenthesis seems to be redundant, it existence will not reduce theperformance of
the program.
Control Statements
A programming language uses control statements to cause the flow of execution to advance and branch based
on changes to the state of a program. Java’s program control statements can be put into the following
categories: selection, iteration, and jump. Selection statements allow your program to choose different paths
of execution based upon the outcome of an expression or the state of a variable. Iteration statements enable
program execution to repeat one or more statements (that is, iteration statements form loops). Jump statements
allow your program to execute in a nonlinear fashion. All of Java’s control statements are examined here.
Java’s Selection Statements

Java supports two selection statements: if and switch. These statements allow you to control the flow of your
program’s execution based upon conditions known only during run time.
if Statement
The general form is –
if (condition)
{
//true block
}
else
{
//false block
}
If the condition is true, then the statements written within true block will be executed, otherwise false
block will be executed. The condition should result into Boolean type. For example,
int a, b, max;
………… if(a>b)
max=a;
else
SUIET 2022-23 21SCS34
max=b;
Nested-if Statement
A nested if is an if statement that is the target of another if or else. For example,
if(i == 10)
{
if(j < 20)
a = b;
if(k > 100)
c = d;
else
a = c;
}
else
a = d;
The if-else-if Statement

if(condition1)
block1;
else if(condition2) block2;
…………..
…………..else
blockn
The if statements are executed from the top down. As soon as one of the conditions controlling the if is true,
the block associated with that if is executed, and the rest of the ladder is bypassed. The final else acts as a
default condition; that is, if all other conditional tests fail, then the last else statement is performed.
switch Statement
The switch statement is Java’s multi-way branch statement. It provides an easy way to dispatch execution to
different parts of your code based on the value of an expression. As such, it often provides a better alternative
than a large series of if-else-if statements. Here is the general form of a switch statement:
switch (expression)
{
case value1:
// statement sequencebreak;
case value2:
………….... case valueN:
default:
// default statement sequence
SUIET 2022-23 21SCS34
}
The expression must be of type byte, short, int, or char; each of the values specified in the case statements
must be of a type compatible with the expression. The switch statement works like this: The value of the
expression is compared with each of the literal values in the case statements. If a match is found, the code
sequence following that case statement is executed. If none of the constants matches the value of the
expression, then the default statement is executed. However, the default statement is optional. If no case
matches and no default is present, then no further action is taken. The break statement is used inside the
switch to terminate a statement sequence. When a break statement is encountered, execution branches to the
first line of code that follows the entire switch statement. This has the effect of “jumping out” of the switch.
The break statement is optional. If you omit the break, execution will continue on into the next case.
NOTE:
 We can even nest switch statements one within the other.
 The switch differs from the if in that switch can only test for equality, whereas if can evaluate any type
of Boolean expression. That is, the switch looks only for a match between the value ofthe expression and one
of its case constants.
 No two case constants in the same switch can have identical values. Of course, a switch
statement and an enclosing outer switch can have case constants in common.
 A switch statement is usually more efficient than a set of nested ifs.
The last point is particularly interesting because it gives insight into how the Java compiler works. When it
compiles a switch statement, the Java compiler will inspect each of the case constants and create a “jump
table” that it will use for selecting the path of execution depending on the value of the expression. Therefore,
if you need to select among a large group of values, a switch statement will run much faster than the
equivalent logic coded using a sequence of if-elses. The compiler can do this because it knows that the case
constants are all the same type and simply must be compared for equality with the switch expression. The
compiler has no such knowledge of a long list of if expressions.
Iteration Statements
Java’s iteration statements are for, while, and do-while. These statements create what we commonly call
loops. A loop repeatedly executes the same set of instructions until a termination condition is met.
while Loop
while(condition)
{
//body of the loop
}
The condition can be any Boolean expression. The body of the loop will be executed as long as the
conditional expression is true. When condition becomes false, control passes to the next line of code
immediately following the loop.
do- while Loop

do
{
//body of the loop
} while(condition);
38
SUIET 2022-23 21SCS34
Each iteration of the do-while loop first executes the body of the loop and then evaluates the conditional
expression. If this expression is true, the loop will repeat. Otherwise, the loop terminates. As with all of Java’s
loops, condition must be a Boolean expression.
for Loop
for(initialization; condition; updation)
{
// body of loop
}
When the loop first starts, the initialization portion of the loop is executed. Generally, this is an expression that
sets the value of the loop control variable, which acts as a counter that controls the loop. It is important to
understand that the initialization expression is only executed once. Next, condition isevaluated. This must be a
Boolean expression. It usually tests the loop control variable against a target value. If this expression is true,
then the body of the loop is executed. If it is false, the loop terminates. Next, the updation portion of the loop
is executed. This is usually an expression that increments or decrements the loop control variable. The loop
then iterates, first evaluating the conditional expression, then executing the body of the loop, and then
executing the iteration expression with each pass. This process repeats until the controlling expression is false.
for-each Loop
The for-each style of for is also referred to as the enhanced for loop. The general form of the for-each
version of the for is shown here:
for(type itr-var : collection)statement-block
Here, type specifies the type and itr-var specifies the name of an iteration variable that will receive the elements
from a collection, one at a time, from beginning to end. The collection being cycled through is specified by
collection. There are various types of collections that can be used with the for, but the only type used in this
chapter is the array. With each iteration of the loop, the next element in the collection is retrieved and stored in
itr-var. The loop repeats until all elements in the collection have been obtained.
Because the iteration variable receives values from the collection, type must be the same as (orcompatible with)
the elements stored in the collection. Thus, when iterating over arrays, type must be compatible with the base
type of the array.
Consider an example –
int nums[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int sum = 0;
for(int i=0; i < 10; i++)sum += nums[i];
The above set of statements can be optimized as follows –
int nums[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int sum = 0;
for(int x: nums)
sum += x;
With each pass through the loop, x is automatically given a value equal to the next element in nums. Thus, on
the first iteration, x contains 1; on the second iteration, x contains 2; and so on. Not only is the syntax
39
SUIET 2022-23 21SCS34
streamlined, but it also prevents boundary errors.
For multi-dimensional arrays:

The for-each version also works for multi-dimensional arrays. Since a 2-d array is an array of 1-d array, the
iteration variable must be a reference to 1-d array. In general, when using the for-each for to iterate over an
array of N dimensions, the objects obtained will be arrays of N–1 dimensions.
Consider the following example –
Program to Demonstrate for-each version of for loop

class ForEach
{
{
int sum = 0;
int nums[][] = new int[2][3];
// give nums some values for(int i = 0; i < 2; i++)

for(int j=0; j < 3; j++) nums[i][j] = (i+1)*(j+1);
for(int x[ ] : nums) //nums is a 2-d array and x is 1-d array

{
for(int y : x) // y refers elements in 1-d array x
{
System.out.println("Value is: " +y);sum += y;
}
}
System.out.println("Summation: " + sum);
}
}
Value is: 1
Value is: 2
Value is: 3
Value is: 2
Value is: 4
Value is: 6
Summation: 18
The for-each version of for has several applications viz. Finding average of numbers, finding minimum and
maximum of a set, checking for duplicate entry in an array, searching for an element in unsorted list etc. The
following program illustrates the sequential (linear) search.
Program 2.5 Linear/Sequential Search

class SeqSearch
{
40
SUIET 2022-23 21SCS34
{
int nums[] = { 6, 8, 3, 7, 5, 6, 1, 4 };
int val = 5;
boolean found = false;
for(int x : nums)
{
if(x == val)
found = true;break;
}
}
if(found)
System.out.println("Value found!");
}
}

Value found !
Jump Statements
Java supports three jump statements: break, continue, and return. These statements transfer control toanother
part of your program.
Using break
In java, break can be used in 3 different situations:
 To terminate statement sequence in switch
 To exit from a loop
 Can be used as a civilized version of goto
Following is an example showing terminating a loop using break.

for (int i=0;i<20;i++) if(i==5)
break;
else
System.out.println(“ i= “ + i);
The above code snippet prints values from 0 to 4 and when i become 5, the loop is terminated.
Using break as a form of goto

Java does not have a goto statement because it is an un-conditional jump and may end up with an infinite loop.
But in some situations, goto will be useful. For example, the goto can be useful when you are exiting from a
deeply nested set of loops. To handle such situations, Java defines an expanded form of the break statement.
By using this form of break, you can, for example, break out of one or more blocks of code. These blocks need
not be part of a loop or a switch. They can be any block. Further, you can specify precisely where execution
will resume, because this form of break works with a label. As you will see, break gives you the benefits of a
goto without its problems. The general form of labeled break is:
break label;
41
SUIET 2022-23 21SCS34
Program to break statement with labels

class Break
{
{
boolean t = true;
first:
{
second:
{
third:
{
System.out.println("Before the break.");if(t)
break second; // break out of second block
System.out.println("This won't execute");
}
System.out.println("This won't execute");
}
System.out.println("This is after second block.");
}
}
}

Before the break
This is after second block
As we can see in the above program, the usage of break with a label takes the control out of the secondblock
directly.
Using continue
Sometimes, we may need to proceed towards next iteration in the loop by leaving some statements. Insuch
situations, we can use continue statement within for, while and do-while. For example –
for (int i=1; i<20;i++)

if (i%2 == 0)
continue;
else
System.out.println(“i = “ + i);
The above code snippet prints only the odd numbers in the range of 1 to 20.
Using return
The return statement is used to explicitly return the method. Based on some condition, we may need togo
back to the calling method sometimes. So, we can use return in such situations.
42
SUIET 2022-23 21SCS34
MODULE III
Class Fundamentals
Class can be thought of as a user-defined data type. We can create variables (objects) of that data type.
So, we can say that class is a template for an object and an object is an instance of a class. Most of the
times, the terms object and instance are used interchangeably.
The General Form of a Class

A class contains data (member or instance variables) and the code (member methods) that operate on
43
SUIET 2022-23 21SCS34
the data. The general form can be given as –
class classname
{
type var1;
type var2;
…….
type method1(para_list)
{
//body of method1
}
type method2(para_list)
{
//body of method2
}
………..
}
Here, classname is any valid name given to the class. Variables declared within a class are called as
instance variables because every instance (or object) of a class contains its own copy of these
variables. The code is contained within methods. Methods and instance variables collectively called as
members of the class.
A Simple Class
Here we will consider a simple example for creation of class, creating objects and using members of the
class. One can store the following program in a single file called BoxDemo.java. (Or, two classes can be
saved in two different files with the names Box.java and BoxDemo.java.)
class Box
{
double w, h, d;
}
class BoxDemo
{
{
Box b1=new Box();
Box b2=new Box();
double vol;
b1.w=2;
b1.h=4;
b1.d=3;
b2.w=5;
b2.h=6;
b2.d=2;
44
SUIET 2022-23 21SCS34
vol=b1.w*b1.h*b1.d;
System.out.println("Volume of Box1 is " + vol);
vol=b2.w*b2.h*b2.d;
System.out.println("Volume of Box2 is " + vol);
}
}

Volume of Box1 is 24.0 w
Volume of Box1 is 60.0
h
When you compile above program, two class files will be created viz. Box.class and BoxDemo.class. Since
main() method is contained in BoxDemo.class, you need to execute the same.
In the above example, we have created a class Box which contains 3 instance variables w, h, d.
Box b1=new Box();
The above statement creates a physical memory for one object of Box class. Every object is an instance of a
class, and so, b1 and b2 will have their own copies of instance variables w, h and d.
Declaring Objects
Creating a class means having a user-defined data type. To have a variable of this new data type, we should
create an object.
Consider the following declaration:
Box b1;
This statement will not actually create any physical object, but the object name b1 can just refer to the actual
object on the heap after memory allocation as follows –
b1 = new Box ();
We can even declare an object and allocate memory using a single statement –
Box b1=new Box();
Without the usage of new, the object contains null. Once memory is allocated dynamically, the object b1
contains the address of real object created on the heap.
The memory map is as shown in the following diagram –
Statement Effect
Box b1; Null
b1
45
SUIET 2022-23 21SCS34
d
b1 = new Box();
w b1
h
Closer look at new
The general form for d object creation is –
obj_name = new class_name();
Here, class_name() is actually a constructor call. A constructor is a special type of member function invoked
automatically when the object gets created. The constructor usually contains the code needed for object
initialization. If we do not provide any constructor, then Java supplies a default constructor.
Java treats primitive types like byte, short, int, long, char, float, double and boolean as ordinary variables but
not as an object of any class. This is to avoid extra overhead on the heap memory and also to increase the
efficiency of the program. Java also provides the class-version of these primitive types that
can be used only if necessary. We will study those types later in detail.
With the term dynamic memory allocation, we can understand that the keyword new allocates memory for
the object during runtime. So, depending on the user’s requirement memory will be utilized. This will
avoid the problems with static memory allocation (either shortage or wastage of memory during runtime).
If there is no enough memory in the heap when we use new for memory allocation, it will throw a run-time
exception.
Assigning Object Reference Variables

When an object is assigned to another object, no separate memory will be allocated. Instead, the second
object refers to the same location as that of first object. Consider the following declaration –
Box b1= new Box();
Box b2= b1;
Now both b1 and b2 refer to same object on the heap. The memory representation for two objects can be
shown as –
b1
46
SUIET 2022-23 21SCS34
b2
Thus, any change made for the instance variables of one object affects the other object also. Although b1
and b2 both refer to the same object, they are not linked in any other way. For example, a subsequent
assignment to b1 will simply unhook b1 from the original object without affecting the object or affecting
b2.
For example:
Box b1 = new Box();
Box b2 = b1;
// ...
b1 = null;
Here, b1 has been set to null, but b2 still points to the original object.
NOTE that when you assign one object reference variable to another object reference variable, you are
not creating a copy of the object, you are only making a copy of the reference.
Introducing Methods
A class can consist of instance variables and methods. We have seen declaration and usage of instance
variables in Program 2.1. Now, we will discuss about methods. The general form of a method is –
ret_type method_name(para_list)
{
//body of the method
return value;
}
Here, ret_type specifies the data type of the variable returned by the method. It may be any primitive type or
any other derived type including name of the same class. If the method does not return any value, the ret_type
should be specified as void.
method_name is any valid name given to the method para_list is the list of parameters (along with their
respective types) taken the method. It may be even empty also.
body of method is a code segment written to carry out some process for which the method is meant for.
return is a keyword used to send value to the calling method. This line will be absent if the ret_type is void.
Adding Methods to Box class
Though it is possible to have classes with only instance variables as we did for Box class of Program ,
it is advisable to have methods to operate on those data. Because, methods acts as interface to the
classes. This allows the class implementer to hide the specific layout of internal data structures behind
cleaner method abstractions. In addition to defining methods that provide access to data, you can also
define methods that are used internally by the class itself.
Consider the following example –
class Box
{
47
SUIET 2022-23 21SCS34
double w, h, d;
void volume()
{
System.out.println("The volume is " + w*h*d);
}
class BoxDemo
{
{
Box b1=new Box();
Box b2=new Box();
b1.w=2;
b1.h=4;
b1.d=3;
b2.w=5;
b2.h=6;
b2.d=2;
b1.volume();
b2.volume();
}
}

The volume is 24.0
The volume is 60.0
In the above program, the Box objects b1 and b2 are invoking the member method volume() of the Box
class to display the volume. To attach an object name and a method name, we use dot (.) operator. Once
the program control enters the method volume(), we need not refer to object name to use the instance
variables w, h and d.
Returning a value
In the previous example, we have seen a method which does not return anything. Now we will modify the
above program so as to return the value of volume to main() method.
class Box
{
double w, h, d;
double volume()
{
return w*h*d;
}
}
48
SUIET 2022-23 21SCS34
class BoxDemo
{
{
Box b1=new Box();
Box b2=new Box();
double vol;
b1.w=2;
b1.h=4;
b1.d=3;
b2.w=5;
b2.h=6;
b2.d=2;
vol = b1.volume()
System.out.println("The volume is " + vol);
System.out.println("The volume is " + b2.volume());
}
}

The volume is 24.0
The volume is 60.0
As one can observe from above example, we need to use a variable at the left-hand side of the
assignment operator to receive the value returned by a method. On the other hand, we can directly make
a method call within print statement as shown in the last line of above program.
There are two important things to understand about returning values:
The type of data returned by a method must be compatible with the return type specified by the
method. For example, if the return type of some method is boolean, you could not return an
integer.
The variable receiving the value returned by a method (such as vol, in this case) must also be
compatible with the return type specified for the method.
Adding Methods that takes Parameters

Having parameters for methods is for providing some input information to process the task. Consider the
following version of Box class which has a method with parameters.
class Box
{
double w, h, d;
double volume()
{
return w*h*d;
}
void set(double wd, double ht, double dp)
{
w=wd;
49
SUIET 2022-23 21SCS34
h=ht;
d=dp;
}
}
class BoxDemo
{
{
Box b1=new Box();
Box b2=new Box();
b1.set(2,4,3);
b2.set(5,6,2);
System.out.println("The volume of b1 is " + b1.volume());
System.out.println("The volume of b2 is " + b2.volume());
}
}
The volume of b1 is 24.0
In the above program, the Box class contains a method set() which take 3 parameters. Note that, the variables
wd, ht and dp are termed as formal parameters or just parameters for a method. The values
passed like 2, 4, 3 etc. are called as actual arguments or just arguments passed to the method.
Constructors
Constructor is a special type of member method which is invoked automatically when the object gets
created. Constructors are used for object initialization. They have same name as that of the class. Since
they are called automatically, there is no return type for them. Constructors may or may not take
parameters.
class Box
{
double w, h, d;
double volume()
{
return w*h*d;
}
Box() //ordinary constructor
{
w=h=d=5;
}
Box(double wd, double ht, double dp) //parameterized constructor
{
w=wd;
h=ht;
d=dp;
}
50
SUIET 2022-23 21SCS34
}
class BoxDemo
{
{
Box b1=new Box();
Box b2=new Box();
Box b3=new Box(2,4,3);
System.out.println("The volumeof b1 is " + b1.volume());
}
}

When we create two objects b1 and b2, the constructor with no arguments will be called and the all the
instance variables w, h and d are set to 5. Hence volume of b1 and b2 will be same (that is 125 in this
example). But, when we create the object b3, the parameterized constructor will be called and hence
volume will be 24.
Few points about constructors:

Every class is provided with a default constructor which initializes all the data members to
respective default values. (Default for numeric types is zero, for character and strings it is null and
default value for Boolean type is false.)
In the statement
classname ob= new classname();
the term classname() is actually a constructor call.

 If the programmer does not provide any constructor of his own, then the above statement will call
default constructor.
 If the programmer defines any constructor, then default constructor of Java can not be used.
 So, if the programmer defines any parameterized constructor and later would like to create an
object without explicit initialization, he has to provide the default constructor by his own.
For example, the above program, if we remove ordinary constructor, the statements like
Box b1=new Box();
will generate error. To avoid the error, we should write a default constructor like –
Box(){ }
Now, all the data members will be set to their respective default values.
The this Keyword

Sometimes a method will need to refer to the object that invoked it. To allow this, Java defines the this
keyword. this can be used inside any method to refer to the current object. That is, this is always a
reference to the object which invokes the method call. For example, in the Program 2.5, the method
51
SUIET 2022-23 21SCS34
volume() can be written as –
double volume()
{
return this.w * this.h * this.d;
}
Here, usage of this is not mandatory as it is implicit. But, in some of the situations, it is useful as
explained in the next section
Instance Variable Hiding
As we know, in Java, we can not have two local variables with the same name inside the same or
enclosing scopes. (Refer Program 1.7 and a NOTE after that program from Chapter 1, Page 16 & 17).
But we can have local variables, including formal parameters to methods, which overlap with the names
of the class’ instance variables. However, when a local variable has the same name as an instance
variable, the local variable hides the instance variable. That is, if we write following code snippet for a
constructor in Program 2.5, we will not get an expected output –
Box(double w, double h, double d)
{
w=w;
h=h;
d=d;
}
Here note that, formal parameter names and data member names match exactly. To avoid the problem,
we can use –
{
this.w=w; //this.w refers to data member name and w refers to formal parameter
this.h=h;
this.d=d;
}
In C and C++, dynamically allocated variables/objects must be manually released using delete operator.
But, in Java, this task is done automatically and is called as garbage collection. When no references to
an object exist, that object is assumed to be no longer needed, and the memory occupied by the object
can be reclaimed. Garbage collection occurs once in a while during the execution of the program. It will
not occur simply because one or more objects exist that are no longer used. Furthermore, different Java
run-time implementations will take varying approaches to garbage collection.
The finalize() Method

Sometimes an object will need to perform some action when it is destroyed. For example, if an object is
holding some non-Java resource such as a file handle or character font, then you might want to make
sure these resources are freed before an object is destroyed. To handle such situations, Java provides a
mechanism called finalization. By using finalization, you can define specific actions that will occur when
an object is just about to be reclaimed by the garbage collector. To add a finalizes to a class, you simply
define the finalize() method. The Java run time calls that method whenever it is about to recycle an
object of that class.
The finalize( ) method has this general form:
protected void finalize( )

{
// finalization code here
52
SUIET 2022-23 21SCS34
}
Here, the keyword protected is a specifier that prevents access to finalize( ) by code defined outside its
class. Note that finalize( ) is only called just prior to garbage collection. It is not called when an object
goes out-of-scope. So, we can not know when finalize() method is called, or we may be sure whether it
is called or not before our program termination. Therefore, if at all our program uses some resources, we
should provide some other means for releasing them and must not depend on finalize() method.
A Stack Class
To summarize the concepts of encapsulation, class, constructor, member initialization etc., we will now
consider a program to implement stack operations.
Concept of Stack: A stack is a Last in First Out (LIFO) data structure. Following figure depicts the basic
Inserting an element into a stack is known as push operation, whereas deleting an element from the
stack is pop operation. An attempt made to push an element into a full stack is stack overflow and an
attempt to delete from empty stack is stack underflow.
class Stack
{
int st[] = new int[5];
int top;
Stack()
{
top = -1;
}
void push(int item)
{
if(top==4)
System.out.println("Stack is full.");
53
SUIET 2022-23 21SCS34
else
st[++top] = item;
}
int pop()
{
if(top==-1)
{
System.out.println("Stack underflow.");
return 0;
}
else
return st[top--];
}
}
class StackDemo
{
{
Stack mystack1 = new Stack();
Stack mystack2 = new Stack();
for(int i=0; i<5; i++)
mystack1.push(i);
for(int i=5; i<10; i++)
mystack2.push(i);
System.out.println("Contents of mystack1:");
System.out.println(mystack1.pop());
System.out.println("Contents of mystack2:");
System.out.println(mystack2.pop());
}
}
Overloading Methods
Having more than one method with a same name is called as method overloading. To implement this
concept, the constraints are:
1. The number of arguments should be different, and/or
2. Type of the arguments must be different.
NOTE that, only the return type of the method is not sufficient for overloading.
class Overload
{
void test() //method without any arguments
{
System.out.println("No parameters");
}
void test(int a) //method with one integer argument
54
SUIET 2022-23 21SCS34
{
System.out.println("Integer a: " + a);
}
void test(int a, int b) //two arguments
{
System.out.println("With two arguments : " + a + " " + b);
}
void test(double a) //one argument of double type
{
System.out.println("double a: " + a);
}
}
class OverloadDemo
{
{
Overload ob = new Overload();
ob.test();
ob.test(10);
ob.test(10, 20);
ob.test(123.25);
}
}
Overloading Constructors
One can have more than one constructor for a single class if the number and/or type of arguments are
different. Consider the following code:
class OverloadConstruct
{
int a, b;
OverloadConstruct()
{
System.out.println("Constructor without arguments");
}
OverloadConstruct(int x)
{
a=x;
System.out.println("Constructor with one argument:"+a);
}
OverloadConstruct(int x, int y)
{
a=x;
b=y;
System.out.println("Constructor with two arguments:"+ a +"\t"+ b);
}
}
55
SUIET 2022-23 21SCS34
class OverloadConstructDemo
{
{
OverloadConstruct ob1= new OverloadConstruct();
OverloadConstruct ob2= new OverloadConstruct(10);
OverloadConstruct ob3= new OverloadConstruct(5,12);
}
}
Output:
Constructor without arguments
Constructor with one argument: 10
Constructor with two arguments: 5 12
Using Objects as Parameters

Just similar to primitive types, even object of a class can also be passed as a parameter to any method.
Consider the example given below –
class Test
{
int a, b;
Test(int i, int j)
{
a = i;
b = j;
}
boolean equals(Test ob)
{
if(ob.a == this.a && ob.b == this.b)
return true;
else
return false;
}
}
class PassOb
{
{
Test ob1 = new Test(100, 22);
Test ob2 = new Test(100, 22);
Test ob3 = new Test(-1, -1);
System.out.println("ob1 == ob2: " + ob1.equals(ob2));
System.out.println("ob1 == ob3: " + ob1.equals(ob3));
}
}
Output:
ob1 == ob2: true
56
SUIET 2022-23 21SCS34
ob1 == ob3: false
Using one object to initialize the other:

Sometimes, we may need to have a replica of one object. The usage of following statements will not
serve the purpose.
Box b2=b1;
In the above case, both b1 and b2 will be referring to same object, but not two different objects. So, we
can write a constructor having a parameter of same class type to clone an object.
class Box
{
double h, w, d;
Box(double ht, double wd, double dp)
{
h=ht; w=wd; d=dp;
}
Box (Box bx) //observe this constructor
{
h=bx.h; w=bx.w; d=bx.d;
}
void vol()
{
System.out.println("Volume is " + h*w*d);
}
{
Box b2=new Box(b1); //initialize b2 using b1
b1.vol();
b2.vol();
}
}
Output
Volume is 24
Volume is 24
A Closer Look at Argument Passing

In Java, there are two ways of passing arguments to a method.
 Call by value : This approach copies the value of an argument into the formal parameter of the
method. Therefore, changes made to the parameter of the method have no effect on the argument.
 Call by reference: In this approach, a reference to an argument is passed to the parameter. Inside the
subroutine, this reference is used to access the actual argument specified in the call. This means that
changes made to the parameter will affect the argument used to call the subroutine.
57
SUIET 2022-23 21SCS34
In Java, when you pass a primitive type to a method, it is passed by value. When you pass an object to a
method, they are passed by reference. Keep in mind that when you create a variable of a class type, you are
only creating a reference to an object. Thus, when you pass this reference to a method, the parameter that
receives it will refer to the same object as that referred to by the argument.
This effectively means that objects are passed to methods by use of call-by-reference. Changes to the object
inside the method do affect the object used as an argument.
class Test
{
int a, b;
Test(int i, int j)
{
a = i;
b = j;
}
void meth(Test o)
{
o.a *= 2;
o.b /= 2;
}
}
class CallByRef
{
{
Test ob = new Test(15, 20);
System.out.println("before call: " + ob.a + " " + ob.b);
ob.meth(ob);
System.out.println("after call: " + ob.a + " " + ob.b);
}
}
Output:
before call: 15 20
after call: 30 10
Returning Objects
In Java, a method can return an object of user defined class.
class Test
{
int a;
Test(int i)
{
a = i;
}
Test incrByTen()
{
58
SUIET 2022-23 21SCS34
Test temp = new Test(a+10);
return temp;
}
}
class RetOb
{
{
Test ob1 = new Test(2);
Test ob2;
ob2 = ob1.incrByTen();
System.out.println("ob1.a: " + ob1.a);
System.out.println("ob2.a: " + ob2.a);
ob2 = ob2.incrByTen();
System.out.println("ob2.a after second increase: " + ob2.a);
}
}
Output:
ob1.a: 2
ob2.a: 12
ob2.a after second increase: 22
Recursion
A method which invokes itself either directly or indirectly is called as recursive method. Every recursive
method should satisfy following constraints:
1. It should have at least one non-recursive terminating condition.
2. In every step, it should be nearer to the solution (that is, problem size must be decreasing)
class Factorial
{
int fact(int n)
{
if (n==0)
return 1;
return n*fact(n-1);
}
}
class FactDemo
{
{
Factorial f= new Factorial();
System.out.println("Factorial 3 is "+ f.fact(3));
System.out.println("Factorial 8 is "+ f.fact(8));
}
}
59
SUIET 2022-23 21SCS34
Output:
Factorial of 3 is 6
Factorial of 8 is 40320
Introducing Access Control

Encapsulation feature of Java provides a safety measure viz. access control. Using access specifiers,
we can restrict the member variables of a class from outside manipulation. Java provides following
access specifiers:
1. public
2. private
3. protected
Along with above access specifiers, Java defines a default access level.
Some aspects of access control are related to inheritance and package (a collection of related classes).
The protected specifier is applied only when inheritance is involved. So, we will now discuss about only
private and public.
When a member of a class is modified by the public specifier, then that member can be accessed by any
other code. When a member of a class is specified as private, then that member can only be accessed by
other members of its class. When no access specifier is used, then by default the member of a class is
public within its own package, but cannot be accessed outside of its package. Usually, you will want to
restrict access to the data members of a class—allowing access only through methods. Also, there will
be times when you will want to define methods that are private to a class. An access specified precedes the rest
of a member’s type specification.
For example,
public int x;
private char ch;
Consider a program given below –

class Test
{
int a;
public int b;
private int c;
void setc(int i)
{
c = i;
}
int getc()
{
return c;
}
}
class AccessTest
{
{
Test ob = new Test();
60
SUIET 2022-23 21SCS34
ob.a = 10;
ob.b = 20;
ob.setc(100);
System.out.println("a, b, and c: " + ob.a + " " + ob.b + " " + ob.getc());
}
}
Understanding static
When a member is declared static, it can be accessed before any objects of its class are created, and
without reference to any object. Instance variables declared as static are global variables. When objects
of its class are declared, no copy of a static variable is made. Instead, all instances of the class share
the same static variable.
Methods declared as static have several restrictions:
They can only call other static methods.
They must only access static data.
They cannot refer to this or super in any way.
If you need to do computation in order to initialize your static variables, you can declare a static block
that gets executed exactly once, when the class is first loaded.
class UseStatic
{
static int a = 3;
static int b;
static void meth(int x) //static method
{
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}
static //static block
{
System.out.println("Static block initialized.");
b = a * 4;
}
{
meth(42);
}
}
Output:
Static block initialized.
x = 42
a=3
b = 12
Outside of the class in which they are defined, static methods and variables can be used independently
of any object. To do so, you need only specify the name of their class followed by the dot operator. The
general form is –
classname.method();
Consider the following program:
61
SUIET 2022-23 21SCS34
class StaticDemo
{
static int a = 42;
static int b = 99;
static void callme()
{
System.out.println("Inside static method, a = " + a);
}
}
class StaticByName
{
{
StaticDemo.callme();
System.out.println("Inside main, b = " + StaticDemo.b);
}
}
Output:
Inside static method, a = 42
Inside main, b = 99
Arrays Revisited
Arrays have been discussed earlier. An important point to be noted with arrays is: arrays are
implemented as objects in Java. Because of this, we can use a special instance variable length to know
the size of an array.
class Test
{
{
int a1[]=new int[10];
int a2[]={1, 2, 3, 4, 5};
int a3[]={3, 8, -2, 45, 9, 0, 23};
System.out.println(“Length of a1 is” + a1.length);
}
}
Output:
Length of a1 is 10
Length of a2 is 5
Length of a3 is 7
3.19 Inheritance
Inheritance is one of the building blocks of object oriented programming languages. It allows creation of
classes with hierarchical relationship among them. Using inheritance, one can create a general class that defines
traits common to a set of related items. This class can then be inherited by other, more specific classes, each
adding those things that are unique to it. In the terminology of Java, a class that is inherited is called a
62
SUIET 2022-23 21SCS34
superclass. 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. Through inheritance, one can achieve re-usability of the code.
class A //super class
{
//members of class A
}
class B extends A //sub class
{
//members of B
}
Consider a program to understand the concept:

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));
}
}
class SimpleInheritance
{
{
A superOb = new A();
B subOb = new B();
superOb.i = 10;
superOb.j = 20;
System.out.println("Contents of superOb: ");
superOb.showij();
subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
63
SUIET 2022-23 21SCS34
System.out.println("Contents of subOb: ");
subOb.showij();
subOb.showk();
System.out.println("Sum of i, j and k in subOb:");
subOb.sum();
}
}
Note that, private members of the super class can not be accessed by the sub class. The subclass
contains all non-private members of the super class and also it contains its own set of members to
achieve specialization.
Type of Inheritance
Single Inheritance: If a class is inherited from one parent class, then it is known as single inheritance.
This will be of the form as shown below –
Superclass
Subclass
The previous program is an example of single inheritance.
Multilevel Inheritance: If several classes are inherited one after the other in a hierarchical manner, it is known
as multilevel inheritance, as shown below –
64
SUIET 2022-23 21SCS34
A Superclass variable can reference a subclass object

A reference variable of a superclass can be assigned a reference to any subclass derived from that
superclass.
Consider the following for illustration:
class Base
{
void dispB()
{
System.out.println("Super class " );
}
}
class Derived extends Base

{
void dispD()
{
System.out.println("Sub class ");
}
}
class Demo
{
{
Base b = new Base();
Derived d=new Derived();
b=d; //superclass reference is holding subclass object
b.dispB();
//b.dispD(); error!!
}
}
Note that, the type of reference variable decides the members that can be accessed, but not the type
of the actual object. That is, when a reference to a subclass object is assigned to a superclass
reference variable, you will have access only to those parts of the object defined by the superclass.
Using super
In Java, the keyword super can be used in following situations:
1. To invoke superclass constructor within the subclass constructor
2. To access superclass member (variable or method) when there is a duplicate member name in
the subclass
Let us discuss each of these situations:
To invoke superclass constructor within the subclass constructor:

Sometimes, we may need to initialize the members of super class while creating subclass object. Writing such
a code in subclass constructor may lead to redundancy in code. For example,
65
SUIET 2022-23 21SCS34
class Box
{
double w, h, b;
Box(double wd, double ht, double br)
{
w=wd; h=ht; b=br;
}
}
class ColourBox extends Box

{
int colour;
ColourBox(double wd, double ht, double br, int c)
{
w=wd; h=ht; b=br; //code redundancy
colour=c;
}
}
Also, if the data members of super class are private, then we can’t even write such a code in subclass
constructor. If we use super() to call superclass constructor, then it must be the first statement executed inside
a subclass constructor as shown below –
class Box
{
double w, h, b;
Box(double wd, double ht, double br)
{
w=wd; h=ht; b=br;
}
}
class ColourBox extends Box

{
int colour;
ColourBox(double wd, double ht, double br, int c)
{
super(wd, ht, br); //calls superclass constructor
colour=c;
}
}
class Demo
{
{
ColourBox b=new ColourBox(2,3,4, 5);
}
66
SUIET 2022-23 21SCS34
}
Here, we are creating the object b of the subclass ColourBox . So, the constructor of this class is invoked. As
the first statement within it is super(wd, ht, br), the constructor of superclass Box is invoked, and then the rest
of the statements in subclass constructor ColourBox are executed.
To access superclass member variable when there is a duplicate variable name in the subclass:
This form of super is most applicable to situations in which member names of a subclass hide members by the
same name in the superclass.
class A
{
int a;
}
class B extends A
{
int a; //duplicate variable a
B(int x, int y)
{
super.a=x; //accessing superclass a
a=y; //accessing own member a
}
void disp()
{
System.out.println("super class a: "+ super.a);
System.out.println("sub class a: "+ a);
}
}
class SuperDemo
{
{
B ob=new B(2,3);
ob.disp();
}
}
Creating Multilevel Hierarchy

Java supports multi-level inheritance. A sub class can access all the non-private members of all of its
super classes. Consider an illustration:
class A
{
int a;
}
class B extends A
67
SUIET 2022-23 21SCS34
{
int b;
}
class C extends B
{
int c;
C(int x, int y, int z)
{
a=x; b=y; c=z;
}
void disp()
{
System.out.println("a= "+a+ " b= "+b+" c="+c);
}
}
class MultiLevel
{
{
C ob=new C(2,3,4);
ob.disp();
}
}
When Constructors are called

When class hierarchy is created (multilevel inheritance), the constructors are called in the order of their
derivation. That is, the top most super class constructor is called first, and then its immediate sub class
and so on. If super is not used in the sub class constructors, then the default constructor of super class
will be called.
class A
{
A()
{
System.out.println("A's constructor.");
}
}
class B extends A
{
B()
{
System.out.println("B's constructor.");
}
}
68
SUIET 2022-23 21SCS34
class C extends B
{
C()
{
System.out.println("C's constructor.");
}
}
class CallingCons
{
{
C c = new C();
}
}
Output:
A's constructor
B's constructor
C's constructor
Method Overriding
In a class hierarchy, when a method in a subclass has the same name and type signature as a method in its
superclass, then the method in the subclass is said to override the method in the superclass. When an
overridden method is called from within a subclass, it will always refer to the version of that method defined by
the subclass. The version of the method defined by the superclass will be hidden.
class A
{
int i, j;
A(int a, int b)
{
i = a;
j = b;
}
void show() //suppressed
{
System.out.println("i and j: " + i + " " + j);
}
}
class B extends A
{
int k;
B(int a, int b, int c)
{
super(a, b);
69
SUIET 2022-23 21SCS34
k = c;
}
void show() //Overridden method
{
}
}
class Override
{
{
B subOb = new B(1, 2, 3);
subOb.show();
}
}
Output:
k: 3
Note that, above program, only subclass method show() got called and hence only k got displayed. That
is, the show() method of super class is suppressed. If we want superclass method also to be called, we
can re-write the show() method in subclass as –
void show()
{
super.show(); // this calls A's show()
}
Method overriding occurs only when the names and the type signatures of the two methods (one in superclass
and the other in subclass) are identical. If two methods (one in superclass and the other in subclass) have same
name, but different signature, then the two methods are simply overloaded.
Dynamic Method Dispatch

Method overriding forms the basis for one of Java’s most powerful concepts: dynamic method dispatch.
Dynamic method dispatch is the mechanism by which a call to an overridden method is resolved at run time,
rather than compile time. Java implements run-time polymorphism using dynamic method dispatch.
We know that, a superclass reference variable can refer to subclass object. Using this fact, Java resolves the
calls to overridden methods during runtime. When an overridden method is called through a superclass
reference, Java determines which version of that method to execute based upon the type of the object being
referred to at the time the call occurs. Thus, this determination is made at run time.
When different types of objects are referred to, different versions of an overridden method will be called.
In other words, it is the type of the object being referred to (not the type of the reference variable) that
determines which version of an overridden method will be executed. Therefore, if a superclass contains a
method that is overridden by a subclass, then when different types of objects are referred to through superclass
reference variable, different versions of the method are executed.
70
SUIET 2022-23 21SCS34
class A
{
void callme()
{
System.out.println("Inside A");
}
}
class B extends A
{
void callme()
{
System.out.println("Inside B");
}
}
class C extends A
{
void callme()
{
System.out.println("Inside C");
}
}
class Dispatch
{
{
A a = new A();
B b = new B();
C c = new C();
A r; //Superclass reference
r = a; //holding subclass object
r.callme();
r = b;
r.callme();
r = c;
r.callme();
}
}
Why overridden methods?

Overridden methods are the way that Java implements the “one interface, multiple methods” aspect of
polymorphism. Super classes and subclasses form a hierarchy which moves from lesser to greater
specialization. Used correctly, the superclass provides all elements that a subclass can use directly. It also
defines those methods that the derived class must implement on its own. This allows the subclass the flexibility
to define its own methods, yet still enforces a consistent interface. Thus, by combining inheritance with
71
SUIET 2022-23 21SCS34
overridden methods, a superclass can define the general form of the methods that will be used by all of its
subclasses. Dynamic, run-time polymorphism is one of the most powerful mechanisms that object-oriented
design brings to bear on code reuse and robustness.
Using Abstract Classes

Sometimes, the method definition will not be having any meaning in superclass. Only the subclass
(specialization) may give proper meaning for such methods. In such a situation, having a definition for a
method in superclass is absurd. Also, we should enforce the subclass to override such a method. A method
which does not contain any definition in the superclass is termed as abstract method. Such a method
declaration should be preceded by the keyword abstract. These methods are sometimes referred to as sub
classer responsibility because they have no implementation specified in the superclass.
A class containing at least one abstract method is called as abstract class. Abstract classes cannot be
instantiated, that is one cannot create an object of abstract class. Whereas, a reference can be created for an
abstract class.
abstract class A
{
abstract void callme();
void callmetoo()
{
System.out.println("This is a concrete method.");
}
}
class B extends A
{
void callme() //overriding abstract method
{
System.out.println("B's implementation of callme.");
}
}
class AbstractDemo
{
{
B b = new B(); //subclass object
b.callme(); //calling abstract method
b.callmetoo(); //calling concrete meth
}
}
Example: Write an abstract class shape, which has an abstract method area(). Derive three classes
Triangle, Rectangle and Circle from the shape class and to override area(). Implement run-time
polymorphism by creating array of references to superclass. Compute area of different shapes and display the
same.
72
SUIET 2022-23 21SCS34
Solution:
abstract class Shape
{
final double PI= 3.1416;
abstract double area();
}
class Triangle extends Shape

{
int b, h;
Triangle(int x, int y) //constructor
{
b=x;
h=y;
}
double area() //method overriding

{
System.out.print("\nArea of Triangle is:");
return 0.5*b*h;
}
}
class Circle extends Shape

{
int r;
Circle(int rad) //constructor
{
r=rad;
}
double area() //overriding
{
System.out.print("\nArea of Circle is:");
return PI*r*r;
}
}
class Rectangle extends Shape

{
int a, b;
Rectangle(int x, int y) //constructor
{
a=x;
b=y;
}
double area() //overriding

{
73
SUIET 2022-23 21SCS34
System.out.print("\nArea of Rectangle is:");
return a*b;
}
}
class AbstractDemo
{
{
Shape r[]={new Triangle(3,4), new Rectangle(5,6),new Circle(2)};
for(int i=0;i<3;i++)
System.out.println(r[i].area());
}
}
Output:
Area of Triangle is:6.0
Area of Rectangle is:30.0
Area of Circle is:12.5664
Note that, here we have created array r, which is reference to Shape class. But, every element in r is holding
objects of different subclasses. That is, r[0] holds Triangle class object, r[1] holds Rectangle class object and so
on. With the help of array initialization, we are achieving this, and also, we are calling respective constructors.
Later, we use a for-loop to invoke the method area() defined in each of these classes.
Using final
The keyword final can be used in three situations in Java:
1. To create the equivalent of a named constant.
2. To prevent method overriding
3. To prevent Inheritance
To create the equivalent of a named constant: A variable can be declared as final. Doing so prevents
its contents from being modified. This means that you must initialize a final variable when it is declared.
For example:
final int FILE_NEW = 1;
final int FILE_OPEN = 2;
final int FILE_SAVE = 3;
final int FILE_SAVEAS = 4;
final int FILE_QUIT = 5;
It is a common coding convention to choose all uppercase identifiers for final variables. Variables
declared as final do not occupy memory on a per-instance basis. Thus, a final variable is essentially a
constant.
To prevent method overriding: Sometimes, we do not want a superclass method to be overridden in

the subclass. Instead, the same superclass method definition has to be used by every subclass. In such
situation, we can prefix a method with the keyword final as shown below –
class A
74
SUIET 2022-23 21SCS34
{
final void meth()
{
System.out.println("This is a final method.");
}
}
class B extends A
{
void meth() // ERROR! Can't override.
{
System.out.println("Illegal!");
}
}
To prevent Inheritance: As we have discussed earlier, the subclass is treated as a specialized class and
superclass is most generalized class. During multi-level inheritance, the bottom most class will be with all the
features of real-time and hence it should not be inherited further. In such situations, we can prevent a particular
class from inheriting further, using the keyword final. For example –
final class A
{
// ...
}
class B extends A // ERROR! Can't subclass A

{
// ...
}
Note:
 Declaring a class as final implicitly declares all of its methods as final, too.
 It is illegal to declare a class as both abstract and final since an abstract class is incomplete by itself and
relies upon its subclasses to provide complete implementations
The Object Class

There is one special class, Object, defined by Java. All other classes are subclasses of Object. That is,
Object is a superclass of all other classes. This means that a reference variable of type Object can refer to an
object of any other class. Also, since arrays are implemented as classes, a variable of type Object can also refer
to any array. Object defines the following methods, which means that they are available in every object.
Method Purpose
Object clone( ) Creates a new object that is the same as the object being cloned.
boolean equals(Object object) Determines whether one object is equal to another.
void finalize( ) Called before an unused object is recycled.
Class getClass( ) Obtains the class of an object at run time.
int hashCode( ) Returns the hash code associated with the invoking object.
75
SUIET 2022-23 21SCS34
void notify( ) Resumes execution of a thread waiting on the invoking object.
void notifyAll( ) Resumes execution of all threads waiting on the invoking object.
String toString( ) Returns a string that describes the object.
void wait( )
void wait(long milliseconds)
void wait(long milliseconds,
int nanoseconds)
Waits on another thread of execution.
The methods getClass( ), notify( ), notifyAll( ), and wait( ) are declared as final. You may override
the others. The equals( ) method compares the contents of two objects. It returns true if the objects
are equivalent, and false otherwise. The precise definition of equality can vary, depending on the
type of objects being compared. The toString( ) method returns a string that contains a description of
the object on which it is called. Also, this method is automatically called when an object is output
using println( ). Many classes override this method.
MODULE IV
Packages
When we have more than one class in our program, usually we give unique names to classes. In a real- time
development, as the number of classes increases, giving unique meaningful name for each class will be a
problem. To avoid name-collision in such situations, Java provides a concept of packages. A package is a
collection of classes. The package is both a naming and a visibility control mechanism. You can define classes
inside a package that are not accessible by code outside that package. You can also define class members that
are only exposed to other members of the same package. This allows your classes to have intimate knowledge
of each other, but not expose that knowledge to the rest of the world.
76
SUIET 2022-23 21SCS34
Defining a Package
To create a package, include a package command as the first statement in a Java source file. Any class declared
within that file will belong to the specified package. If you omit the package statement, the class names are put
into the default package, which has no name.
General form of the package statement:

package pkg;
Example –
package MyPackage;
Java uses file system directories to store packages. For example, the .class file for any class you declare to be
part of MyPackage must be stored in a directory called MyPackage. Remember that case is significant, and the
directory name must match the package name exactly. More than one file can include the same package
statement. The package statement simply specifies to which package the classes defined in a file belong. It does
not exclude other class in other files from being part of that same package.
One can create a hierarchy of packages. To do so, simply separate each package name from the one above it by
use of a period. The general form of a multileveled package statement is shown here:
package pkg1[.pkg2[.pkg3]];
A package hierarchy must be reflected in the file system of your Java development system. For example, a
package declared as package java.awt.image; needs to be stored in java\awt\image in a Windows environment.
You cannot rename a package without renaming the directory in which the classes are stored.
Finding Packages and CLASSPATH

As we have seen, packages are reflected with directories. This will raise the question that - how does Java run-
time know where to look for the packages that we create?
 By default, Java run-time uses current working directory as a starting point. So, if our packageis in
sub-directory of current working directory, then it will be found.
 We can set directory path using CLASSPATH environment variable.
 We can use –classpath option with javac and java to specify path of our classes.
Assume that we have created a package MyPackage. When the second two options are used, the class path
must not include MyPackage. It must simply specify the path to MyPackage. For example, in a Windows
environment, if the path to MyPackage is
C:\MyPrograms\Java\MyPackage
Then the class path to MyPackage is

C:\MyPrograms\JavaConsider the program given below –
package MyPackage;
class Test
{
int a, b; Test(int x, int y)
{
77
SUIET 2022-23 21SCS34
a=x; b=y;
}
void disp()
{
System.out.println("a= "+a+" b= "+b);
}
}
class PackDemo
{
{
Test t=new Test(2,3);t.disp();
}
}
Access Protection
Java provides many levels of protection to allow fine-grained control over the visibility of variables and
methods within classes, subclasses, and packages. Classes and packages are both means of encapsulating and
containing the name space and scope of variables and methods. Packages act as containers for classes and other
subordinate packages. Classes act as containers for data and code. The class is Java’s smallest unit of
abstraction.
Java addresses four categories of visibility for class members:

 Subclasses in the same package
 Non-subclasses in the same package
 Subclasses in different packages
 Classes that are neither in the same package nor subclasses
Even a class has accessibility feature. A class can be kept as default or can be declared as public. When a class
is declared as public, it is accessible by any other code. If a class has default access, then it can only be
accessed by other code within its same package. When a class is public, it must be the only public class
declared in the file, and the file must have the same name as the class.
Accessibility of members of the class can be better understood using the following table.
Priv No Protecte Public

ate Modifier d
Same class Yes Yes Yes Yes
Same package No Yes Yes Yes
subclass
Same package No Yes Yes Yes
non-subclass
78
SUIET 2022-23 21SCS34
Different No No Yes Yes
packageSubclass
Different No No No Yes
packagenon-
subclass
Importing Packages
Since classes within packages must be fully qualified with their package name or names, it could become
tedious to type in the long dot-separated package path name for every class you want to use. For this reason,
Java includes the import statement to bring certain classes, or entire packages, into visibility. Once imported, a
class can be referred to directly, using only its name.
In a Java source file, import statements occur immediately following the package statement (if it exists) and
before any class definitions. The general form of the import statement is:
import pkg1[.pkg2].(classname|*);
For
example, import java.util.Date;import java.io.*;
The star form may increase compilation time—especially if you import several large packages. For this reason
it is a good idea to explicitly name the classes that you want to use rather than importing whole packages.
However, the star form has absolutely no effect on the run-time performance or size of your classes.
All of the standard Java classes included with Java are stored in a package called java. The basic language
functions are stored in a package inside of the java package called java.lang. Normally, you have to import
every package or class that you want to use, but since Java is useless without much of the functionality in
java.lang, it is implicitly imported by the compiler for all programs. This is equivalent to the following line
being at the top of all of your programs:
import java.lang.*;
If a class with the same name exists in two different packages that you import using the star form, the compiler
will remain silent, unless you try to use one of the classes. In that case, you will get a compile- time error and
have to explicitly name the class specifying its package.
The import statement is optional. Any place you use a class name, you can use its fully qualified name, which
includes its full package hierarchy. For example,
import java.util.*; class MyDate extends Date

{ ……………}
Can be written as –
class MyDate extends java.util.Date
{ …}
Interfaces
Interface is an abstract type that can contain only the declarations of methods and constants. Interfaces are
syntactically similar to classes, but they do not contain instance variables, and their methods are declared
79
SUIET 2022-23 21SCS34
without any body. Any number of classes can implement an interface. One class may implement many
interfaces. By providing the interface keyword, Java allows you to fully utilize the “one interface, multiple
methods” aspect of polymorphism. Interfaces are alternative means for multiple inheritance in Java.
Defining an Interface
An interface is defined much like a class. This is the general form of an interface:
access interface name

{
type final-varname1 = value;type final-varname2 = value;
…………………
return-type method-name1(parameter-list);return-type method-name2(parameter-list);
…………………
}
Few key-points about interface:

 When no access specifier is mentioned for an interface, then it is treated as default and the interface is only
available to other members of the package in which it is declared. When an interface is declared as public,
the interface can be used by any other code.
 All the methods declared are abstract methods and hence are not defined inside interface. But, a class
implementing an interface should define all the methods declared inside the interface.
 Variables declared inside of interface are implicitly final and static, meaning they cannot be changed by
the implementing class.
 All the variables declared inside the interface must be initialized.
 All methods and variables are implicitly public.
Implementing Interface
To implement an interface, include the implements clause in a class definition, and then create the methods
defined by the interface. The general form of a class that includes the implements clause looks like this:
class classname extends superclass implements interface1, interface2...

{
// class-body
}
Consider the following example:
interface ICallback
{
void callback(int param);
}
class Client implements ICallback

{
public void callback(int p) //note public
{
System.out.println("callback called with " + p);
80
SUIET 2022-23 21SCS34
}
void test()
{
System.out.println(“ordinary method”);
}
}
class TestIface
{
{
ICallback c = new Client();c.callback(42);
// c.test() //error!!
}
}
Here, the interface ICallback contains declaration of one method callback(). The class Client implementing
this interface is defining the method declared in interface. Note that, the method callback() is public by default
inside the interface. But, the keyword public must be used while defining it inside the class. Also, the class has
its own method test(). In the main() method, we are creating a reference of
interface pointing to object of Client class. Through this reference, we can call interface method, but not
method of the class.
The true polymorphic nature of interfaces can be found from the following example –
interface ICallback
{
void callback(int param);
}
class Client implements ICallback

{
public void callback(int p) //note public
{
System.out.println("callback called with " + p);
}
}
class Client2 implements ICallback

{
public void callback(int p)
{
System.out.println("Another version of ICallBack");System.out.println("p squared " + p*p);
}
}
81
SUIET 2022-23 21SCS34
class TestIface
{
{
ICallback x[]={new Client(), new Client2()};
for(int i=0;i<2;i++) x[i].callback(5);

}
}
Output:
callback called with 5 Another version of ICallBack p squared 25
In this program, we have created array of references to interface, but they are initialized to class objects.Using
the array index, we call respective implementation of callback() method.
Note: Interfaces may look similar to abstract classes. But, there are lot of differences between them as shown
in the following table:
Abstract Class Interface

Can have instance methods that Are implicitly abstract and cannot
implementsa default behavior. have implementations.
May contain non-final variables. Variables i interface b

declareddefault n are y
final.
Can have mem w priv Members of a Java interface are public
the bers i ate, bydefault.
protected, t
etc.. h
A Java abstract class should be Java interface should be implemented
extendedusing keyword “extends”. using keyword “implements”
An abstract class can extend another Java An interface can extend another Java
class and implement multiple Java interface only.
interfaces.
Not slow Compared to abstract classes,

interfacesare slow as it requires extra
indirection.
Variables in Interfaces
You can use interfaces to import shared constants into multiple classes by simply declaring an interface that
contains variables that are initialized to the desired values. When you include that interface in a class all of those
variable names will be in scope as constants (Similar to #define in C/C++). If an interface contains no methods,
then any class that includes such an interface doesn’t actually implement anything. It is just using a set of
constants. Consider an example to illustrate the same:
interface SharedConst
82
SUIET 2022-23 21SCS34
{
int FAIL=0; //these are final by default int PASS=1;
}
class Result implements SharedConst

{
double mr;
Result(double m)
{
mr=m;
}
int res()
{
if(mr<40)
return FAIL;else return PASS;
}
}
class Exam extends Result implements SharedConst
{
Exam(double m)
{
super(m);
}
{
Exam r = new Exam(56);
switch(r.res())
{
case FAIL:
System.out.println("Fail");break;
case PASS:
System.out.println("Pass");break;
}
}
}
Interfaces can be extended

One interface can inherit another interface by using the keyword extends. The syntax is the same as for
inheriting classes. When a class implements an interface that inherits another interface, it must provide
implementations for all methods defined within the interface inheritance chain.
interface A
{
void meth1();void meth2();
}
83
SUIET 2022-23 21SCS34
interface B extends A
{
void meth3();
}
class MyClass implements B

{
public void meth1()
{
System.out.println("Implement meth1().");
}
public void meth2()

{
}
public void meth3()
{
}
}
class IFExtend
{
public static void main(String arg[])
{
MyClass ob = new MyClass();ob.meth1();
ob.meth2();
ob.meth3();
}
}
Exception Handling
An exception is an abnormal condition that arises in a code sequence at run time. In other words, an exception
is a run-time error. In computer languages that do not support exception handling, errors must be checked and
handled manually—typically through the use of error codes. This approach is as cumbersome as it is
troublesome. Java’s exception handling avoids these problems and, in the process, brings run-time error
management into the object oriented world.
Exception Handling Fundamentals

A Java exception is an object that describes an exceptional (that is, error) condition that has occurred in a
piece of code. When an exceptional condition arises, an object representing that exception is created and
thrown in the method that caused the error. That method may choose to handle the exception itself, or pass it
on. Either way, at some point, the exception is caught and processed.
Exceptions can be generated by the Java run-time system, or they can be manually generated by your code.
Exceptions thrown by Java relate to fundamental errors that violate the rules of the Java language or the
84
SUIET 2022-23 21SCS34
constraints of the Java execution environment. Manually generated exceptions are typically used to report
some error condition to the caller of a method.
Java exception handling is managed using five keywords:

 try: A suspected code segment is kept inside try block.
 catch: The remedy is written within catch block.
 throw: Whenever run-time error occurs, the code must throw an exception.
 throws: If a method cannot handle any exception by its own and some subsequent methodsneeds to
handle them, then a method can be specified with throws keyword with its declaration.
 finally: block should contain the code to be executed after finishing try-block.
The general form of exception handling is –
try
{
// block of code to monitor errors

catch (ExceptionType1 exOb)
{
// exception handler for ExceptionType1
}
catch (ExceptionType2 exOb)
{
// exception handler for ExceptionType2

}
...
….
finally
{
// block of code to be executed after try block ends
}
Exception Types
All the exceptions are the derived classes of built-in class viz. Throwable. It has two subclasses viz.
Exception and Error.
Throwable
Exception Error
85
Customized Exception
RuntimeException Customized Exception
(User defined class to
(Automatically defined (User defined class to
handle own exception)
for programs) handle own exception)
SUIET 2022-23 21SCS34
Exception class is used for exceptional conditions that user programs should catch. We can inherit from this
class to create our own custom exception types. There is an 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.
Error class defines exceptions that are not expected to be caught under normal circumstances by our 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. Stack overflow is an example of such an error.
Uncaught Exceptions
Let us see, what happens if we do not handle exceptions.
class Exc0
{
{
int d = 0;
int a = 42 / d;
}
}
When the Java run-time system detects the attempt to divide by zero, it constructs a new exception object and
then throws this exception. This causes the execution of Exc0 to stop, because once an exception has been
thrown, it must be caught by an exception handler and dealt with immediately.
Since, in the above program, we have not supplied any exception handlers of our own, so the exception is
caught by the default handler provided by the Java run-time system.
Any un-caught exception is handled by default handler. The default handler displays a string describing the
exception, prints a stack trace from the point at which the exception occurred, and terminates the program. Here
is the exception generated when above example is executed:
java.lang.ArithmeticException: / by zero at Exc0.main(Exc0.java:6)
The stack trace displays class name, method name, file name and line number causing the exception. Also, the
type of exception thrown viz. ArithmeticException which is the subclass of Exception is displayed. The type of
exception gives more information about what type of error has occurred. The stack trace will always show the
sequence of method invocations that led up to the error.
class Exc1
{
static void subroutine()
{
int d = 0;
int a = 10 / d;
}
{
86
SUIET 2022-23 21SCS34
Exc1.subroutine();
}
}
The resulting stack trace from the default exception handler shows how the entire call stack is displayed:
java.lang.ArithmeticException: / by zero at Exc1.subroutine(Exc1.java:6)
at Exc1.main(Exc1.java:10)
Using try and catch

Handling the exception by our own is very much essential as
 We can display appropriate error message instead of allowing Java run-time to display stack-trace.
 It prevents the program from automatic (or abnormal) termination.
To handle run-time error, we need to enclose the suspected code within try block.
class Exc2
{
{
int d, a;
try
{
d = 0;
a = 42 / d;
System.out.println("This will not be printed.");
} catch (ArithmeticException e)
{
System.out.println("Division by zero.");
}
System.out.println("After catch statement.");
}
}
Output:
Division by zero. After catch statement.
The goal of most well-constructed catch clauses should be to resolve the exceptional condition and then
continue on as if the error had never happened.
import java.util.Random;class HandleError

{
{
int a=0, b=0, c=0; Random r = new Random();
for(int i=0; i<10; i++)

87
SUIET 2022-23 21SCS34
{
try
{
b=r.nextInt().
c = r.nextInt();
a = 12345 / (b/c);
a = 12345 / (b/c);
} catch (ArithmeticException e)
{
System.out.println("Division by zero.");a = 0;
}
System.out.println("a: " + a);
}
}
}
The output of above program is not predictable exactly, as we are generating random numbers. But, the loop
will execute 10 times. In each iteration, two random numbers (b and c) will be generated. When their division
results in zero, then exception will be caught. Even after exception, loop will continue to execute.
Displaying a Description of an Exception: We can display this description in a println() statement by simply
passing the exception as an argument. This is possible because Throwable overrides the toString() method
(defined by Object) so that it returns a string containing a description of the exception.
catch (ArithmeticException e)
{
System.out.println("Exception: " + e);
a = 0;
}
Now, whenever exception occurs, the output will be –

Exception: java.lang.ArithmeticException: / by zero
Multiple Catch Claues

In some cases, more than one exception could be raised by a single piece of code. To handle this type of
situation, you can specify two or more catch clauses, each catching a different type of exception. When an
exception is thrown, each catch statement is inspected in order, and the first one whose type matches that of the
exception is executed. After one catch statement executes, the others are bypassed, and execution continues
after the try/catch block.
class MultiCatch
{
{
88
SUIET 2022-23 21SCS34
try
{
int a = args.length; System.out.println("a = " + a);
int b = 42 / a;
int c[] = { 1 };
c[42] = 99;
}
catch(ArithmeticException e)
{
System.out.println("Divide by 0: " + e);
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Array index oob: " + e);
}
System.out.println("After try/catch blocks.");
}
}
Here is the output generated by running it both ways:

C:\>java MultiCatcha = 0
Divide by 0: java.lang.ArithmeticException: / by zeroAfter try/catch blocks.
C:\>java MultiCatch TestArg a = 1

Array index oob: java.lang.ArrayIndexOutOfBoundsException:42 After try/catch blocks
While using multiple catch blocks, we should give the exception types in a hierarchy of subclass to superclass.
Because, catch statement that uses a superclass will catch all exceptions of its own type plus all that of its
subclasses. Hence, the subclass exception given after superclass exception is never caught and is a unreachable
code, that is an error in Java.
class SuperSubCatch
{
{
try
{
int a = 0;
int b = 42 / a;
} catch(Exception e)
{
System.out.println("Generic Exception catch.");
}
catch(ArithmeticException e) // ERROR - unreachable
{
System.out.println("This is never reached.");
}
}
}
89
SUIET 2022-23 21SCS34
The above program generates error “Unreachable Code”, because ArithmeticException is a subclass of
Exception.
Nested try Statements

The try statement can be nested. That is, a try statement can be inside the block of another try. Each time a
try statement is entered, the context of that exception is pushed on the stack. If an inner try statement does not
have a catch handler for a particular exception, the stack is unwound and the next try statement’s catch handlers
are inspected for a match. This continues until one of the catch statements succeeds, or until all the nested try
statements are exhausted. If no catch statement matches, then the Java run-time system will handle the
exception.
class NestTry
{
{
try
{
int a = args.length;int b = 42 / a;
System.out.println("a = " + a);
try
{
if(a==1)
a = a/(a-a);
if(a==2) int c[] = { 1 };c[10] = 99;
{
}
}catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Array index out-of-bounds: " + e);
}
}catch(ArithmeticException e)
{
}
}
}
When a method is enclosed within a try block, and a method itself contains a try block, it is considered tobe a
nested try block.
class MethNestTry
{ static void nesttry(int a)
{ try
{
90
SUIET 2022-23 21SCS34
if(a==1)
a = a/(a-a);if(a==2)
{
int c[] = { 1 };c[42] = 99;
}
}catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Array index out-of-bounds: " + e);
}
}

{
try
{
int a = args.length;int b = 42 / a;
System.out.println("a = " + a);nesttry(a);
} catch(ArithmeticException e)
{
}
}
} catch(ArithmeticException e)
{
}
}
}
throw
Till now, we have seen catching the exceptions that are thrown by the Java run-time system. It is possible for
your program to throw an exception explicitly, using the throw statement. The general form of throw is shown
here:
throw ThrowableInstance;
Here, ThrowableInstance must be an object of type Throwable or a subclass of Throwable. Primitive types,
such as int or char, as well as non-Throwable classes, such as String and Object, cannot be used as
exceptions.
There are two ways you can obtain a Throwable object:

using a parameter in a catch clause, or
creating one with the new operator.
class ThrowDemo
{
static void demoproc()
{
try
{
throw new NullPointerException("demo");
91
SUIET 2022-23 21SCS34
} catch(NullPointerException e)
{
System.out.println("Caught inside demoproc: " + e);
}
}

{
demoproc();
}
}
Here, new is used to construct an instance of NullPointerException. Many of Java’s built-in run-time
exceptions have at least two constructors:
one with no parameter and
one that takes a string parameter
When the second form is used, the argument specifies a string that describes the exception. This string is
displayed when the object is used as an argument to print() or println(). It can also be obtained by a call to
getMessage(), which is defined by Throwable.
throws
If a method is capable of causing an exception that it does not handle, it must specify this behavior so that
callers of the method can guard themselves against that exception. You do this by including a throws clause in
the method’s declaration. A throws clause lists the types of exceptions that a method might throw. This is
necessary for all exceptions, except those of type Error or RuntimeException, or any of their subclasses. All
other exceptions that a method can throw must be declared in the throws clause. If they are not, a compile-time
error will result.
The general form of a method declaration that includes a throws clause:

type method-name(parameter-list) throws exception-list
{
// body of method
}
Here, exception-list is a comma-separated list of the exceptions that a method can throw.
class ThrowsDemo
{
static void throwOne() throws IllegalAccessException
{
System.out.println("Inside throwOne."); throw new IllegalAccessException("demo");
}
{
try
92
SUIET 2022-23 21SCS34
{
throwOne();
} catch (IllegalAccessException e)
{
System.out.println("Caught " + e);
}
}
}
finally
When exceptions are thrown, execution in a method takes a rather abrupt, nonlinear path that alters the normal
flow through the method. Sometimes it is even possible for an exception to cause the method to return
prematurely. This could be a problem in some methods. For example, if a method opens a file upon entry and
closes it upon exit, then you will not want the code that closes the file to be bypassed by the exception-handling
mechanism. The finally keyword is designed to address such situations.
The finally clause creates a block of code that will be executed after a try/catch block has completed and
before the next code of try/catch block. The finally block will execute whether or not an exception is thrown.
If an exception is thrown, the finally block will execute even if no catch statement matches the exception. Any
time a method is about to return to the caller from inside a try/catch block, via an uncaught exception or an
explicit return statement, the finally clause is also executed just before the method returns. The finally clause is
optional. However, each try statement requires at least one catch or a finally clause.
class FinallyDemo
{
static void procA()
{
try
{
System.out.println("inside procA"); throw new RuntimeException("demo");

} finally
{
}
}
System.out.ptintln("procA's finally");
static void procB()
{
try
{
} finally
93
SUIET 2022-23 21SCS34
{
}
}
System.out.println("inside procB");return;
System.out.println("procB's finally");
}
}
System.out.println("inside procC"); System.out.println("procC's static void procC()

{ try
{
finally");
} finally
{
}
}

{
try
{
procA();
} catch (Exception e)
{
System.out.println("Exception caught");
}
procB();
procC();
}
}
Output:
inside procA procA’s finally Exception caught inside procB procB’s finally inside procC procC’s finally
94
Java’s Built-in Exceptions
Inside the standard package java.lang, Java defines several exception classes. The most general of these
exceptions are subclasses of the standard type RuntimeException. These exceptions need not be included in
any method’s throws list. Such exceptions are called as unchecked exceptions because the compiler does not
check to see if a method handles or throws these exceptions. Java.lang defines few checked exceptions which
needs to be listed out by a method using throws list if that method generate one of these exceptions and does
not handle it itself. Java defines several other types of exceptions that relate to its various class libraries.
Table: Java’s Unchecked Exceptions

Exception Meaning
ArithmeticException Arithmetic error, such as divide-by-zero.
ArrayIndexOutOfBoundsExcepti Array index is out-of-bounds.
on
ArrayStoreException Assignment to an array element of an incompatible
type.
ClassCastException Invalid cast.
EnumConstantNotPresentExcept An attempt is made to use an undefined enumeration
ion value.
IllegalArgumentException Illegal argument used to invoke a method.
IllegalMonitorStateException Illegal monitor operation, such as waiting on an

unlockedthread.
IllegalStateException Environment or application is in incorrect state.
IllegalThreadStateException Requested operation not compatible with current

threadstate.
IndexOutOfBoundsException Some type of index is out-of-bounds.
NegativeArraySizeException Array created with a negative size.
NullPointerException Invalid use of a null reference.

NumberFormatException Invalid conversion of a string to a numeric format.
SecurityException Attempt to violate security.
StringIndexOutOfBounds Attempt to index outside the bounds of a string.
TypeNotPresentException Type not found.

UnsupportedOperationException An unsupported operation was encountered.
Table: Java’s Checked Exceptions
Exception Meaning
ClassNotFoundException Class not found.
CloneNotSupportedExcept Attempt to clone an object that does not implement the
ion
Cloneable interface.
IllegalAccessException Access to a class is denied.
InstantiationException Attempt to create an object of an abstract class or interface.
InterruptedException One thread has been interrupted by another thread.

NoSuchFieldException A requested field does not exist.
NoSuchMethodException A requested method does not exist.
Creating your own Exception Subclasses

Although Java’s built-in exceptions handle most common errors, sometimes we may want to create our own
exception types to handle situations specific to our applications. This is achieved by defining a subclass of
Exception class. Your subclasses don’t need to actually implement anything—it is their existence in the type
system that allows you to use them as exceptions. The Exception class does not define any methods of its own.
It inherits those methods provided by Throwable. Thus, all exceptions, including those that you create, have
the methods defined by Throwable available to them.
Method Description
Throwable fillInStackTrace( ) Returns a Throwable object that contains a completed
stack trace. This object can be re-thrown.
Throwable getCause( ) Returns the exception that underlies the current
exception. If there is no underlying exception, null is
returned.
String getLocalizedMessage( ) Returns a localized description of the exception.
String getMessage() Returns a description of the exception.
StackTraceElement[] Returns an array that contains the stack trace, one
getStackTrace() element at a time, as an array of StackTraceElement.
The method at the top of the stack is the last method
called before the exception was thrown. This method is
found in the first element of the array. The
StackTraceElement class gives your program access to
information about each element in the trace, such as its
method name.
Throwable initCause(Throwable Associates causeExc with the invoking exception as a
causeExc) cause of the invoking exception. Returns a reference to
the exception.
void printStackTrace( ) Displays the stack trace.
We may wish to override one or more of these methods in exception classes that we create. Two of the
constructors of Exception are:
Exception( ) Exception(String msg)
Though specifying a description when an exception is created is often useful, sometimes it is better to override
toString( ). The version of toString( ) defined by Throwable (and inherited by Exception) first displays the
name of the exception followed by a colon, which is then followed by your description. By overriding
toString( ), you can prevent the exception name and colon from being displayed. This makes for a cleaner
output, which is desirable in some cases.
class MyException extends Exception
{
int marks;
MyException (int m)
{
marks=m;
}
public String toString()

{
return "MyException: Marks cannot be Negative";
}
}
class CustExceptionDemo
{
static void test(int m) throws MyException
{
System.out.println("Called test(): "+m);if(m<0)
throw new MyException(m);
System.out.println("Normal exit");
}
{
try{
test(45);
test(-2);
}
catch (MyException e)
{
System.out.println("Caught " + e);
}
}
}
Chained Exceptions
The concept of chained exception allows you to associate another exception with an exception. This second
exception describes the cause of the first exception. For example, imagine a situation in which a method throws
an ArithmeticException because of an attempt to divide by zero. However, the actual cause of the problem was
that an I/O error occurred, which caused the divisor to be set improperly. Although the method must certainly
throw an ArithmeticException, since that is the error that occurred, you might also want to let the calling code
know that the underlying cause was an I/O error. Chained exceptions let you handle this, and any other
situation in which layers of exceptions exist.
To allow chained exceptions, two constructors and two methods were added to Throwable. The constructors
are shown here:
Throwable(Throwable causeExc)
Throwable(String msg, Throwable causeExc)
In the first form, causeExc is the exception that causes the current exception. That is, causeExc is the
underlying reason that an exception occurred. The second form allows you to specify a description at the same
time that you specify a cause exception. These two constructors have also been added to the Error, Exception,
and RuntimeException classes.
Chained exceptions can be carried on to whatever depth is necessary. Thus, the cause exception can, itself, have
a cause. Be aware that overly long chains of exceptions may indicate poor design. Chained exceptions are not
something that every program will need. However, in cases in which knowledge of an underlying cause is
useful, they offer an elegant solution.
Using Exceptions
Exception handling provides a powerful mechanism for controlling complex programs that have many dynamic
run-time characteristics. It is important to think of try, throw, and catch as clean ways to handle errors and
unusual boundary conditions in your program’s logic. Unlike some other languages in which error return codes
are used to indicate failure, Java uses exceptions. Thus, when a method can fail, have it throw an exception.
This is a cleaner way to handle failure modes.
Note that Java’s exception-handling statements should not be considered a general mechanism for
nonlocal branching. If you do so, it will only confuse your code and make it hard to maintain.
MODULE V
Enumerations
An enumeration is a list of named constants. In Java, enumerations define class types. That is, in Java,
enumerations can have constructors, methods and variables. An enumeration is created using the keyword
enum. Following is an example –
enum Person
{
Married, Unmarried, Divorced, Widowed
}
The identifiers like Married, Unmarried etc. are called as enumeration Constants. Each such constant is
implicitly considered as a public static final member of Person.
After defining enumeration, we can create a variable of that type. Though enumeration is a class type, we need
not use new keyword for variable creation, rather we can declare it just like any primitive data type. For
example,
Person p= Person.Married;
We can use == operator for comparing two enumeration variables. They can be used in switch-case
also. Printing an enumeration variable will print the constant name. That is,
System.out.println(p); // prints as Married
Consider the following program to illustrate working of enumerations:
enum Person
{
}
class EnumDemo
{
{
Person p1;
p1=Person.Unmarried; System.out.println("Value of p1 :" + p1);
Person p2= Person.Widowed;if(p1==p2)

System.out.println("p1 and p2 are same");
else
System.out.println("p1 and p2 are different");
switch(p1)
{
case Married: System.out.println("p1 is Married");break;
case Unmarried: System.out.println("p1 is Unmarried");
break;
case Divorced: System.out.println("p1 is Divorced");break;
case Widowed: System.out.println("p1 is Widowed");
break;
}
}
}
The values() and valueOf() Methods

All enumerations contain two predefined methods: values() and valueOf(). Their general forms are shown here:
public static enum-type[] values()
public static enum-type valueOf(String str)
The values() method returns an array of enumeration constants. The valueOf() method returns theenumeration
constant whose value corresponds to the string passed in str.
enum Person
{
}
class EnumDemo
{ public static void main(String args[])
{ Person p;
System.out.println("Following are Person constants:");Person all[]=Person.values();
for(Person p1:all)
System.out.println(p1);
p=Person.valueOf("Married"); System.out.println("p contains "+p);

}
}
Output:
Following are Person constants:
Married UnmarriedDivorced Widowed
p contains Married
Java Enumerations are Class Types

Java enumeration is a class type. That is, we can write constructors, add instance variables and methods, and
even implement interfaces. It is important to understand that each enumeration constant is an object of its
enumeration type. Thus, when you define a constructor for an enum, the constructor is called when each
enumeration constant is created. Also, each enumeration constant has its own copy of any instance variables
defined by the enumeration.
enum Apple
{
Jonathan(10), GoldenDel(9), RedDel(12), Winesap(15), Cortland(8);private int price;
Apple(int p)
{
price = p;
}
int getPrice()
{
return price;
}
}
class EnumDemo
{
{
Apple ap;
System.out.println("Winesap costs " + Apple.Winesap.getPrice());System.out.println("All apple prices:");
for(Apple a : Apple.values())
System.out.println(a + " costs " + a.getPrice() + " cents.");
}
}
Output:
Winesap costs 15All apple prices:
Jonathan costs 10 cents.
GoldenDel costs 9 cents.RedDel costs 12 cents. Winesap costs 15 cents. Cortland costs 8 cents.
Here, we have member variable price, a constructor and a member method. When the variable ap is
declared in main( ), the constructor for Apple is called once for each constant that is specified.
Although the preceding example contains only one constructor, an enum can offer two or moreoverloaded
forms, just as can any other class. Two restrictions that apply to enumerations:
 an enumeration can’t inherit another class.
 an enum cannot be a superclass.
Enumerations Inherits Enum

All enumerations automatically inherited from java.lang.Enum. This class defines several methods that are
available for use by all enumerations. We can obtain a value that indicates an enumeration constant’s position in
the list of constants. This is called its ordinal value, and it is retrieved by calling the ordinal() method, shown
here:
final int ordinal( )
It returns the ordinal value of the invoking constant. Ordinal values begin at zero. We can compare the
ordinal value of two constants of the same enumeration by using the compareTo() method. It has this general
form:
final int compareTo(enum-type e)
The usage will be –

e1.compareTo(e2);
Here, e1 and e2 should be the enumeration constants belonging to same enum type. If the ordinal value of e1 is
less than that of e2, then compareTo() will return a negative value. If two ordinal values are equal, the method
will return zero. Otherwise, it will return a positive number.
We can compare for equality an enumeration constant with any other object by using equals( ), which
overrides the equals( ) method defined by Object.
enum Person
{
}
enum MStatus
{
Married, Divorced
}
class EnumDemo
{
{
Person p1, p2, p3;
MStatus m=MStatus.Married; System.out.println("Ordinal values are: ");
for(Person p:Person.values())
System.out.println(p + " has a value " + p.ordinal());
p1=Person.Married; p2=Person.Divorced;p3=Person.Married;
if(p1.compareTo(p2)<0)
System.out.println(p1 + " comes before "+p2);else if(p1.compareTo(p2)==0)
System.out.println(p1 + " is same as "+p2);
else
System.out.println(p1 + " comes after "+p2);
if(p1.equals(p3))
System.out.println("p1 & p3 are same");
if(p1==p3)
System.out.println("p1 & p3 are same");
if(p1.equals(m))
System.out.println("p1 & m are same");
else
System.out.println("p1 & m are not same");
//if(p1==m) Generates error

//System.out.println("p1 & m are same");
}
}
Type Wrappers
Java uses primitive types (also called simple types), such as int or double, to hold the basic data types
supported by the language. Primitive types, rather than objects, are used for these quantities for the sake of
performance. Using objects for these values would add an unacceptable overhead to even the simplest of
calculations. Thus, the primitive types are not part of the object hierarchy, and they do not inherit Object.
Despite the performance benefit offered by the primitive types, there are times when you will need an object
representation. For example, you can’t pass a primitive type by reference to a method. Also, many of the
standard data structures implemented by Java operate on an object, which means that you can’t use these data
structures to store primitive types. To handle these (and other) situations, Java provides type wrappers, which
are classes that encapsulate a primitive type within an object.
The type wrappers are Double, Float, Long, Integer, Short, Byte, Character, and Boolean. These classes
offer a wide array of methods that allow you to fully integrate the primitive types into Java’s object hierarchy.
Primi Wrapper
tive
boole java.lang.Boolea
an n
byte java.lang.Byte
char java.lang.Charac
ter
doubl java.lang.Doubl
e e
float java.lang.Float
int java.lang.Integer
long java.lang.Long
short java.lang.Short
void java.lang.Void
Character Wrappers: Character is a wrapper around a char. The constructor for Character is Character(char
ch)
Here, ch specifies the character that will be wrapped by the Character object being created. Toobtain the
char value contained in a Character object, call charValue(), shown here:
char charValue( )
It returns the encapsulated character.
Boolean Wrappers: Boolean is a wrapper around boolean values. It defines these constructors:
Boolean(boolean boolValue)
Boolean(String boolString)
In the first version, boolValue must be either true or false. In the second version, if boolString
contains the string “true” (in uppercase or lowercase), then the new Boolean object will be true.
Otherwise, it will be false. To obtain a boolean value from a Boolean object, useboolean booleanValue( )
It return the boolean equivalent of the invoking object.
 The Numeric Type Wrappers: The most commonly used type wrappers are those that represent numeric
values. All of the numeric type wrappers inherit the abstract class Number. Number declares methods that
return the value of an object in each of the different number formats. These methods are shown here:
byte byteValue( ) double doubleValue( ) float floatValue( ) int intValue( )
long longValue( ) short shortValue( )
For example, doubleValue( ) returns the value of an object as a double, floatValue( ) returns the value as a
float, and so on. These methods are implemented by each of the numeric type wrappers.
All of the numeric type wrappers define constructors that allow an object to be constructed from a given value,
or a string representation of that value. For example, here are the constructors defined for Integer:
Integer(int num) Integer(String str)
If str does not contain a valid numeric value, then a NumberFormatException is thrown. All of the type
wrappers override toString(). It returns the human-readable form of the value contained within the wrapper.
This allows you to output the value by passing a type wrapper object to println(), for example, without having
to convert it into its primitive type.
Ex:
class TypeWrap
{

{
Character ch=new Character('#'); System.out.println("Character is " + ch.charValue());
Boolean b=new Boolean(true); System.out.println("Boolean is " + b.booleanValue());
Boolean b1=new Boolean("false"); System.out.println("Boolean is " + b1.booleanValue());
Integer iOb=new Integer(12); //boxing

int i=iOb.intValue(); //unboxing
System.out.println(i + " is same as " + iOb);
Integer a=new Integer("21"); int x=a.intValue(); System.out.println("x is " + x);
String s=Integer.toString(25); System.out.println("s is " +s);

}
}
Output:
Character is # Boolean is true Boolean is false 12 is same as 12
x is 21
s is 25
I/O Basics
Java programs perform I/O through streams. A stream is a logical device 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. Thus, the same I/O classes and
methods can be applied to any type of device. Java defines two types of streams: byte and character. Byte
streams are used for reading or writing binary data. Character streams provide a convenient means for
handling input and output of characters.
Reading Console Input

In Java, console input is accomplished by reading from System.in. To obtain a character based stream that is
attached to the console, wrap System.in in a BufferedReader object. BufferedReader supports a buffered
input stream. Its most commonly used constructor is shown here:
BufferedReader(Reader inputReader)
Here, inputReader is the stream that is linked to the instance of BufferedReader that is being created. To
obtain an InputStreamReader object that is linked to System.in, use the following constructor:
InputStreamReader(InputStream inputStream)
Because System.in refers to an object of type InputStream, it can be used for inputStream.
Putting it all together, the following line of code creates a BufferedReader that is connected to the keyboard:
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
After this statement executes, br is a character-based stream that is linked to the console through System.in. To
read a character from a BufferedReader , we use read() method. Each time that read( ) is called, it reads a
character from the input stream and returns it as an integer value. It returns –1 when the end of the stream is
encountered.
import java.io.*;class BRRead

{
public static void main(String args[]) throws IOException
{
char c;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));System.out.println("Enter
characters, 'q' to quit.");
do
{
c = (char) br.read(); System.out.println(c);
} while(c != 'q');
}
}
Sample Output:
Enter characters, 'q' to quit. abcdjqmn
abcdj q
The above program allows reading any number of characters and stores them in buffer. Then, all the characters
are read from the buffer till the ‘q’ is found and are displayed.
In Java, the data read from the console are treated as strings (or sequence of characters). So, if we need to read
numeric data, we need to parse the string to respective numeric type and use them later in the program.
Following is a program to read an integer value.
import java.io.*;class BRRead

{
{
int x;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));System.out.println("Enter a
number:"); x=Integer.parseInt((br.readLine()).toString());
x=x+5; System.out.println(x);
}
}
Writing Console Output

Console output can be achieved using print() and println() methods. The PrintStream class providesanother
method write() which is capable of printing only low-order 8-bit values.
Ex:
int b; b = 'A';
System.out.write(b); System.out.write('\n');
PrintWriter Class
PrintWriter is one of the character-based classes. System.out is used to write stream of bytes. As there is a
limitation for size of bytes, for most generic program (that supports various languages in the world), it is better
to use PrintWriter class object to display the output. We can decide whether to flush the stream from the buffer
after every newline by setting 2nd argument of the PrintWriter class constructor as true.
import java.io.*;
public class PrintWriterDemo
{
{
PrintWriter pw = new PrintWriter(System.out, true);pw.println("This is a string");
int i = -7; pw.println(i); double d = 4.5e-7;pw.println(d);

}
}
Reading and Writing Files

Java provides a number of classes and methods that allow you to read and write files. In Java, all files are byte-
oriented, and Java provides methods to read and write bytes from and to a file. However, Java allows you to
wrap a byte-oriented file stream within a character-based object. Two classes used:
FileInputStream FileOutputStream
To open a file, you simply create an object of one of these classes, specifying the name of the file as an
argument to the constructor. Two constructors are of the form:
FileInputStream(String fileName) throws FileNotFoundException
FileOutputStream(String fileName) throws FileNotFoundException
Here, fileName specifies the name of the file that you want to open. When you create an input stream, if the file
does not exist, then FileNotFoundException is thrown. For output streams, if the file cannot be created, then
FileNotFoundException is thrown. When an output file is opened, any preexisting file by the same name is
destroyed. When you are done with a file, you should close it by calling close( ). To read from a file, you can
use a version of read( ) that is defined within FileInputStream. To write data into a file, you can use the write(
) method defined by FileOutputStream.
Program to read data from a file:

Note to students: First create a file(using Notepad) with name “test.txt” and save it in the folder (same place
where you are going to keep your Java programs). Write some contents into this file. Then create a Java
program as shown below –
import java.io.*;class ReadFile

{
{
int i; FileInputStream f;
try
{
f = new FileInputStream("test.txt");
} catch(FileNotFoundException e)
{
System.out.println("File Not Found");return;
}
do
{
i = f.read();
if(i != -1) System.out.print((char) i);
} while(i != -1);
f.close();
}
}
When you run above program, contents of the “test.txt” file will be displayed. If you have not created the
test.txt file before running the program, then “File Not Found” exception will be caught.
Program to write data into a File:

To read the data from a file, it is obvious that the file must already exist in readable format. But, to write a data
into a file, the file need not exist in the folder. Instead, when the statement to open a file to write the data is
encountered in the program a file with specified name will be created. The data written will be then stored
into it. If the specified file already exists inside the folder, it will be overwritten by the new data. Hence, the
programmer must be careful.
Consider the below given program:
import java.io.*;class WriteFile

{
{
int i; FileOutputStream fout;char c;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));System.out.println("Enter

characters, 'q' to quit.");
try
{
fout = new FileOutputStream("test1.txt");
} catch(FileNotFoundException e)
{
System.out.println("Error Opening Output File");
return;
do
{
c = (char) br.read();
fout.write((int)c);
} while(c != 'q');
}
}
When you run above program, it will ask you to enter few characters. Give some random characters as an
input and provide ‘q’ to quit. The program will read all these characters from the buffer and write into the file
“test1.txt”. Go the folder where you have saved this program and check for a text file “test1.txt”. Open the file
manually (by double clicking on it) and see that all characters that you have entered are stored in this file.
Applets
Using Java, we can write either Application or Applet. 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. After
an applet arrives on the client, it has limited access to resources so that it can produce a graphical user interface
and run complex computations without introducing the risk of viruses or breaching data integrity.
To write an applet, we need to import Abstract Window Toolkit (AWT) classes. Applets interact with the user
(either directly or indirectly) through the AWT. The AWT contains support for a window-based, graphical user
interface. We also need to import applet package, which contains the class Applet. Every applet that you create
must be a subclass of Applet. Consider the below given program:
import java.awt.*; import java.applet.*;
/*
<applet code="SimpleApplet" width=200 height=60>
</applet>
*/
public class SimpleApplet extends Applet

{
public void paint(Graphics g)
{
g.drawString("A Simple Applet", 20, 20);
}
}
The class SimpleApplet must be declared as public, because it will be accessed by code that is outside the
program. The paint() method is defined by AWT and must be overridden by the applet. paint( ) is called each
time that the applet must redisplay its output. This situation can occur for several reasons:
– the window in which the applet is running can be overwritten by another window and then uncovered.
– the applet window can be minimized and then restored.
– when the applet begins execution.
The paint( ) method has one parameter of type Graphics. This parameter contains the graphics context, which
describes the graphics environment in which the applet is running. This context is used whenever output to the
applet is required. drawString( ) is a member of the Graphics class used to output a string beginning at the
specified X,Y location. (Upper left corner is 0,0)
The compilation of the applet is same as any normal Java program. But, to run the applet, we need some HTML
(HyperText Markup Language) support. <applet> tag is used for this purpose with the attributes code which is
assigned with name of the class file, and size of the applet window in terms of width and height. The HTML
script must be written as comment lines. Use the following statements:
javac SimpleApplet.java //for compilationappletviewer SimpleApplet.java

//for execution
When you run above program, you will get an applet window as shown below –
Applet Life Cycle: Applet class has five important methods, and any class extending Applet class may
override these methods. The order in which these methods are executed is known as applet life cycle as
explained below:
 init(): This is the first method to be called. This is where you should initialize variables. This method is
called only once during the run time of your applet.
 start( ) : It is called after init(). It is also called to restart an applet after it has been stopped. start() is called
each time an applet’s HTML document is displayed onscreen. So, if a user leaves a web page and comes
back, the applet resumes execution at start().
 paint( ): This is called each time your applet’s output must be redrawn.
 stop( ) : This method is called when a web browser leaves the HTML document containing the applet—
when it goes to another page, for example. When stop() is called, the applet is probably running. You
should use stop() to suspend threads that don’t need to run when the applet is not visible. You can restart
them when start() is called if the user returns to the page.
 destroy( ) : This method is called when the environment determines that your applet needs to be removed
completely from memory. At this point, you should free up any resources the applet may be using. The
stop() method is always called before destroy().
Diagrammatic representation of applet life-cycle is shown in figure given below:
Few key points about applets:

– 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. Instead, applets use theinterface provided by
the AWT or Swing
5.1 String Handling

A string is a sequence of character and Java implements strings as objects of type String. Implementing strings
as built-in objects allows Java to provide a full complement of features that make string handling convenient.
For example, Java has methods to compare two strings, search for a substring, concatenate two strings, and
change the case of letters within a string. Also, String objects can be constructed a number of ways, making it
easy to obtain a string when needed. Once a String object has been created, you cannot change the characters
of that string. Whenever we need any modifications, a new string object containing modifications has to be
created. However, a variable declared as String reference can point to some other String object, and hence can
be changed.
In case, we need a modifiable string, we should use StringBuffer or StringBuilder classes. String,
StringBuffer and StringBuilder classes are in java.lang and are final classes. Thus, no class can inherit these
classes. All these classes implement CharSequence interface.
The String Constructors

There are several constructors for String class.
1. To create an empty string, use default constructor:

String s= new String();
2. To create a string and initialize:

String s= new String(“Hello”);
3. To create a string object that contains same characters as another string object:
String(String strObj);
For example,
String s= new String(“Hello”);String s1= new String(s);
4. To create a string having initial values:

String(char chars[])
For example,
char ch[]={‘h’, ‘e’, ‘l’, ‘l’, ‘o’};
String s= new String(ch); //s contains hello
5. To specify a sub-range of a character array as an initializer use the following constructor:

String(char chars[ ], int startIndex, int numChars)
For example,
char ch[]={‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’’, ‘g’};
String s= new String(ch, 2, 3); //Now, s contains cde
Even though Java’s char type uses 16 bits to represent the basic Unicode character set, the typical format for
strings on the Internet uses arrays of 8-bit bytes constructed from the ASCII character set. Because 8-bit ASCII
strings are common, the String class provides constructors that initialize a string when given a byte array.
6. The general forms are:

String(byte asciiChars[ ])
String(byte asciiChars[ ], int startIndex, int numChars)
For example,
byte ascii[] = {65, 66, 67, 68, 69, 70 };
String s1 = new String(ascii); // s1 contains ABCDEF
String s2 = new String(ascii, 2, 3); // s2 contains CDE
JDK 5 and higher versions have two more constructors. The first one supports the extended Unicode character
set.
7. The general form:

String(int codePoints[ ], int startIndex, int numChars)
here, codePoints is array containing Unicode points.
8. Another constructor supports StringBuilder:

String(StringBuilder strBuildObj)
String Length
The length of a string is the number of characters that it contains. To obtain this value, call the length()
method. For example,
String s=new String(“Hello”); System.out.println(s.length()); //prints 5
Special String Operations

Java supports many string operations. Though there are several string handling methods are available, for the
use of programmer, Java does many operations automatically without requiring a call for separate method. This
adds clarity to the program. We will now see few of such operations.
String Literals: Instead of using character arrays and new operator for creating string instance, we can use
string literal directly. For example,
char ch[]={‘H’, ‘e’, ‘l’, ‘l’, ‘o’};String s1=new String(ch);
or
String s2= new String (“Hello”);
Can be re-written, for simplicity, as –
String s3=“Hello”; //usage of string literal
A String object will be created for every string literal and hence, we can even use,
System.out.println(“Hello”.length()); //prints 5
String Concatenation: Java does not allow any other operator than + on strings. Concatenationof two or
more String objects can be achieved using + operator. For example,
String age = “9”;
String s = "He is " + age + " years old."; System.out.println(s); //prints He is 9 years old.
One practical use of string concatenation is found when you are creating very long strings. Instead of letting
long strings wrap around within your source code, you can break them into smaller pieces, using the + to
concatenate them.
String longStr = "This could have been " +
"a very long line that would have " + "wrapped around. But string concatenation " +"prevents this.";
System.out.println(longStr);
String Concatenation with Other Data Types: We can concatenate String with other data types. For example,
int age = 9;
String s = "He is " + age + " years old."; System.out.println(s); //prints He is 9 years old.
Here, the int value in age is automatically converted into its string representation within a String object. The
compiler will convert an operand to its string equivalent whenever the other operandof the + is an instance of
String. But, we should be careful while mixing data types:
String s= “Four : ” + 2 + 2; System.out.println(s); //prints Four : 22
This is because, “Four :” is concatenated with 2 first, then the resulting string is again concatenated with 2. We
can prevent this by using brackets:
String s = “Four : ” + (2+2); System.out.println(s); //prints Four : 4
String Conversion and toString(): Java uses valueOf( ) method for converting data into its string
representation during concatenation. valueOf( ) is a string conversion method defined by String. valueOf( ) is
overloaded for all the primitive types and for type Object. For the primitive types, valueOf( ) returns a string
that contains the human-readable equivalent of the value with which it is called. For objects, valueOf( ) calls
the toString( ) method on the object. Every class implements toString( ) because it is defined by Object.
However, the default implementation of toString( ) is seldom sufficient. For our own classes, we may need to
override toString() to give our own string representation for user-defined class objects. The toString( ) method
has this general form:
String toString( )
To implement toString( ), simply return a String object that contains the human-readable stringthat
appropriately describes an object of our class.
class Box
{
double width, height, depth;

{ width = w; height = h;depth = d;
}
public String toString()

{
return "Dimensions are " + width + "by" + depth + "by" + height;
}
}
class StringDemo
{
{
Box b = new Box(10, 12, 14);
String s = "Box b: " + b; // concatenate Box object
System.out.println(s); // convert Box to string System.out.println(b);
}
}
Output:
Box b: Dimensions are 10.0 by 14.0 by 12.0
Dimensions are 10.0 by 14.0 by 12.0
Note: Observe that, Box’s toString( ) method is automatically invoked when a Box object isused in a
concatenation expression or in a call to println( ).
Character Extraction Methods
The String class provides different ways for extracting characters from a string object. Though a String object
is not a character array, many of the String methods use an index into a string object for their operation.
charAt() : This method is used to extract a single character from a String. It has this generalform:
char charAt(int where)
Here, where is the index of the character that you want to obtain. The value of where must benonnegative
and specify a location within the string. For example,
char ch;
ch= “Hello”.charAt(1); //ch now contains e
getChars() : If you need to extract more than one character at a time, you can use this method. It has the
following general form:
void getChars(int sourceStart, int sourceEnd, char target[], int targetStart)
sourceStart specifies the index of the beginning of the substring

sourceEnd specifies an index that is one past the end of the desired substring. (i.e. the
substring contains the characters from sourceStart through sourceEnd–1)
target specifies the array which receives the substring
targetStart is the index within target at which the substring will be copied
Care must be taken to assure that the target array is large enough to hold the number ofcharacters in
the specified substring.
class StringDemo1
{
{
}
}
Output:
demo
String s = "This is a demo of the getChars method."; int start = 10;
int end = 14;
char buf[] = new char[end - start];s.getChars(start, end, buf, 0); System.out.println(buf);
getBytes() : It is an alternative to getChars() that stores the characters in an array of bytes. Ituses the
default character-to-byte conversions provided by the platform. Here is its simplest form:
byte[ ] getBytes( )
Other forms of getBytes( ) are also available. getBytes( ) is most useful when you are exportinga String value
into an environment that does not support 16-bit Unicode characters. For example, most Internet protocols and
text file formats use 8-bit ASCII for all text interchange.
toCharArray() : If you want to convert all the characters in a String object into a character array, the easiest
way is to call toCharArray( ). It returns an array of characters for the entire string. It has this general form:
char[ ] toCharArray( )
This function is provided as a convenience, since it is possible to use getChars( ) to achieve the same result.
String s1="hello";
char[] ch=s1.toCharArray();
for(int i=0;i<ch.length;i++) System.out.print(ch[i]);
String Comparison Methods

The String class provides several methods to compare strings or substrings within strings.
• equals() and equalsIgnoreCase(): To compare two strings for equality, we have two methods:
boolean equals(Object str)
boolean equalsIgnoreCase(String str)
Here, str is the String object being compared with the invoking String object. The first method is case
sensitive and returns true, if two strings are equal. The second method returns true if two strings are same,
whatever may be their case.
String s1 = "Hello"; String s2 = "Hello"; String s3 = "Good-bye";String s4 = "HELLO";
System.out.println(s1.equals(s2)); //true System.out.println(s1.equals(s3));
//false System.out.println(s1.equals(s4));
//false
System.out.println(s1.equalsIgnoreCase(s4)); //true
• regionMatches(): The regionMatches( ) method compares a specific region inside a string with another
specific region in another string. There is an overloaded form that allows you to ignore case in such
comparisons. Here are the general forms for these two methods:
boolean regionMatches(int startIndex, String str2, int str2StartIndex, int numChars)

boolean regionMatches(boolean ignoreCase, int startIndex, String str2, int str2StartIndex, int numChars)
startIndex specifies the index at which the region begins within the invoking String.
str2 the String being compared.
str2StartIndex The index at which the comparison will start within str2. numChars The
length of the substring being compared.
ignoreCase used in second version. If it is true, the case of the characters is ignored.
Otherwise, case is significant.
String s1= "Hello How are you?";String s2= "how";

System.out.println(s1.regionMatches(6,s2,0,3)); //false System.out.println(s1.regionMatches(true,6,s2,0,3));
//true
Here, the statement s1.regionMatches(6,s2,0,3) will check whether 3 characters of s2 starting from 0th position
will match 3 characters of s1 starting from 6th position. Note that, 3 characters starting from 6 th position in s1
are “How”. And, s2 is “how”. These two do not match. If we take another argument true for regionMatches()
method, then case is ignored, and hence it willreturn true.
• startsWith( ) and endsWith(): These are the specialized versions of the regionMatches() method. The
startsWith() method determines whether a given String begins with a specified string. The endsWith()
method determines whether the String in question ends with a specified string. They have the following
general forms:
boolean startsWith(String str)boolean endsWith(String str)
Ex:
"Foobar".endsWith("bar") //true"Foobar".startsWith("Foo") //true
A second form of startsWith( ), lets you specify a starting point:

boolean startsWith(String str, int startIndex)
Here, startIndex specifies the index into the invoking string at which point the search will begin.
"Foobar".startsWith("bar", 3) //returns true.
• equals( ) v/s == : The equals( ) method compares the characters inside a String object. The ==
operator compares two object references to see whether they refer to the same instance.
String s1 = "Hello";
String s2 = new String(s1); System.out.println(s1.equals(s2)); //true System.out.println((s1 == s2)); //false
• compareTo(): This method is used to check whether a string is less than, greater than or equal to the other
string. The meaning of less than, greater than refers to the dictionary order (based on Unicode). It has this
general form:
int compareTo(String str)
This method will return 0, if both the strings are same. Otherwise, it will return the difference between the
ASCII values of first non-matching character. If you want to ignore case differences when comparing two
strings, use compareToIgnoreCase(), as shown here:
int compareToIgnoreCase(String str)
Ex:
String str1 = "String method tutorial"; String str2 = "compareTo method example";String str3 = "String method
tutorial";
int var1 = str1.compareTo( str2 );

System.out.println("str1 & str2 comparison: "+var1); // -16
int var2 = str1.compareTo( str3 ); System.out.println("str1 & str3 comparison: "+var2); //0
Searching Strings
The String class provides two methods indexOf() and lastIndexOf() that allow you to search a string for a
specified character or substring. Both these methods are overloaded to take different types of arguments for
doing specific tasks as listed in the table given below –
Method Purpose
int indexOf(int ch) To search for the first occurrence
of acharacter
int lastIndexOf(int ch) To search for the last occurrence of
acharacter,
int indexOf(String str) To search for the first or last

occurrenceof a substring
int lastIndexOf(String str)
int indexOf(int ch, int startIndex) Used to specify a starting point for the
search. Here, startIndex specifies the
int lastIndexOf(int ch, int index at which point the search
startIndex) begins.
int indexOf(String str, int For indexOf() method, the search runs
startIndex) from startIndex to the end of the
int lastIndexOf(String str, string.
int For lastIndexOf( ) method, the search
startIndex)
runs from startIndex to zero.
Following program demonstrates working of all these functions –
class Demo
{
{
String s = "Now is the time for all good men to come to the aid of their
country.";
System.out.println(s.indexOf('t')); //7 System.out.println(s.lastIndexOf('t'));
//65System.out.println(s.indexOf("the"));
//7 System.out.println(s.lastIndexOf("the"));
//55System.out.println(s.indexOf('t', 10));
//11
System.out.println(s.lastIndexOf('t', 60)); //55
System.out.println(s.indexOf("the", 10)); //44
System.out.println(s.lastIndexOf("the", 60)); //55
}
}
Modifying a String
Since String objects cannot be changed, whenever we want to modify a String, we must either copy it into a
StringBuffer or StringBuilder, or use one of the following String methods, which will construct a new copy
of the string with our modifications complete.
substring(): Used to extract a substring from a given string. It has two formats:
String substring(int startIndex): Here, startIndex specifies the index at which the substring will begin. This
form returns a copy of the substring that begins at startIndex and runs to the end of the invoking string.
String substring(int startIndex, int endIndex): Here, startIndex specifies the beginning index, and endIndex
specifies the stopping point. The string returned contains all the characters from the beginning index, up to, but
not including, the ending index.
Ex:
String org = "This is a test. This is, too.";String result ;
result=org.substring(5);
System.out.println(result); //is a test. This is, too.
result=org.substring(5, 7); System.out.println(result); //is
concat(): This method can be used to concatenate two strings: String concat(String str)
This method creates a new object that contains the invoking string with the contents of str
appended to the end. concat( ) performs the same function as +.
String s1 = "one";
String s2 = s1.concat("two");
is same as
String s1 = "one"; String s2 = s1 + "two";
replace():The first form of this method replaces all occurrences of one character in the invokingstring with
another character.
String replace(char original, char replacement)
Here, original specifies the character to be replaced by the character specified by replacement. For example,
String s = "Hello".replace('l', 'w');puts the string “Hewwo” into s.
The second form of replace( ) replaces one character sequence with another. String replace(CharSequence
original, CharSequence replacement)
trim():The trim( ) method returns a copy of the invoking string from which any leading and trailingwhite-
space has been removed. It has this general form:
String trim()
Here is an example:
String s = “ Hello World ".trim();
This puts the string “Hello World” into s by eliminating white-spaces at the beginning and at theend.
Data Conversion using valueOf()

The valueOf() method converts data from its internal format into a human-readable form. It is a static method
that is overloaded within String for all of Java’s built-in types so that each type can be converted properly into
a string. valueOf() is also overloaded for type Object, so an object of any class type you create can also be
used as an argument. Here are a few of its forms:
static String valueOf(double num) static String valueOf(long num) static String valueOf(Object ob) static String
valueOf(char chars[ ])
Example,
int value=30;
String s1=String.valueOf(value);
System.out.println(s1+10); //prints 3010
Changing Case of Characters within a String

The method toLowerCase() converts all the characters in a string from uppercase to lowercase. The
toUpperCase() method converts all the characters in a string from lowercase to uppercase. Non- alphabetical
characters, such as digits, are unaffected. Here are the general forms of these methods:
String toLowerCase() String toUpperCase()
For example,
String str = "Welcome!"; String s1 = str.toUpperCase();

System.out.println(s1); //prints WELCOME!String s2= str.toLowerCase();
System.out.println(s2); //prints welcome!
Additional String Methods
Java provides many more methods as shown in the table given below –
Method Description
int codePointAt(int i) Returns the Unicode code point at the location
specified by i.
int codePointBefore(int i) Returns the Unicode code point at the location that
precedes that specified by i.
int codePointCount(int start, int end) Returns the number of code points in the portion of
the invoking String that is between start and end–1.
boolean contains(CharSequence str) Returns true if the invoking object contains the string
specified by str. Returns false, otherwise.
boolean contentEquals(CharSequence Returns true if the invoking string contains the same
str) string as str. Otherwise, returns false.
boolean contentEquals(StringBuffer Returns true if the invoking string contains the same
str) string as str. Otherwise, returns false.
static String format(String fmtstr, Returns a string formatted as specified by fmtstr.
Object ... args)
static String format(Locale loc, String Returns a string formatted as specified by fmtstr.
fmtstr, Object ... args) Formatting is governed by the locale specified by loc.
boolean matches(string regExp) Returns true if the invoking string matches the
regular expression passed in regExp. Otherwise,
returns false.
int offsetByCodePoints(int start, int Returns the index with the invoking string that is num
num) code pointsbeyond the starting index specified by start.
String replaceFirst(String regExp, Returns a string in which the first substring that
String newStr) matches the regular expression specified by regExp is
replaced by newStr.
String replaceAll(String regExp, Returns a string in which all substrings that match the
String newStr) regular expression specified by regExp are replaced by
newStr.
String[ ] split(String regExp) Decomposes the invoking string into parts and returns
an array that contains the result. Each part is delimited
by the regular expression passed in regExp.
String[ ] split(String regExp, Decomposes the invoking string into parts and returns
int max) an array that contains the result. Each part is delimited
by the regular expression passed in regExp. The
number of pieces is specified by max. If max is
negative, then the invoking string is fully decomposed.
Otherwise, if max contains a nonzero value, the last
entry in the returned array contains the remainder of
the invoking string. If max is zero, the invoking string
is fully decomposed.
CharSequence subSequence(int Returns a substring of the invoking string, beginning
startIndex, at startIndex and stopping at stopIndex. This method
int stopIndex) is required by the CharSequence interface, which is
now implemented by String.
StringBuffer Class
We know that, String represents fixed-length, immutable character sequences. In contrast, StringBuffer
represents growable and writeable character sequences. We can insert characters in the middle or append at the
end using this class. StringBuffer will automatically grow to make room for such additions and often has more
characters pre-allocated than are actually needed, to allow room for growth.
Constructors: The StringBuffer class has four constructors:

StringBuffer(): Reserves space for 16 characters without reallocation.
StringBuffer(int size) : accepts an integer argument that explicitly sets the size of thebuffer
StringBuffer(String str) : accepts a String argument that sets the initial contents of the
StringBuffer object and reserves room for 16 more characters without reallocation.
StringBuffer(CharSequence chars) : creates an object that contains the character sequence contained in chars
StringBuffer class provides various methods to perform certain tasks, which are mainly focused on changing
the content of the string (Remember, String class is immutable – means content of the String class objects
cannot be modified). Some of them are discussed hereunder:
length() and capacity(): These two methods can be used to find the length and total allocated capacity of
StringBuffer object. As an empty object of StringBuffer class gets 16 character space, the capacity of the object
will be sum of 16 and the length of string value allocated to that object. Example:
StringBuffer sb = new StringBuffer("Hello"); System.out.println(“Original string = " + sb);

System.out.println("length = " + sb.length()); //prints 5
System.out.println("capacity = " + sb.capacity()); //prints 21
ensureCapacity(): If you want to preallocate room for a certain number of characters after a StringBuffer has
been constructed, you can use this method to set the size of the buffer. This is useful if you know in advance
that you will be appending a large number of small strings to a StringBuffer. The method ensureCapacity()
has this general form:
void ensureCapacity(int capacity)Here, capacity specifies the size of the buffer.
charAt() and setCharAt(): The value of a single character can be obtained from a StringBuffer via the
charAt() method. You can set the value of a character within a StringBuffer using setCharAt(). Their general
forms are shown here:
char charAt(int where)
void setCharAt(int where, char ch)
For charAt(), where specifies the index of the character being obtained. For setCharAt(), where specifies the
index of the character being set, and ch specifies the new value of that character. Example:
StringBuffer sb = new StringBuffer("Hello"); System.out.println("buffer before = " + sb);

System.out.println("charAt(1) before = " + sb.charAt(1));sb.setCharAt(1, 'i');
sb.setLength(2); System.out.println("buffer after = " + sb);
System.out.println("charAt(1) after = " + sb.charAt(1));
Output would be –
buffer before = Hello charAt(1) before = ebuffer after = Hi charAt(1) after = i
getChars(): To copy a substring of a StringBuffer into an array, use the getChars( ) method. It has this
general form:
void getChars(int sourceStart, int sourceEnd, char target[ ], int targetStart)
Here, sourceStart specifies the index of the beginning of the substring, and sourceEnd specifies an index that is
one past the end of the desired substring. This means that the substring contains the characters from sourceStart
through sourceEnd–1. The array that will receive the characters is specified by target. The index within target
at which the substring will be copied is passed in targetStart. Care must be taken to assure that the target array
is large enough to hold the number of characters in the specified substring.
append(): The append() method concatenates the string representation of any other type of data to the end of
the invoking StringBuffer object. It has several overloaded versions. Here are a few of its forms:
StringBuffer append(String str) StringBuffer append(int num) StringBuffer append(Object obj)
String.valueOf() is called for each parameter to obtain its string representation. The result is appended to the
current StringBuffer object. The buffer itself is returned by each version of append( ) to allow subsequent
calls.
String s; int a = 42;

StringBuffer sb = new StringBuffer(40);
s = sb.append("a=").append(a).append("!").toString();System.out.println(s); //prints a=42!
insert(): The insert() method inserts one string into another. It is overloaded to accept values ofall the simple
types, plus Strings, Objects, and CharSequences. Like append(), it calls String.valueOf( ) to obtain the
string representation of the value it is called with. This string is then inserted into the invoking StringBuffer
object. Few forms are:
– StringBuffer insert(int index, String str)
– StringBuffer insert(int index, char ch)
– StringBuffer insert(int index, Object obj)
Here, index specifies the index at which point the string will be inserted into the invoking
StringBuffer object. Example:
StringBuffer sb = new StringBuffer("I Java!");sb.insert(2, "like "); System.out.println(sb); //I like Java
reverse(): Used to reverse the characters within a string. StringBuffer s = new StringBuffer("abcdef");
System.out.println(s); //abcdef s.reverse();
System.out.println(s); //fedcba
delete() and deleteCharAt(): You can delete characters within a StringBuffer by using the methods
delete() and deleteCharAt(). These methods are shown here:
StringBuffer delete(int startIndex, int endIndex)
It deletes a sequence of characters from the invoking object. Here, startIndex specifies the indexof the first
character to remove, and endIndex specifies an index one past the last character to
remove. Thus, the substring deleted runs from startIndex to endIndex–1.The resulting
StringBuffer object is returned.
StringBuffer deleteCharAt(int loc)
It deletes the character at the index specified by loc. It returns the resulting StringBuffer object.Example:
StringBuffer sb = new StringBuffer("This is a test");sb.delete(4, 7);

System.out.println("After delete: " + sb); //This a testsb.deleteCharAt(0);
System.out.println("After deleteCharAt: " + sb); //his a test
replace(): You can replace one set of characters with another set inside a StringBuffer object by calling
replace( ). Its signature is shown here:
StringBuffer replace(int startIndex, int endIndex, String str)
The substring being replaced is specified by the indexes startIndex and endIndex. Thus, the substring at
startIndex through endIndex–1 is replaced. The replacement string is passed in str. The resulting StringBuffer
object is returned.
StringBuffer sb = new StringBuffer("This is a test");sb.replace(5, 7, "was");

System.out.println("After replace: " + sb); //This was a test
substring() : You can obtain a portion of a StringBuffer by calling substring(). It has the following two
forms:
String substring(int startIndex)
String substring(int startIndex, int endIndex)
The first form returns the substring that starts at startIndex and runs to the end of the invoking StringBuffer
object. The second form returns the substring that starts at startIndex and runs through endIndex–1. These
methods work just like those defined for String that were described earlier.
Additional StringBuffer Methods

Method Description
StringBuffer Appends a Unicode code point to the end of the invoking
appendCodePoint(int ch) object. A reference to the object is returned.
int codePointAt(int i) Returns the Unicode code point at the location specified by i.
int codePointBefore(int i) Returns the Unicode code point at the location that
precedesthat specified by i.
int codePointCount(int start, int Returns the number of code points in the portion of the
end) invoking String that is between start and end–1.
int indexOf(String str) Searches the invoking StringBuffer for the first
occurrence ofstr. Returns the index of the match, or –1 if no
match is found.
int indexOf(String str, Searches the invoking StringBuffer for the first
intstartIndex) occurrence ofstr, beginning at startIndex. Returns the index
of the match, or
–1 if no match is found.
int lastIndexOf(String str) Searches the invoking StringBuffer for the last occurrence
ofstr. Returns the index of the match, or –1 if no match is
found.
int lastIndexOf(String str, Searches the invoking StringBuffer for the last occurrence
intstartIndex) ofstr, beginning at startIndex. Returns the index of the
match, or
–1 if no match is found.
int offsetByCodePoints(int Returns the index with the invoking string that is num code
start, int num) points beyond the starting index specified by start.
CharSequence subSequence (int Returns a substring of the invoking string, beginning at

startIndex and stopping at stopIndex. This method is
startIndex, int stopIndex) requiredby the CharSequence interface, which is now
implemented byStringBuffer.
void trimToSize( ) Reduces the size of the character buffer for the invoking
objectto exactly fit the current contents.
StringBuilder Class
J2SE 5 adds a new string class to Java’s already powerful string handling capabilities. This new class is called
StringBuilder. It is identical to StringBuffer except for one important difference: it is not synchronized, which
means that it is not thread-safe. The advantage of StringBuilder is faster performance. However, in cases in
which you are using multithreading, you must use StringBuffer rather than StringBuilder.
Other Topics
Using instanceof
Sometimes, we need to check type of the object during runtime of the program. We may create multiple classes
and objects to these classes in a program. In such situations, the instanceof operator is useful The instanceof
operator will return Boolean value – true or false.
class A
{
int i, j;
}
class B
{
int i, j;
}
class C extends A
{
int k;
}
class InstanceOfEx
{
{
A a = new A();
B b = new B();
C c = new C();
if(a instanceof A) //this is true

System.out.println("a is instance of A"); //will be printed
if(b instanceof A) //this is false

System.out.println("b is instance of B"); //will not be printed
A ob;
ob = c;
if(ob instanceof C) // true because of inheritance System.out.println("ob is instance of C"); //

will be printed
}
}
Static Import
The statement static import expands the capabilities of the import keyword. By following import with the
keyword static, an import statement can be used to import the static members of a class or interface. When
using static import, it is possible to refer to static members directly by their names, without having to qualify
them with the name of their class. This simplifies and shortens the syntax required to use a static member.
We have observed earlier that when we need to use some Math functions, we need to use Math.sqrt(),
Math.pow() etc. Using static import feature, we can just use sqrt(), pow() etc. as shown below –
import static java.lang.Math.sqrt;import static java.lang.Math.pow;
class Hypot
{
{
double side1, side2;double hypot;
side1 = 3.0;
side2 = 4.0;
hypot = sqrt(pow(side1, 2) + pow(side2, 2)); System.out.println(" the hypotenuse is " + hypot);
}
}
Invoking Overloaded Constructors through this()

When working with overloaded constructors, it is sometimes useful for one constructor to invoke another.In
Java, this is accomplished by using another form of the this keyword. The general form is shown here:
this(arg-list)
When this() is executed, the overloaded constructor that matches the parameter list specified by arg-list is
executed first. Then, if there are any statements inside the original constructor, they are executed. The call to
this() must be the first statement within the constructor.
class MyClass
{
int a, b;
MyClass(int i, int j)
{
a = i;
b = j;
}
MyClass(int i)
{
this(i, i); // invokes MyClass(i, i)
}
MyClass( )
{
this(0); // invokes MyClass(0)
}
void disp()
{
System.out.println(“a=”+a + “ b=”+b);
}
}
class thisDemo
{
{
MyClass m1 = new MyClass();m1.disp();
MyClass m2 = new MyClass(8);m2.disp();
MyClass m3 = new MyClass(2,3);m3.disp();

}
}
Output:
a= 0 b=0
a= 8 b=8
a= 2 b=3
SUIET 2022-23 21SCS34
QUESTION BANK
MODULE I
MCQ
1) What does JVM stands for?
A) Java Variable Machine
B) Java Virtual Machine
C) Java Virtual Mechanism
D) None of the above
Answer [B]
2) What is JVM ?
A) JVM is the confined memory area
B) All java programs run inside JVM memory
C) JVM provides security to the computer by giving controlled access to Files and Memory on a computer
D) All the above
Answer [D]
3) When was first Version of Java i.e Java 1.0 was released?
A) 1991
B) 1994
C) 1996
D) 1999
Answer [C]
4) What is Portability offered by Java language?
A) Small code size easy to carry occupying less disk space
B) Generating suitable Byte Code for each machine by the Compiler
C) Ability to run the Byte on different machines producing the same behaviour and output
D) Java does not actually provide portability
Answer [C]
5) What is JIT in Java?
A) Java In Timer
B) Java In Time Thread
C) Just In Time Compiler
D) Just In Time Runnable
Answer [C]
6) Choose the correct statement about Java?
A) JIT Compiler produces Byte Code from Java file.
B) JIT Compiler takes chunks of Byte Code as input and produces Executable code on that particular machine.
C) JIT Compiler assists the actual JAVAC compiler to compile fast
Answer [B]
7) What happens in the absence of JIT Compiler in Java?
A) Byte code is produced slowly
B) Executable Code is produced slowly because of line by line Interpreting
C) Executable Code is produced without portability
Answer [B]
OBJECT ORIENTED PROGRAMMING USING JAVA Page 127

SUIET 2022-23 21SCS34
8) What are the main Distribution types of Java Software?

A) Java SE (Java Standard Edition)
B) Java EE (Java Enterprise Edition)
C) Java ME (Java Micro Edition)
D) All the above
Answer [D]
9) What is the Java distribution type used to build Web Apps in Java?
A) Java SE
B) Java EE
C) Java ME
D) Java Embedded
Answer [=B]
12) What is the Java command used to compile a java program from Command Line or Command Prompt
or CMD?
A)
>java hello.java
B)
>javac hello.java
C)
>javacomp hello.java
D)
>javacmd hello.java
Answer [B]
13) What is the command used to Run a Java program form Command Line or Command Prompt or
CMD?
A)
javac hello
B)
java hello.class
C)
java hello
D)
java hello.java
Answer [C]
14). What does a Data Type in Java refers to?
A) The place where data is stored
B) The technique how data is retreived
C) The type or variety of data being handled for reading and writing
Answer [C]

SUIET 2022-23 21SCS34
15) Choose the wrong statement about Java programming?
A) Java supports unsigned integers
B) Java supports signed integers
C) Java supports signed char
Answer [C]
16) What are the Type Conversions available in Java language?
A) Narrowing Type Conversion
B) Widening Type Conversion
C) A and B
Answer [D]
17) What is a higher data type in Java language?
A) A data type which holds more data than other data types
B) A data type whose size is more than other data types
C) A data type which can hold more precision digits than other data types
D) All the above
Answer [D]
18) What is a Widening Type Conversion in Java?
A) Conversion of data from higher data type to lower data type
B) Conversion of data from lower data type to higher data type
C) Conversion of data from any data type to any data type
Answer [C]
19) What is a Narrowing Type Conversion in Java?
A) Conversion of data from lower data type to higher data type
B) Conversion data from a higher data type to a lower data type
C) Conversion of data from any data type to any data type
Answer [D]
20) What is the result of a Narrowing type conversion?
A) Loss of data
B) Addition of data
C) Corruption of data
Answer [C]
21) What is the result of a Widening Type Conversion in Java?
A) Loss of data
B) Gain of data
C) No change
Answer [=]
22) Type promotion in Java usually refers to ____.
A) Narrowing Type Conversion
B) Widening Type Conversion
C) No Type Conversion
Answer [=]
SUIET 2022-23 21SCS34
23) An Arithmetic expression in Java involves which Operators or Operations?
A) Addition (+), Subtraction (-)
B) Multiplication (*), Division (/)
C) Modulo Division (%), Increment/Decrement (++/--), Unary Minus (-), Unary Plus (+)
D) All the above
Answer [=]
24) Choose the Compound Assignment Arithmetic Operators in Java below.
A) +=, -=
B) *=, /=
C) %=
D) All the above
Answer [=]
25)
What is the output of the below Java code snippet?
int a = 2 - - 7;
System.out.println(a);
A) -5
B) 10
C) 9
D) Compiler Error
Answer [ C]
1. Explain key attributes of Java programming language.

2. What is JVM? Why do we need it?
3. Briefly explain JRE and JDK.
4. Explain three OOPs principles.
5. What are Keywords and Identifiers? List the rules to write an identifier.
6. Discuss various data types used in Java.
7. What is type Conversion and Casting? Explain automatic type promotion in expressions with rules
and a demo program.
8. Explain scope and lifetime of variables with suitable examples.
9. "Java is a strongly typed language" - Justify this statement.
10. Write a note on Java class libraries
11. Explain array declaration and initialization in Java with suitable examples.
12. What are multi-dimensional arrays? Explain with examples.
13. What are irregular arrays in Java? Write a program to find biggest of numbers in an irregular array
with at least three rows.

SUIET 2022-23 21SCS34
MODULE II
1) What are the two possible Logical Operator types?

A) Bitwise Logical
B) Boolean Logical
C) Arithmetic Logical
D) A and B
Answer [D]
2) Boolean logical operators in Java work with?
A) true/false boolean data
B) 1 and 0 of individual Bits
C) characters of a String
Answer [A]
3) Bitwise logical operators in Java work with?
A) true/false boolean data
B) 0 and 1 individual bits of data
C) Characters of a String
Answer [B]
4) In general Bitwise logical operators are simply called?
A) Logical operators
B) Bitwise operators
C) Binary operators
Answer [B]
5) What is the input for Logical Operators?
A) 1 and 0
B) true / false
C) char / String
Answer [B]
6) What is the output of any Logical operation in Java?
A) 1 or 0
B) true or false
C) char or String
Answer [B]
7) Which is the Logical operator in Java that works with a Single Operand?
A) Logical AND
B) Logical OR
C) Logical Exclusive OR
D) Logical NOT
Answer [D]

SUIET 2022-23 21SCS34
8) Which among the following is a Logical Unary NOT operator in Java?
A) ~
B) !
C) #
D) ^
Answer [B]
9) What is the output of the Java code snippet?
boolean b=false;
b = !b;
System.out.println(b);
A) true
B) false
C) Compiler error
Answer [A]
10) Which among the following is a Short Circuit AND operator?
A)
&
B)
&&
C)
|
D)
||
Answer [B]
11) Which among the following is a Short Circuit OR operator?
A)
&
B)
&&
C)
|
D)
||
Answer [D]
12) What is the output of a Logical OR (|) operation if one of the inputs/operands is false?
A) false
B) true
C) true or false
Answer [C]
13) What is the output of Logical AND (&) operation if one of the inputs/operands is false?
SUIET 2022-23 21SCS34
A) false
B) true
C) true or false
Answer [A]
14) What is the output of a Logical OR (|) operation if one of the inputs/operands is true?
A) false
B) true
C) true or false
Answer: B
15) Identify the Bitwise NOT operator in Java below.
A)
!
B)
&
C)
~
Answer [C]
16) Bitwise operators in Java work with?
A) boolean data like true or false
B) Real numbers like float or double
C) Individual bits of integers like byte, short, int, long and char
D) All the above
Answer [C]
17) Find operators that work as both Logical operators and Bitwise operators in Java?
A)
&, &=
B)
|, |=
C)
^, ^=
D) All the above
Answer [D]
18) If relational operators are present in an expression, what type of other operators may be used?
A) Logical operators
B) Bitwise operators
C) A and B
Answer [A]
19) What is the name of << bitwise operator in Java?
A) Right Shift Operator
B) Left Shift Operator
C) Left Shift Fill Zero operator
SUIET 2022-23 21SCS34
D) Right Shift Fill Zero operator
Answer [B]
20) What is this >> bitwise operator in Java?
A) Left shift operator
B) Right shift operator
C) Left Shift Fill Zero operator
Answer [B]
21) What is this >>> bitwise operator in Java?
A) Left Shift operator
B) Left Shift Fill Zero operator
C) Right Shift Operator
Answer [D]
22) Left Shift (<<) in Java is equivalent to?

A) Subtracting the number by 2
B) Dividing the number by 2
C) Multiplying the number by 2
D) Adding the number by 2
Answer [C]
23) Right Shift >> in Java is equivalent to?
A) Multiplying the number by 2
B) Dividing the number by 2`
C) Subtracting the number by 2
D) Adding the number by 2
Answer [B]
1. What are different types of operators in Java? Explain any two of them.
2. Discuss ternary operator with examples.
3. Differentiate >> and >>> with suitable examples.
4. Briefly explain short-circuit logical operators with examples.
5. Explain different types of iteration statements with examples.
6. Discuss various selective control structures.
7. Write a note on jump statements in Java.
8. Discuss different versions of for - loop with examples.
9. Write a program to illustrate break statement with labels.
MODULE III
1) What is a Loop in Java programming language?

A) A Loop is a block of code that is executed repeatedly as long as a condition is satisfied.

SUIET 2022-23 21SCS34
B) A Loop is a block of code that is executed only once if the condition is satisfied.
C) A Loop is a block of code that is executed more than 2 times if the condition is satisfied.
D) None
Answer [=]
2) Choose a valid loop name in Java below.
A) for
B) while
C) do while
D) All
Answer [=]
3) Every loop in Java has a condition that should be ___ in order to proceed for execution. (TRUE / FALSE)
A) FALSE
B) TRUE
C) -
D) -
Answer [=]
4) Choose the correct syntax of the WHILE loop in Java below.
A)
while(condition)
{
//statements
}
B)
while(condition);
{
//statements
}
C)
while
{
//statements
}(condition)
D) None
Answer [=]
5) Choose the correct Syntax of FOR loop in Java below.
A)
for(initialization; condition; increment-or-decrement)
{
//statements
}
SUIET 2022-23 21SCS34
B)
for(condition; increment-or-decrement; initialization)
{
//statements
}
C)
for(increment-or-decrement; condition; initialization)
{
//statements
}
D) None
Answer [=]
6) Choose the correct syntax of the DO WHILE loop in Java below.
A)
do
{
//statements
}while(condition);
B)
do
{
//statements
}while(condition)
C)
do while(condition)
{
//statements
}
D) None
Answer [=]
7) Choose the correct syntax of an Enhanced FOR loop in Java below.
A)
for(Type variable: Collection)
{
//statements

SUIET 2022-23 21SCS34
}
B)
for(Type variable; Collection)
{
//statements
}
C)
for(Collection: Type variable)
{
//statements
}
D) None
Answer [=]
8) State TRUE or FALSE. A WHILE loop in Java executes the statements at least once even the condition is
not satisfied.
A) FALSE
B) TRUE
C) -
D) -
Answer [=]
9) A BREAK statement inside a Loop like WHILE, FOR, DO WHILE and Enhanced-FOR causes the
program execution ___ Loop.
A) Exit
B) Continuation with next iteration
C) Never exit
D) None
Answer [=]
10) A CONTINUE statement inside a Loop like WHILE, FOR, DO-WHILE and Enhanced-FOR causes the
program execution ___ the loop.
A) Skip
B) Skip present iteration and continue with next iteration of the loop
C) Exit
D) None
Answer [=]
1) Java is a ___ programming language.
A) Functional
B) Object-Oriented
C) Theoretical
D) All the above
Answer [=]

SUIET 2022-23 21SCS34
2) In Java programming language, the code is placed inside ___.
A) Classes, Interfaces
B) Methods
C) Blocks
D) All the above
Answer [=]
3) Properties are implemented using ___ in Java.
A) Methods
B) Variables
C) Interfaces
D) All the above
Answer [=]
4) A Class in Java is like a ____.
A) Prototype
B) Instruction Sheet
C) Blueprint
D) All the above
Answer [=]
5) Which is the file extension used for a public Java class source code?
A) .j
B) .class
C) .java
D) None
Answer [=]
6) Which is the file extension used for a compiled Java class file?
A) .j
B) .java
C) .class
D) .cls
Answer [=]
7) State TRUE or FALSE. The source-code of An Abstract-Class or Interface is kept inside a .java file.
A) FALSE
B) TRUE
C) -
D) -
Answer [=]
8) After compilation, an Interface or Abstract-Class is kept in a ___ file in Java programming.

A) .java
B) .cls
C) .class
D) .interface
Answer [=]
9) State TRUE or FALSE. In Java, a public class or abstract-class or interface must be kept in a separate .java
file.
A) FALSE
SUIET 2022-23 21SCS34
B) TRUE
C) -
D) -
Answer [=]
10) In a .java file, how many numbers of public types namely class, interface or abstract can be managed?
A) 1
B) 2
C) 3
D) Any number
Answer [=]
11) In Java, the keyword used to declare a class is ___.
A) Class
B) Java
C) class
D) java
Answer [=]
12) A Java class can contain___.
A) Variables
B) Methods, Constructors
C) Inner Classes (A class inside another class)
D) All the above
Answer [=]
13) How many maximum numbers of objects can be created from a single Class in Java?
A) 32
B) 64
C) 256
D) None
Answer [=]
14) Creating an object from a class is also called ____.
A) Initializing
B) Instantiating
C) Interfacing
Answer [=]
15) The keyword used to create a new object in Java is ___.

A) class
B) java
C) new
D) create
Answer [=]
16) Choose the correct statements about choosing a name for a class in Java.
A) The class name can start with only a letter or underscore or dollar sign.
B) The class name can contain numbers
C) The class name can not start with a number
D) All the above
SUIET 2022-23 21SCS34
Answer [=]
17) An object is created at __ time in Java.
A) Compile-time
B) Run time
C) Assembling time
Answer [=]
18) Choose the correct statement about Java main method.
A) The main method is not a required method
B) The main method must be declared public static void.
C) you can define program flow using the main method. The Java virtual machine calls the main method directly.
D) All the above
Answer [=]
19) Choose the correct syntax for declaring a Java class below.
A)
class CLASSNAME
{
}
B)
CLASSNAME class
{
}
C)
class CLASSNAME;
{
}
D)
Class CLASSNAME
{
}
Answer [=]
20) Choose the correct way of creating an object of the below class.
class Table
{

SUIET 2022-23 21SCS34
Table(){System.out.println("Table Created");}
}
A)
Table t = new Table;
B)
Table t = new Table();
C)
Table() t = new Table();
1. Define class. Give syntax and example.

2. Briefly explain static members of the class with suitable examples.
3. Discuss method overloading. Write a program to overload a method area() to compute area of a triangle and
a circle.
4. Define a constructor. What are the salient features of Constructor? Write a Java program to show these
features.
5. How do you overload a constructor? Explain with a program.
6. Define recursion. Write a recursive program to find nth Fibonacci number.
7. Write a program to implement stack operations.
8. What are different parameter passing techniques in Java? Discuss the salient features of the same.
9. What are various access specifiers in Java? List out the behaviour of each of them.
10. Create a Java class called Student with the following details as variables (USN, Name, Branch,
Phone Number). Write a Java program to create n student objects and print USN, Name, Branch,
and Phone number with suitable heading.
11. What is inheritance? Discuss different types of inheritance with suitable example.
12. Discuss the behavior of constructors when there is a multilevel inheritance. Give appropriate code
to illustrate the process.
13. Mention and explain the uses of super keyword in Java.
14. How do you pass arguments to superclass constructor through the subclass constructor? Explain
with a code snippet.
15. Discuss usage of final keyword in Java. Give suitable examples.
16. What do you mean by method overriding? Discuss with a programming example.
17. Explain abstract class and abstract method with suitable code snippet.
18. Write a note on:
a. Use of this keyword
b. Garbage Collection in Java
c. Finalize() method
d. Object Class
e. Dynamic Method Dispatch
19. Create an abstract class called Employee. Include the members: Name, EmpID and an abstract
method cal_sal(). Create two inherited classes SoftwareEng (with the members basic and DA)
and HardwareEng (with members basic and TA). Implement runtime polymorphism (dynamic
method dispatch) to display salary of different employees by creating array of references to
superclass.

SUIET 2022-23 21SCS34
20. Differentiate method overloading and method overriding
MODULE 1V
) A Java constructor is like a method without ___.

A) statements
B) return type
C) argument list
D) None
Answer [=]
2) The name of a constructor and the name of a class are ___.
A) Same
B) Different
C) -
D) -
Answer [=]
3) The placement of a constructor inside a class should be ___.
A) Always at the beginning of class
B) Always at the end of class
C) Anywhere in the class
D) None
Answer [=]
4) The purpose of a Java constructor is ___.
A) Initialization of variables with passed data
B) Writing custom code
C) Accepting other objects as inputs
D) All the above
Answer [=]
5) Memory is allocated to an object once the execution of ___ is over in Java language.
A) main method
B) constructor
C) destructor
D) None
Answer [=]
6) What is the output of the below Java program?
public class TestingConstructor
{
void TestingConstructor()
{
System.out.println("Amsterdam");
}
SUIET 2022-23 21SCS34
TestingConstructor()
{
System.out.println("Antarctica");
}
public static void main(String[] args)

{
TestingConstructor tc = new TestingConstructor();
}
}
A) Antarctica
B) Amsterdam
C) No output
D) Compiler error
Answer [=]
7) In Java, a constructor with no parameters or no arguments is called ___ constructor.
A) Default constructor
B) User-defined constructor
C) -
D) -
Answer [=]
8) In Java, a constructor with one or more arguments or parameters is called a ___ constructor.
A) Default constructor
B) User-defined constructor or Non-default constructor
C) -
D) -
Answer [=]
9) The compiler adds a default no-argument constructor to a class if it ___.
A) does not define a constructor at all.
B) defines at least one constructor with arguments
C) -
D) -
Answer [=]
10) Overloading of constructors in Java means adding more than ___ constructors with the different
argument list.
A) 1
B) 2
C) 3
SUIET 2022-23 21SCS34
D) 8
Answer [=]
11) What is the output of the below Java program with constructors?
public class Constructor2
{
int count=10;
Constructor2(int count)
{
System.out.println("Count=" + count);
}

{
Constructor2 con = new Constructor2();
}
}
A) Count=0
B) Count=10
C) Compiler error
Answer [=]
12) A constructor can call another overloaded constructor using the ___ keyword in Java.
A) super
B) local
C) con
D) this
Answer [=]
13) What is the output of the below Java program with overloaded constructors?
{
int birds=10;
Constructor3()
{
this(20);
}
Constructor3(int birds)

SUIET 2022-23 21SCS34
{
System.out.println("Birds=" + birds);
}

{
}
}
A) Birds=0
B) Birds=10
C) Birds=20
D) Compiler error
Answer [=]
14) In Java, you can pass __ variables from one constructor to another overloaded constructor.
A) local variables
B) static variables
C) non-static variables
D) local and static variables
Answer [=]
15) Choose the correct way of calling the second constructor from the first constructor in the below code
options.
A)
Constructor5()
{
int a=30;
this('A');
}
Constructor5(char c)
{
//
}
B)
Constructor5()

SUIET 2022-23 21SCS34
{
int a=30;
this('A');
System.out.println("Success");
}
{
//
}
C)
Constructor5()
{
this('A');
System.out.println("Success");
}
{
//
}
D) All the above
Answer [=]
16) What is the output of the below Java program with many constructors?
{
Constructor7(int a)
{
System.out.println("Book=" + a);
}
Constructor7(float a)
{
System.out.println("Pen="+ a );
}
SUIET 2022-23 21SCS34
{
Constructor7 con = new Constructor7(50.5f);
}
}
A) Book=50
B) Pen=50.5
C) Compiler error
Answer [=]
17) What is the output of the below Java program with many constructors?
{
Constructor8(boolean a)
{
System.out.println("MODEM="+ a );
}
Constructor8(float a)
{
System.out.println("ROUTER=" + a);
}
{
Constructor8 con1 = new Constructor8(50);
Constructor8 con2 = new Constructor8(false);
}
}
A)
ROUTER=50.0
MODEM=false
B)
ROUTER=50
MODEM=false
C) Compiler error
D) None
Answer [=]
SUIET 2022-23 21SCS34
18) What is the output of the below Java program with overloaded constructors?
public class Jiraffe
{
Jiraffe(int sugarcanes)
{
System.out.println("Eats "+ sugarcanes + " Sugarcanes");
}
Jiraffe(int age, int...sugarcanes)
{
System.out.println("Eats "+ sugarcanes[0] + " Sugarcanes");
}
{
Jiraffe jiff2 = new Jiraffe(40);
Jiraffe jiff = new Jiraffe(5,10);
}
}
A)
2.Eats 40 Sugarcanes
B)
C) Compiler error
D) None
Answer [=]
19) Choosing a suitable overloaded constructor happens at ___ time in Java.
A) Compile-time
B) Run time
C) -
D) -
Answer [=]
20) Java constructor overloading follows ___ principle in Object-Oriented programming.
A) Inheritance
B) Encapsulation
C) Polymorphism
D) None

SUIET 2022-23 21SCS34
Answer [=]
21) Java allows calling or invoking a method from a constructor. State TRUE or FALSE.
A) TRUE
B) FALSE
C) -
D) -
Answer [=]
22) What is the output of the below Java program?

{
Constructor9()
{
show();
}
void show()
{
System.out.println("JAM JAM");
}
{
}
}
A) JAM JAM
B) No output
C) Compiler error
D) None
Answer [=]
What do you mean by a package? How do you use it in a Java program? Explain with a program.
1. How do you import a package? Explain.
2. Write a note on access protection in Java.
3. Define an interface. Explain how to define and implement an interface with an example.
4. Differentiate abstract base class and an interface.
5. How do you define variables inside interface? List out the the characteristics of such variables.
6. Define an exception. What are the key terms used in exception handling? Explain.
7. Demonstrate working of nest try block with an example.

SUIET 2022-23 21SCS34
8. Write a program which contains one method which will throw IllegalAccessException and useproper
exception handles so that exception should be printed.
9. Write a note on:
a. Java’s built-in exception
b. Uncaught Exceptions
10. How do you create your own exception class? Explain with a program.
MODULE V
1) What is a package in Java?

A) A Package is a collection of files of type Java Class, Interfaces, or Abstract Class
B) A Package is simply a Directory or Folder with Java Classes
C) A Package usually contains Java Classes written for a specific purpose or problem
D) All the above
Answer [=]
2) Choose the correct syntax of a Java Package below.
A)
package PACKAGE_NAME;
B)
package PACKAGE_NAME.*;
C)
pkg PACKAGE_NAME;
D)
pkg PACKAGE_NAME.*;
Answer [=]
3) The keyword used to declare a Java package is ____.
A) pkg
B) package
C) pkge
Answer [=]
4) What is the maximum number of Java Class files that can be kept inside a single Java Package?
A) 8
B) 64
C) 128
D) Unlimited
Answer [=]
5) Can you compile a Java file kept inside a directory without mentioning the package name?
folder_1
----- SomeFile.java
.
.
//SomeFile.java

SUIET 2022-23 21SCS34
//no package declaration
//package folder_1; commented
public class SomeFile
{
}
A) Yes
B) No
C) -
D) -
Answer [=]
6) The name of a package is the name of the ___ in Java.
A) folder
B) All parent folders separated by DOT symbols
C) All parent packages separated by DOT symbols
D) All the above
Answer [=]
7) It is possible to declare a package and import another package within the same Java class file. State TRUE
or FALSE.
A) TRUE
B) FALSE
C) -
D) -
Answer [=]
8) The keyword used to import a package into Java class or Interface is ___.
A) import
B) download
C) use
Answer [=]
9) Which is the correct syntax to import a Java package below?
A)
import PACKAGE1.*;
B)
import PACKAGE1.CLASS1;
C)
import PACKAGE1.PACKAGE2.PACKAGE3.*;
D) All the above
Answer [=]
10) Choose correct declaration and importing of packages in Java.

SUIET 2022-23 21SCS34
A)
package SOMEPACKAGE;
import PACKAGE_N.*;
B)
import PACKAGE_N.*;
C)
import PACKAGE_M.*;
import PACKAGE_N.*;
D) All the above
Answer [=]
11) You can use the same name for a Parent package and Child package in Java. State TRUE or FALSE.
A) TRUE
B) FALSE
C) -
D) -
Answer [=]
12) What is the maximum number of levels or depth up to which sub-packages can be defined in Java?
A) 8
B) 16
C) 32
D) There is no limit
Answer [=]
13) Choose a correct statement below about importing packages into a class.
A) A Java class or interface can import any number of packages.
B) It is advised to import only the required Classes of a package to save memory.
C) Java packages are usually distributed in the form of JAR files.
D) All the above
Answer [=]
14) When importing a Package, the Class is actually importing ____.
A) Classes or Interfaces from the package
B) Constants
C) Methods
Answer [=]
15) The package declaration statement should be the first statement in a Java file. State TRUE or FALSE.
A) TRUE
B) FALSE
C) -
D) -

SUIET 2022-23 21SCS34
Answer [=]
16) You can place a comment before the Package Declaration statement in Java. State TRUE or FALSE.
A) TRUE
B) FALSE
C) -
D) -
Answer [=]
) Java Enum is also called ___.
A) Enumeration
B) Numeration
C) Iteration
Answer [=]
2) Which is the keyword used to create an ENUM type in Java?
A) enum
B) Enum
C) enumeration
D) Enumeration
Answer [=]
3) An ENUM type in Java is like a ____.
A) interface
B) class
C) abstract class
Answer [=]
4) An ENUM class in Java can contain ______.
A) constructors
B) methods
C) variables and constants
D) All the above
Answer [=]
5) Which is true about enum constants in Java?
A) Enum constants have index.
B) The index starts with zero (0).
C) Enum constant can be accessed using a DOT (.) operator
D) All the above
1. Define Enumerations. Give an example.

2. Discuss values() and valueOf() methods in Enumerations with suitable examples.
3. "Enumerations in Java are class types" - justify this statement with appropriate examples.
4. Write a note on ordinal() and compareTo() methods.
5. What are wrapper classes? Explain with examples.
6. Write a program to read n integers from the keyboard and find their average.
7. Write a program to read data from keyboard and to store it into a file.
8. Write a program to read data from an existing file and to display it on console.
9. Define an Applet. Write a program to demonstrate simple applet.

SUIET 2022-23 21SCS34
10. Explain life cycle of an applet.
11. List and explain any four constructors of String class with suitable examples.
12. Write a note on following String class methods:
(i) charAt()
(ii) toCharArray()
(iii) regionMatches()
(iv) startsWith() and endsWith()
(v) replace()
(vi) trim()
(vii) substring()
13. Explain various forms of indexOf() and lastIndexOf() methods with a code snippet.
14. Differentiate StringBuffer class methods length() and capacity().
15. Write a note on StringBuffer class methods:
(i) setCharAt()
(ii) append()
(iii) insert()
(iv) reverse()
(v) delete()
(vi) deleteCharAt()
16. Write a note on
(i) instanceof Operator
(ii) static import
(iii) this()

Java Notes - Copy

Uploaded by

Java Notes - Copy

Uploaded by

SUIET 2022-23 21SCS34

OBJECT ORIENTED PROGRAMMING USING JAVA

Sub Code : 21SCS34 IA Marks : 50

On Completion of this Course students are able to,

CO5: Develop simple GUI Using applets concepts

Faculty Member HOD

Object oriented programming using java Page 1

An Overview of Java: Object-Oriented Programming, A First Simple Program, A Second Short

Introducing Classes: Class Fundamentals, Declaring Objects, Assigning Object Reference

Object oriented programming using java Page 2

Scheme of Examination for End Semester Examination of 50 Marks:

Object oriented programming using java Page 3

chu, Tata McGraw Hill education private limited, 2010.

TEACHING/LESSON PLAN (ODD Semester 2022-23)

Lesson/Teaching Plan of the Course:

Booleans, A Closer Look at Literals, ppt Java

Object oriented programming using java Page 4

Boolean Logical Operators Chalk Java

Overloading Methods, Using Objects as Java

Object oriented programming using java Page 5

Using Abstract Classes, Using final with Java

Object oriented programming using java Page 6

String Handling: The String Constructors, String Java

Object oriented programming using java Page 7

SI.NO CONTENTS PAGE NO

Object oriented programming using java Page 8

The Three OOP Principles

A First Simple Program

public static void main(String args[]) {

System.out.println("This is a simple Java program.");

Object oriented programming using java Page 10

To compile use the following command

C:\> javac Example.java

When the program is run, the following output is displayed:

This is a simple Java program.

A Closer Look at the First Sample Program

i) The program begins with the following lines

This is a multiline comment in which it is ignored by the compiler.

Example is an identifier that is the name of the class.

// Your program begins with a call to main().

iv) The next line of code is shown here:

Object oriented programming using java Page 11

public static void main(String args[]) {

System.out.println("This is a simple Java program.");

A Second Short Program

public static void main(String args[]) {

int num; // this declares a variable called num

num = 100; // this assigns num the value 100

System.out.println("This is num: " + num);

System.out.print("The value of num * 2 is ");

Object oriented programming using java Page 12

Following is the general form of a variable declaration:

Two Control Statements

Here is a program that illustrates the if statement:

Object oriented programming using java Page 13

x now greater than y

The for Loop

Using Blocks of Code

Object oriented programming using java Page 14

Consider this if statement:

for(x = 0; x<10; x++) {

Object oriented programming using java Page 15

iterates, the three statements inside the block will be executed.

Invalid identifier names include these:

Symbol Name Purpose

Object oriented programming using java Page 16

() Parentheses Used to contain lists of

[] Brackets Used to declare

, Comma Separates consecutive

The Java Keywords

abstract continue For new switch

Object oriented programming using java Page 17

The Java Class Libraries

The Primitive Types

Java defines eight primitive types of data:

Name Width Range