UNIT – I

INTRODUCTION TO OOP AND JAVA

Overview of OOP – Object oriented programming paradigms – Features of Object-Oriented
Programming – Java Buzzwords – Overview of Java – Data Types, Variables and Arrays –
Operators – Control Statements – Programming Structures in Java – Defining classes in Java
– Constructors-Methods -Access specifiers - Static members- Java Doc comments
1.1 OVERVIEW OF OOP:
Object-oriented programming (OOP) is a programming paradigm that organizes code into
objects, which are instances of classes. It provides a way to structure and design software by
representing real-world entities, their attributes, and behaviours. OOP aims to improve code
reusability, modularity, and maintainability.
1.2 OBJECT ORIENTED PROGRAMMING PARADIGMS:
• Class
• Objects
• Data Abstraction
• Encapsulation
• Inheritance
• Polymorphism
1.3 FEATURES OF OBJECT-ORIENTED PROGRAMMING:
Class: A class can be defined as a template/blueprint that describes the behaviour/state that the
object of its type support. A class is a blueprint from which individual objects are created.
Following is an example of a class.
public class Dog {
String breed;
int age;
String color;
void barking()
{
System.out.println("Working of Braking");
}
}
A class can contain any of the following variable types.
• Local variables − Variables defined inside methods, constructors or blocks are called local
variables. The variable will be declared and initialized within the method and the variable will
be destroyed when the method has completed.
• Instance variables − Instance variables are variables within a class but outside any method.
These variables are initialized when the class is instantiated. Instance variables can be accessed
from inside any method, constructor or blocks of that particular class.
• Class variables − Class variables are variables declared within a class, outside any method,
with the static keyword.
A class can have any number of methods to access the value of various kinds of methods. In
the above example, barking(), hungry() and sleeping() are methods.
Object: Objects have states and behaviours. Example: A dog has states - colour, name, breed
as well as behaviours – wagging the tail, barking, eating. An object is an instance of a class.
If we consider the real-world, we can find many objects around us, cars, dogs, humans, etc. All
these objects have a state and a behavior. If we consider a dog, then its state is - name, breed,
color, and the behavior is - barking, wagging the tail, running.
If we compare the software object with a real-world object, they have very similar
characteristics. Software objects also have a state and a behavior. A software object’s state is
stored in fields and behavior is shown via methods. So, in software development, methods
operate on the internal state of an object and the object-to-object communication is done via
methods.
Abstraction: Abstraction focuses on simplifying complex systems by breaking them down into
manageable parts. It involves creating abstract classes or interfaces that define the common
structure and behaviour for a group of related objects. Abstraction allows programmers to work
at higher levels of functionality without getting into implementation details.
A powerful way to manage abstraction is through the use of hierarchical classifications. This
allows us to layer the semantics of complex systems, breaking them into more manageable
pieces.
• Hierarchical abstractions of complex systems can also be applied to computer programs.
• The data from a traditional process-oriented program can be transformed by abstraction into
its component objects.
• A sequence of process steps can become a collection of messages between these objects.
• Thus, each of these objects describes its own unique behavior.
• We can treat these objects as concrete entities that respond to messages telling them to do
something.
Encapsulation: Encapsulation is the mechanism that binds together code and the data it
manipulates, and keeps both safe from outside interference and misuse.
• In Java, the basis of encapsulation is the class. There are mechanisms for hiding the
complexity of the implementation inside the class.
• Each method or variable in a class may be marked private or public.
• The public interface of a class represents everything that external users of the class need to
know, or may know.
• The private methods and data can only be accessed by code that is a member of the class.
• Therefore, any other code that is not a member of the class cannot access a private method or
variable.
• Since the private members of a class may only be accessed by other parts of program through
the class’s public methods, we can ensure that no improper actions take place.
Inheritance: Inheritance is the process by which one object acquires the properties of another
object.

For example, a Dog is part of the classification Mammal, which in turn is part of the Animal
class. Without the use of hierarchies, each object would need to define all of its characteristics
explicitly. However, by use of inheritance, an object need only define those qualities that make
it unique within its class. It can inherit its general attributes from its parent. Thus, inheritance
makes it possible for one object to be a specific instance of a more general case. There are five
types: Single, Multilevel, Hierarchical, Multiple and Hybrid.

Polymorphism: Polymorphism (from Greek, meaning “many forms”) allows objects of

different classes to be treated as instances of a common superclass. It enables the use of a single
interface to represent various types, providing flexibility and extensibility. Polymorphism can
be achieved through method overriding and method overloading.

For e.g., a dog’s sense of smell is polymorphic. If the dog smells a cat, it will bark and run after
it. If the dog smells its food, it will salivate and run to its bowl. The same sense of smell is at
work in both situations. The difference is what is being smelled, that is, the type of data being
operated upon by the dog’s nose.

Consider a stack (which is a last-in, first-out LIFO list). We might have a program that re-
quires three types of stacks. One stack is used for integer values, one for floating-point values,
and one for characters. The algorithm that implements each stack is the same, even though the
data being stored differs.
1.4 JAVA BUZZWORDS:

Simple:

• Java is Easy to write and more readable.

• Java has a concise, cohesive set of features that makes it easy to learn and use.
• Most of the concepts are drawn from C++, thus making Java learning simpler.

Secure:

• Java program cannot harm other system thus making it secure.

• Java provides a secure means of creating Internet applications.
• Java provides secure way to access web applications.

Portable:

• Java programs can execute in any environment for which there is a Java run-time
system.
• Java programs can run on any platform (Linux, Window, Mac)
• Java programs can be transferred over world wide web (e.g applets)

Object-oriented:

• Java programming is object-oriented programming language.

• Like C++, java provides most of the object oriented features.
• Java is pure OOP Language. (while C++ is semi object oriented)

Robust:

• Java encourages error-free programming by being strictly typed and performing run-
time checks.

Multithreaded:

• Java provides integrated support for multithreaded programming.

Architecture-neutral:

• Java is not tied to a specific machine or operating system architecture.

• Java is machine independent.
• Bytecode can be interpreted on any platform by JVM (Java Virtual Machine).

High performance:

• Bytecodes are highly optimized.

• JVM can execute bytecodes much faster.
Distributed:

• Java is designed with the distributed environment.

• Java can be transmitted over internet.

Dynamic:

• Java programs carry substantial amounts of run-time type information with them that
is used to verify and resolve accesses to objects at run time.

1.5 OVERVIEW OF JAVA:

Java is a popular general-purpose, high-level programming language that was developed by

Sun Microsystems (now owned by Oracle Corporation) in the mid-1990s. It was designed with
a focus on simplicity, portability, and security. Here's an overview of Java:

Platform Independence: Java is renowned for its platform independence. Java programs are
compiled into bytecode, which can run on any system with a Java Virtual Machine (JVM). This
"write once, run anywhere" capability makes Java highly portable across different operating
systems and hardware architectures.

Object-Oriented Programming (OOP): Java is an object-oriented language that supports the

principles of encapsulation, inheritance, polymorphism, and abstraction. It encourages the use
of objects and classes to structure code, promote reusability, and simplify software
development.

Syntax and Structure: Java's syntax is derived from C and C++, making it relatively easy for
programmers familiar with those languages to learn Java. Programs are organized into classes,
which contain methods (functions) and variables (fields). Java code is compiled into bytecode
before execution.

Standard Library: Java has an extensive standard library known as the Java Development Kit
(JDK). It provides a wide range of pre-built classes and APIs for tasks such as input/output,
networking, database connectivity, multithreading, graphical user interfaces (GUIs), and more.
The JDK also includes the Java Runtime Environment (JRE) required to run Java programs.

Memory Management: Java features automatic memory management through garbage

collection. The JVM automatically allocates and deallocates memory, relieving developers
from the burden of manual memory management. This helps in preventing common memory-
related issues like memory leaks and segmentation faults.

Exception Handling: Java has a robust exception handling mechanism. It allows developers
to handle exceptional situations during program execution, providing a structured way to catch
and handle errors, exceptions, and unexpected events.

Multithreading: Java provides built-in support for multithreading, enabling the concurrent
execution of multiple threads within a program. This allows for efficient utilization of system
resources and the development of concurrent and parallel applications.
Security: Java incorporates various security features, such as bytecode verification, class
loading restrictions, and a security manager. These measures help to create a secure execution
environment and protect against malicious code execution.

Large Community and Ecosystem: Java has a vast and active community of developers,
which has resulted in a rich ecosystem of libraries, frameworks, and tools. These resources
offer extensive support, open-source contributions, and a wide range of solutions for diverse
application development needs.

Application Domains: Java is used for a variety of applications, including enterprise software
development, web development (Java EE), mobile app development (Android), scientific and
numerical computing, game development, and more.

1.6 DATA TYPES, VARIABLES AND ARRAYS

Data Types:

Java is a statically typed and also a strongly typed language. In Java, each type of data (such
as integer, character, hexadecimal, etc.) is predefined as part of the programming language and
all constants or variables defined within a given program must be described with one of the
data types. Data types represent the different values to be stored in the variable. In java, there
are two categories of data types:

• Primitive data types

• Non-primitive data types

Non-Primitive Data Types:

• Array
• Class
 • String
• Interface

Primitive Data Types:

Java defines eight primitive types of data: byte, short, int, long, char, float, double, and boolean.
The primitive types are also commonly referred to as simple types and they are grouped into
the following four groups:

i) Integers - This group includes byte, short, int, and long. All of these are signed, positive and
negative values. The width and ranges of these integer types vary widely, as shown in the
following table:
Name Width in bits 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

Table: Integer Data Types

ii) Floating-point numbers – They are also known as real numbers. This group includes float
and double, which represent single- and double-precision numbers, respectively. The width and
ranges of them are shown in the following table:
Name Width in bits Range
double 64 4.9e–324 to 1.8e+308
float 32 1.4e–045 to 3.4e+038

Table: Floating-point Data Types

iii) Characters - This group includes char, which represents symbols in a character set, like
letters and numbers. char is a 16-bit type. The range of a char is 0 to 65,536. There are no
negative chars.

iv) Boolean - This group includes Boolean. It can have only one of two possible values, true
or false.

Variables:

A variable is the holder that can hold the value while the java program is executed. A variable
is assigned with a datatype. It is name of reserved area allocated in memory. In other words, it
is a name of memory location. There are three types of variables in java: local, instance and
static.

A variable provides us with named storage that our programs can manipulate. Each variable in
Java has a specific type, which determines the size and layout of the variable’s memory; the
range of values that can be stored within that memory; and the set of operations that can be
applied to the variable.
Before using any variable, it must be declared. The following statement expresses the basic
form of a variable declaration –

datatype variable [ = value][, variable [ = value] ...] ;

Here data type is one of Java’s data types and variable is the name of the variable. To de- clare
more than one variable of the specified type, use a comma-separated list.

Example

int a, b, c; // Declaration of variables a, b, and c. int a = 20, b = 30; // initialization

byte B = 22; // Declaratrion initializes a byte type variable B.

Types of Variables

There are three types of variables in java:

• local variable

• instance variable

• static variable

Fig. Types of variables

Local Variable:

• Local variables are declared inside the methods, constructors, or blocks.

• Local variables are created when the method, constructor or block is entered

• Local variable will be destroyed once it exits the method, constructor, or block.

• Local variables are visible only within the declared method, constructor, or block.

• Local variables are implemented at stack level internally.

• There is no default value for local variables, so local variables should be declared and
an initial value should be assigned before the first use.

• Access specifiers cannot be used for local variables.

Instance Variable:

• A variable declared inside the class but outside the method, is called instance variable.
Instance variables are declared in a class, but outside a method, constructor or any block.

• A slot for each instance variable value is created when a space is allocated for an

object in the heap.

• Instance variables are created when an object is created with the use of the keyword
‘new’ and destroyed when the object is destroyed.

• Instance variables hold values that must be referenced by more than one method,
constructor or block, or essential parts of an object’s state that must be present throughout the
class.

• Instance variables can be declared in class level before or after use.

• Access modifiers can be given for instance variables.

• The instance variables are visible for all methods, constructors and block in the class.
It is recommended to make these variables as private. However, visibility for subclasses can be
given for these variables with the use of access modifiers.

• Instance variables have default values.

○ numbers, the default value is 0,

○ Booleans it is false,

○ Object references it is null.

• Values can be assigned during the declaration or within the constructor.

• Instance variables cannot be declared as static.

• Instance variables can be accessed directly by calling the variable name inside the class.
However, within static methods (when instance variables are given accessibility), they should
be called using the fully qualified name. ObjectReference.VariableName.

Static variable:

• Class variables also known as static variables are declared with the static keyword in a
class, but outside a method, constructor or a block.

• Only one copy of each class variable per class is created, regardless of how many
objects are created from it.
• Static variables are rarely used other than being declared as constants. Constants are
variables that are declared as public/private, final, and static. Constant variables never change
from their initial value.

• Static variables are stored in the static memory. It is rare to use static variables other
than declared final and used as either public or private constants.

• Static variables are created when the program starts and destroyed when the program
stops.

• Visibility is same as instance variables. However, most static variables are declared
public since they must be available for users of the class.

• Default values are same as instance variables.

○ numbers, the default value is 0;

○ Booleans, it is false;

○ Object references, it is null.

• Values can be assigned during the declaration or within the constructor. Additionally,
values can be assigned in special static initializer blocks.

• Static variables cannot be local.

• Static variables can be accessed by calling with the class name ClassName.
VariableName.

• When declaring class variables as public static final, then variable names (constants)
are all in upper case. If the static variables are not public and final, the naming syntax is the
same as instance and local variables.

Array:

Array is a collection of elements of similar data type stored in contiguous memory location.
The array size is fixed i.e we can’t increase/decrease its size at runtime. It is index based and
the first element is stored at 0th index.

Advantages of Array:

• Code Optimization: Multiple values can be stored under common name. Date retrieval
or sorting is an easy process.
• Random access: Data at any location can be retrieved randomly using the index.

Disadvantages of Array:

• Inefficient memory usage: Array is static. It is not resizable at runtime based on number
of user’s input. To overcome this limitation, Java introduce collection concept.

Types of Arrays

There are two types of arrays:

• One Dimensional Array

• Multidimensional Array

• Dynamic Array

• Jagged Array

One Dimensional Array:

Declaring Array Variables: The syntax for declaring an array variable is

Syntax:

dataType[] arrayName; //preferred way

Or

dataType arrayName [];

Here datatype can be a primitive data type like: int, char, Double, byte etc. arrayName is an
identifier.

Example:

int[] a;

Instantiation of an Array: Array can be created using the new keyword. To allocate memory
for array elements we must mention the array size. The size of an array must be specified by
an int value and not long or short. The default initial value of elements of an array is 0 for
numeric types and false for boolean.

Syntax:

arrayName=new datatype[size];

Or

dataType[] arrayName=new datatype[size]; //declaration and instantiation

Example:

int[] a=new int[5]; //defining an integer array for 5 elements Alternatively, we can create
and initialize array using following syntax.

Syntax:

dataType[] arrayName=new datatype[]{

list of values separated by comma};

Or

dataType[] arrayName={

list of values separated by comma};

Example:

int[] a={12,13,14};

int[] a=new int[]{12,13,14};

The built-in length property is used to determine length of the array i.e. number of ele- ments
present in an array.

Accessing array elements: The array elements can be accessed by using indices. The index
starts from 0 and ends at (array size-1). Each element in an array can be accessed using for
loop.

Example:

Program to access array elements.

class Main{

public static void main(String args[]){

int a[]=new int[]{10,20,30,40}; //declaration and initialization

//printing array

for(int i=0;i<a.length;i++) //length is the property of array

System.out.println(a[i]);

}}

Sample Output:

10
20

30

40

The for-each loop: The for-each loop is used to traverse the complete array sequentially
without using an index variable. It’s commonly used to iterate over an array or a Collections
class (eg, Array- List).

Syntax:

for(type var:arrayName){

Statements using var;

Example:

Program to calculate sum of array elements.

class Main{

public static void main(String args[]){

int a[]=new int[]{10,20,30,40}; //declaration and initialization int sum=0;

for(int i:a) // calculate sum of array elements

sum+=i;

System.out.println(“Sum:”+sum);

}}

Sample Output:

Sum:100

Multidimensional Arrays: Multidimensional arrays are arrays of arrays with each element of
the array holding the reference of other array. These are also known as Jagged Arrays.

Syntax:

dataType[][] arrayName=new datatype[rowsize][columnnsize]; // 2 dimensional array

dataType[][][] arrayName=new datatype[][][]; // 3 dimensional array

Example:

int[][] a=new int[3][4];

Example:

Program to access 2D array elements

class TwoDimEx

public static void main(String args[])

// declaring and initializing 2D array

int arr[][] = { {1,1,12},{2,16,1},{12,42,2} };

// printing 2D array

for (int i=0; i< arr.length; i++)

for (int j=0; j < arr[i].length ; j++)

System.out.print(arr[i][j] + “ “);

System.out.println();

}}}

Sample Output:

1 1 12

2 16 1

12 42 2
Jagged Array: Jagged array is an array of arrays with different row size i.e. with different
dimensions.

Example:

class Main {

public static void main(String[] args) {

int[][] a = {

{11, 3, 43},

{3, 5, 8, 1},

{9},

};

System.out.println(“Length of row 1: “ + a[0].length);

System.out.println(“Length of row 2: “ + a[1].length);

System.out.println(“Length of row 3: “ + a[2].length);

}}

Sample Output:

Length of row 1: 3

Length of row 2: 4

Length of row 3: 1

Passing an array to a method: An array can be passed as parameter to method.

Example:

Program to find minimum element in an array

class Main{

static void min(int a[]){

int min=a[0];

for(int i=1;i<a.length;i++)

if(min>a[i])
min=a[i];

System.out.println(“Minimum:”+min);

public static void main(String args[]){

int a[]={12,13,14,5};

min(a);//passing array to method

}}

Sample Output:

Minimum:5

Returning an array from a method: A method may also return an array.

Example:

Program to sort array elements in ascending order.

class Main{

static int[] sortArray(int a[]){ int tmp;

for(int i=0;i<a.length-1;i++) { //code for sorting

for(int j=i+1;j<=a.length-1;j++) {

if(a[i]>a[j]){

tmp=a[i];

a[i]=a[j];

a[j]=tmp;

}}}

return(a); // returning array

public static void main(String args[]){

int a[]={33,43,24,5};

a=sortArray(a); //passing array to method

1.7 OPERATORS:

Operator in java is a symbol that is used to perform operations. Java provides a rich set of
operators to manipulate variables.For example: +, -, *, / etc.

All the Java operators can be divided into the following groups −

Arithmetic Operators:

• Multiplicative : * / %
• Additive :+-

Relational Operators

• Comparison : < > <= >= instanceof

• Equality : == !=

Bitwise Operators

• bitwise AND : &

• bitwise exclusive OR : ^
• bitwise inclusive OR : |
• Shift operator: << >> >>>

Logical Operators

• logical AND : &&

• logical OR : ||
• logical NOT : ~ !

Assignment Operators:

• =

Ternary operator:

• ?:

Unary operator:

• Postfix : expr++ expr—

• Prefix : ++expr --expr +expr -expr

The Arithmetic Operators:

Arithmetic operators are used to perform arithmetic operations in the same way as they are
used in algebra. The following table lists the arithmetic operators −
Example:

int A=10, B=20;

Operator Description Example Output

+ (Addition) Adds values A & B. A+B 30
- (Subtraction) Subtracts B from A A-B -10
* (Multiplication) Multiplies values A & B A*B 200
/ (Division) Divides B by A B/A 2
Divides left-hand operand by right-
% (Modulus) B%A 0
hand operand and returns remainder.

// Java program to illustrate arithmetic operators

public class Aoperators

public static void main(String[] args)

int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;

String x = “Thank”, y = “You”;

System.out.println(“a + b = “+(a + b));

System.out.println(“a - b = “+(a - b));

System.out.println(“x + y = “+x + y);

System.out.println(“a * b = “+(a * b));

System.out.println(“a / b = “+(a / b));

System.out.println(“a % b = “+(a % b));

The Relational Operators: The following relational operators are supported by Java language.

Example:

int A=10,B=20;
 Operator Description Example Output
Checks if the values of two operands are equal or
== (equal to) not, if yes then condition becomes true. (A == B) true

Checks if the values of two operands are equal or

!= (not equal to) not, if values are not equalthen condition becomes (A != B) true
true.
Checks if the value of left operand is greater than
> (greater than) the value of right operand, if yes then condition (A > B) true
becomes true.
Checks if the value of left operand is less than the
< (less than) value of right operand, if yes then condition (A < B) true
becomes true.
Checks if the value of left operand is greater than
>= (greater than or or equal to the value of right operand, if yes then
(A >= B) true
equal to) condition be-comes true.

Checks if the value of left operand is less than or

<= (less than or equal to the value of right operand, if yes then
(A <= B) true
equal to) condition becomestrue.

checks whether the object is of a partic-ular type boolean re-

(class type or interface type) sult = name
instance of Operator True
(Object reference variable ) instanceof instanceof
(class/interface type) String;

// Java program to illustrate relational operators

public class operators

public static void main(String[] args)

int a = 20, b = 10; boolean condition = true;

//various conditional operators System.out.println(“a == b :” + (a == b)); System.out.println(“a

< b :” + (a < b)); System.out.println(“a <= b :” + (a <= b)); System.out.println(“a > b :” + (a >
b)); System.out.println(“a >= b :” + (a >= b)); System.out.println(“a != b :” + (a != b));

System.out.println(“condition==true :” + (condition == true));

}}
Bitwise Operators:

Java supports several bitwise operators, that can be applied to the integer types, long, int, short,
char, and byte. Bitwise operator works on bits and performs bit-by-bit operation.

Example:

int a = 60,b = 13;

binary format of a & b will be as follows −

a = 0011 1100

b = 0000 1101

Bitwise operators follow the truth table:

a b a&b a|b a^b ~a

0 0 0 0 1 1
0 1 0 1 0 1
1 0 0 1 0 0
1 1 1 1 1 0

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a = 1100 0011

The following table lists the bitwise operators −

int A=60,B=13;

Operator Description Example Output

& (bit- Binary AND Operator copies a bit to (A & B) will give 12 12
wise and) the result if it exists in bothoperands. which is (in binary
form:0000
1100)
| (bitwise Binary OR Operator copies a bit (A | B) 61
or) if it exists in either operand. (in binary form:
0011 1101)
^ (bitwise Binary XOR Operator copies thebit if (A ^ B) will give 49 49
XOR) it is set in one operand but not both. which is 0011 0001 (in binary form:
0011 0001)
~ (bitwise Binary Ones Complement Opera-tor is (~A) will give -61 -61
compli- unary and has the effect of ‘flipping’ which is 1100 0011 in (in binary form:
ment) bits. 2’s complement form 1100 0011)
due to a signedbinary
number.
<< (left The left operands value is movedleft A << 2 will give 240 240
shift) by the number of bits speci- fied by the which is 1111 0000 (in binary form:
right operand. 1111 0000)

>> (right The left operands value is moved right A >> 2 will give 15 15
by the number of bits speci- fied by the
shift) which is 1111 (in binary form:
right operand.
1111)
>>> (zero The left operands value is moved right A >>>2 will give 15 15
fill right by the number of bits speci- fied by the
shift) which is 0000 1111 (in binary form:
right operand and shifted values are
filled up with zeros. 0000 1111)

// Java program to illustrate bitwise operators

public class operators

public static void main(String[] args)

int a = 10;

int b = 20;

System.out.println(“a&b = “ + (a & b));

System.out.println(“a|b = “ + (a | b));

System.out.println(“a^b = “ + (a ^ b));

System.out.println(“~a = “ + ~a);

}}

Logical Operators:

The following are the logical operators supported by java.

Example:

A=true;

B=false;

Operator Description Example Ouptput

&& (logical If both the operands are non-zero,
(A && B) false
and) then the condition becomes true.
|| (logical or) If any of the two operands are non-
zero, then the condition becomes (A || B) true
true.
! (logical not) Use to reverses the logical state of its
operand. If a condition is true then
!(A && B) true
Logical NOT operator will make
false.

Assignment Operators:

The following are the assignment operators supported by Java.

Operator Description Example

=
C = A + B will as-
(Simple Assigns values from right side oper- sign value of
assignment ands to left side operand.
A + B into C
operator)
+=
(Add AND It adds right operand to the left operand C += A is equiva-
assignment and assigns the result to left operand. lent to C = C + A
operator)
-=
(Subtract It subtracts right operand from the left
C -= A is equiva-
AND operand and assigns the result to left
lent to C = C – A
assignment operand.
operator)
*=
(Multiply It multiplies right operand with the left
C *= A is equiva-
AND operand and assigns the result to left
lent to C = C * A
assignment operand.
operator)
 /= It divides left operand with the right
operand and assigns the result to left
(Divide operand. C /= A is equiva-
AND lent to C = C / A
assignment
operator)
%=
(Modulus AND It takes modulus using two operands C %= A is equiva-
assign-ment and assigns the result to left operand. lent to C = C % A
opera- tor)

C <<= 2 is same
<<= Left shift AND assignment operator.
asC = C << 2
C >>= 2 is same
>>= Right shift AND assignment operator.
asC = C >> 2

C &= 2 is same
&= Bitwise AND assignment operator.
asC = C & 2

bitwise exclusive OR and assignment C ^= 2 is same

^=
operator. asC = C ^ 2

bitwise inclusive OR and assignment C |= 2 is same as C

|=
operator. =C|2

// Java program to illustrate assignment operators

public class operators

public static void main(String[] args)

int a = 20, b = 10, c, d, e = 10, f = 4, g = 9;

c = b;

System.out.println(“Value of c = “ + c);

a += 1;

b -= 1;
e *= 2;

f /= 2;

System.out.println(“a, b, e, f = “ +a + “,” + b + “,” + e + “,” + f);

}}

Ternary Operator:

Conditional Operator ( ? : )

Since the conditional operator has three operands, it is referred as the ternary operator. This
operator consists of three operands and is used to evaluate Boolean expressions. The goal of
the operator is to decide, which value should be assigned to the variable. The operator is written
as –

variable x = (expression) ? value if true : value if false

Example:

public class example

public static void main(String args[]) {

int a, b;

a = 10;

b = (a == 0) ? 20: 30;

System.out.println( “b : “ + b );

}}

Unary Operators:

Unary operators use only one operand. They are used to increment, decrement or negate a
value.

Operator Description
- Unary minus negating the values
+ Unary plus converting a negative value to positive
++ :Increment operator incrementing the value by 1
— : Decrement operator decrementing the value by 1
! : Logical not operator inverting a boolean value
// Java program to illustrate unary operators

public class operators

public static void main(String[] args)

int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;

boolean condition = true; c = ++a;

System.out.println(“Value of c (++a) = “ + c); c = b++;

System.out.println(“Value of c (b++) = “ + c); c = --d;

System.out.println(“Value of c (--d) = “ + c); c = --e;

System.out.println(“Value of c (--e) = “ + c);

System.out.println(“Value of !condition =” + !condition);

}}

Precedence of Java Operators

Operator precedence determines the grouping of operands in an expression. This affects how
an expression is evaluated. Certain operators have higher precedence than others; for example,
the multiplication operator has higher precedence than the addition operator –

For example, the following expression,

x = 10 + 5 * 2;

is evaluated. So, the output is 20, not 30. Because operator * has higher precedence than +.

The following table shows the operators with the highest precedence at the top of the table and
those with the lowest at the bottom. Within an expression, higher precedence operators will be
evaluated first.

Category Operator Associativity

Postfix >() [] . (dot operator) Left to right
Unary >++ - - ! ~ Right to left
Multiplicative >* / Left to right
Additive >+ - Left to right
Shift >>> >>> << Left to right
 Relational >> >= < <= Left to right
Equality >== != Left to right
Bitwise AND >& Left to right
Bitwise XOR >^ Left to right
Bitwise OR >| Left to right
Logical AND >&& Left to right
Logical OR >|| Left to right
Conditional ?: Right to left
Assignment >= += -= *= /= %= >>= Right to left
<<= &= ^= |=

1.8 CONTROL STATEMENTS:

Java Control statements control the flow of execution in a java program, based on data val- ues
and conditional logic used. There are three main categories of control flow statements;

Selection statements: if, if-else and switch.

Loop statements: while, do-while and for.

Transfer statements: break, continue, return, try-catch-finally and assert.

Selection statements: The selection statements check the condition only once for the program
execution.

If Statement:

The if statement executes a block of code only if the specified expression is true. If the value
is false, then the if block is skipped and execution continues with the rest of the pro- gram.

The simple if statement has the following syntax: if (<conditional expression>)

<statement action>

The following program explains the if statement.

public class programIF{

public static void main(String[] args)

int a = 10, b = 20;

if (a > b)
System.out.println(“a > b”);

if (a < b)

System.out.println(“b < a”);

}}

The If-else Statement:

The if/else statement is an extension of the if statement. If the condition in the if statement fails,
the statements in the else block are executed. The if-else statement has the following syntax:

if (<conditional expression>)

<statement action>

else

<statement action>

The following program explains the if-else statement.

public class ProgramIfElse

public static void main(String[] args)

int a = 10, b = 20; if (a > b)

System.out.println(“a > b”);

else

System.out.println(“b < a”);

}}}

Switch Case Statement:

The switch case statement is also called as multi-way branching statement with several choices.
A switch statement is easier to implement than a series of if/else statements. The switch
statement begins with a keyword, followed by an expression that equates to a no long integral
value.

After the controlling expression, there is a code block that contains zero or more labeled cases.
Each label must equate to an integer constant and each must be unique. When the switch
statement executes, it compares the value of the controlling expression to the values of each
case label.

The program will select the value of the case label that equals the value of the control- ling
expression and branch down that path to the end of the code block. If none of the case label
values match, then none of the codes within the switch statement code block will be executed.

Java includes a default label to use in cases where there are no matches. A nested switch within
a case block of an outer switch is also allowed. When executing a switch statement, the flow
of the program falls through to the next case. So, after every case, you must insert a break
statement.

The syntax of switch case is given as follows:

switch (<non-long integral expression>) {

case label1: <statement1> case label2: <statement2>

case labeln: <statementn>

default: <statement>

} // end switch

The following program explains the switch statement.

public class ProgramSwitch

public static void main(String[] args)

int a = 10, b = 20, c = 30; int status = -1;

if (a > b && a > c)

status = 1;

}
else if (b > c)

status = 2;

else

status = 3;

switch (status)

case 1:System.out.println(“a is the greatest”);

break;

case 2:System.out.println(“b is the greatest”); break;

case 3:System.out.println(“c is the greatest”); break;

default:System.out.println(“Cannot be determined”);

}}}

Iteration statements: Iteration statements execute a block of code for several numbers of times
until the condition is true.

While Statement

The while statement is one of the looping constructs control statement that executes a block of
code while a condition is true. The loop will stop the execution if the testing expres- sion
evaluates to false. The loop condition must be a boolean expression.

The syntax of the while loop is

while (<loop condition>)

<statements>

The following program explains the while statement.

public class ProgramWhile

{

public static void main(String[] args)

int count = 1;

System.out.println(“Printing Numbers from 1 to 10”);

while (count <= 10)

System.out.println(count++);}

}}}

Do-while Loop Statement

The do-while loop is similar to the while loop, except that the test condition is performed at the
end of the loop instead of at the beginning. The do—while loop executes atleast once without
checking the condition.

It begins with the keyword do, followed by the statements that making up the body of the loop.
Finally, the keyword while and the test expression completes the do-while loop. When the loop
condition becomes false, the loop is terminated and execution continues with the statement
immediately following the loop.

The syntax of the do-while loop is

do

<loop body>

while (<loop condition>);

The following program explains the do--while statement.

public class DoWhileLoopDemo {

public static void main(String[] args) {

int count = 1;

System.out.println(“Printing Numbers from 1 to 10”);

do {

System.out.println(count++);
} while (count <= 10);

}}

For Loop

The for loop is a looping construct which can execute a set of instructions for a specified
number of times. It’s a counter controlled loop.

The syntax of the loop is as follows:

for (<initialization>; <loop condition>; <increment expression>)

<loop body>

• initialization statement executes once before the loop begins. The <initialization>
section can also be a comma-separated list of expression statements.

• test expression. As long as the expression is true, the loop will continue. If this
expression is evaluated as false the first time, the loop will never be executed.

• Increment (Update) expression that automatically executes after each repetition of the
loop body.

• All the sections in the for-header are optional. Any one of them can be left empty, but
the two semicolons are mandatory.

The following program explains the for statement.

public class ProgramFor {

public static void main(String[] args) {

System.out.println(“Printing Numbers from 1 to 10”);

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

System.out.println(count);

}}}

Transfer statements: Transfer statements are used to transfer the flow of execution from one
statement to an- other.

Continue Statement

A continue statement stops the current iteration of a loop (while, do or for) and causes execution
to resume at the top of the nearest enclosing loop. The continue statement can be used when
you do not want to execute the remaining statements in the loop, but you do not want to exit
the loop itself.
The syntax of the continue statement is

continue; // the unlabeled form continue

<label>; // the labeled form

It is possible to use a loop with a label and then use the label in the continue statement. The
label name is optional, and is usually only used when you wish to return to the outermost loop
in a series of nested loops.

The following program explains the continue statement.

public class ProgramContinue {

public static void main(String[] args) {

System.out.println(“Odd Numbers”);

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

if (i % 2 == 0)

continue;

System.out.println(i + “\t”);

}}}

Break Statement

The break statement terminates the enclosing loop (for, while, do or switch statement). Break
statement can be used when we want to jump immediately to the statement following the
enclosing control structure. As continue statement, can also provide a loop with a label, and
then use the label in break statement. The label name is optional, and is usually only used when
you wish to terminate the outermost loop in a series of nested loops.

The Syntax for break statement is as shown below;

break; // the unlabeled form break <label>; // the labeled form

The following program explains the break statement.

public class ProgramBreak {

public static void main(String[] args) {

System.out.println(“Numbers 1 - 10”);

for (int i = 1;; ++i) {

if (i == 11)
break; // Rest of loop body skipped when i is even

System.out.println(i + “\t”);

}}}

The transferred statements such as try-catch-finally, throw will be explained in the later
chapters.

1.9 PROGRAMMING STRUCTURES IN JAVA:

Java Comments

The java comments are statements that are not executed by the compiler and interpreter. The
comments can be used to provide information or explanation about the variable, method, class
or any statement. It can also be used to hide program code for specific time.

Types of Java Comments: There are 3 types of comments in java.

a) Single Line Comment

b) Multi Line Comment
c) Documentation Comment

a) Java Single Line Comment

The single line comment is used to comment only one line. A single-line comment begins with
a // and ends at the end of the line.
Syntax Example
//Comment //This is single line comment

b) Java Multi Line Comment

This type of comment must begin with /* and end with */. Anything between these two
comment symbols is ignored by the compiler. A multiline comment may be several lines long.

Syntax Example
/*Comment starts /* This is a

continues multi line

continues comment */

Commnent ends*/
c) Java Documentation Comment

This type of comment is used to produce an HTML file that documents our program. The
documentation comment begins with a /** and ends with a */.

Syntax Example
/**Comment start /**

* This

*tags are used in order to specify a parameter is

*or method or heading documentation

*HTML tags can also be used comment

*such as <h1> */

*comment ends*/

DEFINING CLASSES IN JAVA:

A class is an entity that determines how an object will behave and what the object will contain.
A class is the basic building block of an object-oriented language such as Java. It is acting as a
template that describes the data and behavior associated with instances of that class.

When you instantiate a class means creating an object. The class contains set of variables and
methods.

The data associated with a class or object is stored in variables; the behaviour associated with
a class or object is implemented with methods. A class is a blueprint from which individual
objects are created.

class MyClass {

// field,

//constructor, and

// method declarations

Example:

class Myclass{

public static void main(String[] args)

{

System.out.println(“Hello World!”); //Display the string.

}}

The keyword class begins the class definition for a class named name. The variables and
methods of the class are embraced by the curly brackets that begin and end the class definition
block. The “Hello World” application has no variables and has a single method named main.

In Java, the simplest form of a class definition is

class name {

...

In general, class declarations can include these components, in order:

1. Modifiers: A class can be public or has default access.

2. Class name: The name should begin with a initial letter.

3. Superclass (if any): The name of the class’s parent (superclass), if any, preceded by
the keyword extends. A class can only extend (subclass) one parent.

4. Interfaces (if any): A comma-separated list of interfaces implemented by the class, if

any, preceded by the keyword implements. A class can implement more than one interface.

5. Body: The class body surrounded by braces, { }.

1.10 CONSTRUCTORS:

Every class has a constructor. If the constructor is not defined in the class, the Java com- piler
builds a default constructor for that class. While a new object is created, at least one constructor
will be invoked. The main rule of constructors is that they should have the same name as the
class. A class can have more than one constructor.

Constructors are used for initializing new objects. Fields are variables that provide the state of
the class and its objects, and methods are used to implement the behavior of the class and its
objects.

Rules for writing Constructor

• Constructor(s) of a class must have same name as the class name in which it resides.

• A constructor in Java cannot be abstract, final, static and synchronized.

• Access modifiers can be used in constructor declaration to control its access i.e which
other class can call the constructor.

Example

public class myclass {

public myclass() {

// Constructor

public myclass(String name) {

// This constructor has one parameter, name.

}}

Types of Constructors: There are two types of constructor in Java:

1. No-argument constructor:

A constructor that has no parameter is known as default constructor. If the constructor is not
defined in a class, then compiler creates default constructor (with no arguments) for the class.
If we write a constructor with arguments or no-argument then compiler does not create
default constructor. Default constructor provides the default values to the object like 0, null
etc. depending on the type.

// Java Program to illustrate calling a no-argument constructor

import java.io.*;

class myclass

int num;

String name;

// this would be invoked while object of that class created. myclass()

System.out.println(“Constructor called”);

}}

class myclassmain
{

public static void main (String[] args)

// this would invoke default constructor.

myclass m1 = new myclass();

// Default constructor provides the default values to the object like 0, null

System.out.println(m1.num);

System.out.println(m1.name);

}}

2. Parameterized Constructor

A constructor that has parameters is known as parameterized constructor. If we want to

initialize fields of the class with your own values, then use parameterized constructor.

// Java Program to illustrate calling of parameterized constructor.

import java.io.*; class myclass

// data members of the class. String name;

int num;

// contructor with arguments. myclass(String name, int n)

this.name = name; this.num = n;

}}

class myclassmain{

public static void main (String[] args)

// this would invoke parameterized constructor.

myclass m1 = new myclass(“Java”, 2017);

System.out.println(“Name :” + m1.name + “ num :” + m1.num);

}}

There are no “return value” statements in constructor, but constructor returns current class
instance. We can write ‘return’ inside a constructor.

Constructor Overloading

Like methods, we can overload constructors for creating objects in different ways. Compiler
differentiates constructors on the basis of numbers of parameters, types of the parameters and
order of the parameters.

// Java Program to illustrate constructor overloading

import java.io.*;

class myclass

// constructor with one argument

myclass (String name)

System.out.println(“Constructor with one “ + “argument - String : “ + name);

// constructor with two arguments

myclass (String name, int id)

System.out.print(“Constructor with two arguments : “ +” String and Integer : “ + name + “ “+

id);

// Constructor with one argument but with different type than previous.

myclass (long num)

System.out.println(“Constructor with one argument : “ +”Long : “ + num);

}}
class myclassmain

public static void main(String[] args)

myclass m1 = new myclass (“JAVA”);

myclass m2 = new myclass (“Python”, 2017);

myclass m3 = new myclass(3261567);

}}

Constructors are different from methods in Java

• Constructor(s) must have the same name as the class within which it defined while it

is not necessary for the method in java.

• Constructor(s) do not any return type while method(s) have the return type or void if

does not return any value.

• Constructor is called only once at the time of Object creation while method(s) can be
called any numbers of time.

Creating an Object

The class provides the blueprints for objects. The objects are the instances of the class. In Java,
the new keyword is used to create new objects.

There are three steps when creating an object from a class −

• Declaration − A variable declaration with a variable name with an object type.

• Instantiation − The ‘new’ keyword is used to create the object.

• Initialization − The ‘new’ keyword is followed by a call to a constructor. This call

initializes the new object.

1.11 METHODS:

A method is a collection of statement that performs specific task. In Java, each method is a part
of a class and they define the behavior of that class. In Java, method is a jargon used for method.

Advantages of methods

• Program development and debugging are easier

• Increases code sharing and code reusability

• Increases program readability

• It makes program modular and easy to understanding

• It shortens the program length by reducing code redundancy

Types of methods

There are two types of methods in Java programming:

• Standard library methods (built-in methods or predefined methods)

• User defined methods

Standard library methods

The standard library methods are built-in methods in Java programming to handle tasks such
as mathematical computations, I/O processing, graphics, string handling etc. These methods
are already defined and come along with Java class libraries, organized in packages. In order
to use built-in methods, we must import the corresponding packages. Some of library methods
are listed below.
Packages Library Methods Descriptions
java.lang.Math acos() Computes arc cosine of the argument
All maths related methods exp() Computes the e raised to given power
are defined in this class
abs() Computes absolute value of argument
log() Computes natural logarithm
sqrt() Computes square root of the argument
pow() Computes the number raised to given
power
java.lang.String charAt() Returns the char value at the specified
index.
All string related methods concat()
are defined in this class compareTo() Concatenates two string

indexOf() Compares two string

Returns the index of the first occurrence
of the given character
toUpperCase()
converts all of the characters in the String
to upper case
I

java.awt add() nserts a component

contains classes for setSize() set the size of the component
graphics
setLayout() defines the layout manager
 setVisible() changes the visibility of the component

Example:

Program to compute square root of a given number using built-in method. public class MathEx
{

public static void main(String[] args) { System.out.print(“Square root of 14 is: “ +

Math.sqrt(14));

Sample Output:

Square root of 14 is: 3.7416573867739413

User-defined methods

The methods created by user are called user defined methods. Every method has the following.

• Method declaration (also called as method signature or method prototype)

• Method definition (body of the method)

• Method call (invoke/activate the method)

Method Declaration

The syntax of method declaration is:

Syntax:

return_type method_name(parameter_list);

Here, the return_type specifies the data type of the value returned by method. It will be void if
the method returns nothing. method_name indicates the unique name assigned to the method.
parameter_list specifies the list of values accepted by the method.

Method Definition

Method definition provides the actual body of the method. The instructions to complete a
specific task are written in method definition. The syntax of method is as follows:

Syntax:

modifier return_type method_name(parameter_list){

// body of the method

}

Here,

Modifier – Defines the access type of the method i.e accessibility re- gion of method
in the application

return_type – Data type of the value returned by the method or void if method returns
nothing

method_name – Unique name to identify the method. The name must follow the rules of
identifier

parameter_list – List of input parameters separated by comma. It must be like datatype

parameter1,datatype parameter2,……

List will be empty () in case of no input parameters.

method body – block of code enclosed within { and } braces to perform specific task

The first line of the method definition must match exactly with the method prototype. A method
cannot be defined inside another method.

Method Call

A method gets executed only when it is called. The syntax for method call is.

Syntax:

method_name(parameters);

When a method is called, the program control transfers to the method definition where the
actual code gets executed and returns back to the calling point. The number and type of
parameters passed in method call should match exactly with the parameter list mentioned in
method prototype.
Example:

Memory allocation for methods calls

Method calls are implemented using stack. When a method is called, the parameters passed in
the call, local variables defined inside method, and return value of the method are stored in
stack frame. The allocated stack frame gets deleted automatically at the end of method
execution.

Types of User-defined methods

The methods in C are classified based on data flow between calling method and called method.
They are:

• Method with no arguments and no return value

• Method with no arguments and a return value

• Method with arguments and no return value

• Method with arguments and a return value.

Method with no arguments and no return value

In this type of method, no value is passed in between calling method and called method. Here,
when the method is called program control transfers to the called method, executes the method,
and return back to the calling method.

Example:

Program to compute addition of two numbers (no argument and no return value)

public class Main{

public void add(){ // method definition with no arguments and no return value

int a=10,b=20;

System.out.println(“Sum:”+(a+b));

public static void main(String[] args) {

Main obj=new Main();

obj.add(); // method call with no arguments

}}

Sample Output:

Sum:30

Method with no arguments and a return value

In this type of method, no value is passed from calling method to called method but a value is
returned from called method to calling method.

Example:

Program to compute addition of two numbers (no argument and with return value)

public class Main {

public int add(){

// method definition with no arguments and with return value

int a=10,b=20;
return(a+b);

public static void main(String[] args) {

int sum=0;

Main obj=new Main();

sum=obj.add();

/* method call with no arguments. The value returned

from the method is assigned to variable sum */

System.out.println(“Sum:”+sum);

}}

Sample Output:

Sum:30

Method with arguments and no return value

In this type of method, parameters are passed from calling method to called method but no
value is returned from called method to calling method.

Example:

Program to compute addition of two numbers (with argument and without return value)

public class Main {

public void add(int x,int y){

// method definition with arguments and no return value

System.out.println(“Sum:”+(x+y));

public static void main(String[] args) {

int a=10,b=20;

Main obj=new Main();

obj.add(a,b); // method call with arguments

}}

Sample Output:

Sum:30

Method with arguments and a return value.

In this type of method, there is data transfer in between calling method and called method.
Here, when the method is called program control transfers to the called method with argu-
ments, executes the method, and return the value back to the calling method.

Example:

Program to compute addition of two numbers (with argument and return value)

public class Main {

public int add(int x,int y){ // function definition with arguments and return value

return(x+y); //return value

public static void main(String[] args) { int a=10,b=20;

Main obj=new Main();

System.out.println(“Sum:”+obj.add(a,b));

/* method call with arguments. The value returned from

the method is displayed within main() */

}}

Sample Output:

Sum:30

1.12 ACCESS SPECIFIERS:

Access specifiers or access modifiers in java specifies accessibility (scope) of a data mem- ber,
method, constructor or class. It determines whether a data or method in a class can be used or
invoked by other class or subclass.

Types of Access Specifiers

There are 4 types of java access specifiers:

1. Private
2. Default (no speciifer)

3. Protected

4. Public

The details about accessibility level for access specifiers are shown in following table.

Access Modifiers Default Private Protected Public

Accessible inside the class Yes Yes Yes Yes
Accessible within the subclass
Yes No Yes Yes
inside the same package
Accessible outside the package No No No Yes
Accessible within the subclass
No No Yes Yes
outside the package

Private access modifier

Private data fields and methods are accessible only inside the class where it is declared i.e
accessible only by same class members. It provides low level of accessibility. Encapsulation
and data hiding can be achieved using private specifier.

Example:

Role of private specifier class PrivateEx{

private int x; // private data

public int y; // public data

private PrivateEx(){} // private constructor public PrivateEx(int a,int b){ // public

constructor

x=a; y=b;

}}

public class Main {

public static void main(String[] args) {

PrivateEx obj1=new PrivateEx(); // Error: private constructor cannot be applied PrivateEx

obj2=new PrivateEx(10,20); // public constructor can be applied to obj2
System.out.println(obj2.y); // public data y is accessible by a non-member
System.out.println(obj2.x); //Error: x has private access in PrivateEx

}}
In this example, we have created two classes PrivateEx and Main. A class contains private data
member, private constructor and public method. We are accessing these private members from
outside the class, so there is compile time error.

Default access modifier

If the specifier is mentioned, then it is treated as default. There is no default specifier keyword.
Using default specifier we can access class, method, or field which belongs to same package,
but not from outside this package.

Example:

Role of default specifier

class DefaultEx{

int y=10; // default data

public class Main {

public static void main(String[] args) {

DefaultEx obj=new DefaultEx();

System.out.println(obj.y);

// default data y is accessible outside the class

}}

Sample Output:

10

In the above example, the scope of class DefaultEx and its data y is default. So it can be
accessible within the same package and cannot be accessed from outside the package.

Protected access modifier

Protected methods and fields are accessible within same class, subclass inside same pack- age
and subclass in other package (through inheritance). It cannot be applicable to class and
interfaces.

Example:

Role of protected specifier class Base{

protected void show(){ System.out.println(“In Base”);

}}

public class Main extends Base{

public static void main(String[] args) {

Main obj=new Main();

obj.show();

}}

Sample Output:

In Base

In this example, show() of class Base is declared as protected, so it can be accessed from outside
the class only through inheritance. Chapter 2 explains the concept of inheritance in detail.

Public access modifier

The public access specifier has highest level of accessibility. Methods, class, and fields
declared as public are accessible by any class in the same package or in other package.

Example:

Role of public specifier class PublicEx{

public int no=10;

}public class Main{

public static void main(String[] args) {

PublicEx obj=new PublicEx();

System.out.println(obj.no);

Sample Output:

10

In this example, public data no is accessible both by member and non-member of the class.
1.13 STATIC MEMBERS:

The static keyword indicates that the member belongs to the class instead of a specific instance.
It is used to create class variable and mainly used for memory management. The static keyword
can be used with:

• Variable (static variable or class variable)

• Method (static method or class method)

• Block (static block)

• Nested class (static class)

• import (static import)

Static variable: Variable declared with keyword static is a static variable. It is a class level
variable commonly shared by all objects of the class.

• Memory allocation for such variables only happens once when the class is loaded in the
memory.

• scope of the static variable is class scope (accessible only inside the class)

• lifetime is global (memory is assigned till the class is removed by JVM).

• Automatically initialized to 0.

• It is accessible using ClassName.variablename

• Static variables can be accessed directly in static and non-static methods.

Example:
 Without static With static

class StaticEx{ class StaticEx{

int no=10; static int no=10;

StaticEx(){ StaticEx(){

System.out.println(no); System.out.println(no);

no++; no++;

} }

} }

public class Main{ public class Main{

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

{ {

StaticEx obj1=new StaticEx(); StaticEx obj1=new StaticEx();

StaticEx obj2=new StaticEx(); StaticEx obj2=new StaticEx();

StaticEx obj3=new StaticEx(); StaticEx obj3=new StaticEx();

} }

} }

Sample Output: Sample Output:

10 10

10 11

10 12
Static Method: The method declared with static keyword is known as static method. main() is
most common static method.

• It belongs to the class and not to object of a class.

• A static method can directly access only static variables of class and directly invoke
only static methods of the class.

• Static methods cannot access non-static members (instance variables or instance

methods) of the class

• Static method cant access this and super references

• It can be called through the name of class without creating any instance of that class.
For example, ClassName.methodName()

Example:

class StaticEx{

static int x;

int y=10;

static void display(){

System.out.println(“Static Method “+x); // static method accessing static variable

public void show(){

System.out.println(“Non static method “+y);

System.out.println(“Non static method “+x); // non-static method can access static variable

}}

public class Main

public static void main(String[] args) {

StaticEx obj=new StaticEx();

StaticEx.display(); // static method invoked without using object

obj.show();

}}
Sample Output:

Static Method 0

Non static method 10

Non static method 0

In this example, class StaticEx consists of a static variable x and static method display(). The
static method cannot access a non-static variable. If you try to access y inside static method
display(), it will result in compilation error.

static void display(){

/*non-static variable y cannot be referred from a

static context*/

System.out.println(“Static Method “+x+y);

Static Block: A static block is a block of code enclosed in braces, preceded by the keyword
static.

• The statements within the static block are first executed automatically before main
when the class is loaded into JVM.

• A class can have any number of static blocks.

• JVM combines all the static blocks in a class as single block and executes them.

• Static methods can be invoked from the static block and they will be executed as and
when the static block gets executed.

Syntax:

static{

…………….

Example:

class StaticBlockEx{ StaticBlockEx (){

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

static {

System.out.println(“First static block”);

static void show(){ System.out.println(“Inside method”);

static{

System.out.println(“Second static block”); show();

public static void main(String[] args) {

StaticBlockEx obj=new StaticBlockEx ();

static{

System.out.println(“Static in main”);

}}

Sample Output:

First static block Second static block Inside method

Static in main

Constructor

Nested class (static class)

Nested class is a class declared inside another class. The inner class must be a static class
declared using keyword static. The static nested class can refer directly to static members of
the enclosing classes, even if those members are private.

Syntax:

class OuterClass{

……..

static class InnerClass{

……….

}}

We can create object for static nested class directly without creating object for outer class.

For example:

OuterClassName.InnerClassName=new OuterClassName.InnerClassName();

Example:

class Outer{

static int x=10;

static class Inner{

int y=20;

public void show(){

System.out.println(x+y); // nested class accessing its own data & outer class static data

}}}

class Main{

public static void main(String args[]){

Outer.Inner obj=new Outer.Inner(); // Creating object for static nested class

obj.show();

}}

Sample Output:

30

Static Import: The static import allows the programmer to access any static members of
imported class directly. There is no need to qualify it by its name.

Syntax:

Import static package_name;

Advantage:

• Less coding is required if you have accessed any static member of a class often.

Disadvantage:

• Overuse of static import makes program unreadable and can’t be maintained.

Example:

import static java.lang.System.*;

class StaticImportEx{

public static void main(String args[]){

out.println(“Static Import Example”); //Now no need of System.out

}}

Sample Output:

Static Import Example

1.14 JAVA DOC COMMENTS:

Javadoc is a tool which comes with JDK and it is used for generating Java code documentation
in HTML format from Java source code, which requires documentation in a predefined format.
JavaDoc comments, which use a slash-star-star, star-slash ( /** … */ ) syntax, serve a different
purpose from inline comments and multi-line Java comments. Whereas inline and block Java
comments are read by other developers who maintain the code, JavaDoc comments are for
developers who use your code.

In object-oriented programming (OOP), Javadoc comments are a specific style of code

comments used in Java programming language to generate documentation automatically. These
comments are written in a specific format and can be processed by the Javadoc tool to produce
HTML-based API documentation.

Javadoc comments are used to document Java classes, interfaces, methods, fields, and
constructors. They help in providing information about the purpose, behavior, parameters,
return values, and usage of the code elements. This documentation is especially useful for
developers who want to use the code or for those who need to maintain it.

The format of Javadoc comments is as follows:

1) Class and Interface Documentation:

/**

* Description of the class or interface.

* Additional details and usage information can be provided here.

*/

public class MyClass {

// Class implementation

The class and interface documentation in Javadoc comments provides an overview of the
purpose and behavior of the class or interface. It typically includes a high-level description of
what the class or interface does and may include additional details such as usage guidelines,
examples, or any relevant information for developers using or extending the class/interface.

2) Method Documentation:

/**

* Description of the method's purpose and behavior.

* @param parameter1 Description of the first parameter.

* @param parameter2 Description of the second parameter.

* @return Description of the return value.

* @throws SomeExceptionType Description of when this exception is thrown.

*/

public ReturnType myMethod(ParameterType parameter1, ParameterType parameter2) throws

SomeExceptionType {

// Method implementation

Method documentation in Javadoc comments describes the purpose and behavior of a method.
It includes a description of what the method does, what parameters it takes (if any), what it
returns (if applicable), and any exceptions it might throw. These comments provide important
information for developers who want to use the method, helping them understand how to use
it correctly and handle any exceptions that may occur.

3) Field Documentation:

/**

* Description of the field.

*/
private int myField;

Field documentation in Javadoc comments provides information about a class's field (variable).
It typically includes a description of the field's purpose, any constraints or rules associated with
the field, and any other relevant details about the field's usage.

4)Constructor Documentation:

/**

* Description of the constructor's purpose and behavior.

* @param parameter1 Description of the first parameter.

* @param parameter2 Description of the second parameter.

*/

public MyClass(ParameterType parameter1, ParameterType parameter2) {

// Constructor implementation

Constructor documentation in Javadoc comments explains the purpose and behavior of a class
constructor. It includes a description of what the constructor does, what parameters it takes (if
any), and any additional information developers need to know when using the constructor to
create instances of the class.

In summary, Javadoc comments play a crucial role in documenting Java code and are an
essential part of creating well-documented APIs. They serve as a valuable reference for
developers, making it easier for them to understand, use, and maintain the code written by
others. Properly documented code with Javadoc comments is considered a best practice in Java
development.