22CS302 - UNIT 1 To 3 - Material

22CS302 - JAVA PROGRAMMING
SYLLABUS
22CS302 - JAVA PROGRAMMING
UNIT I INTRODUCTION TO JAVA 9

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 specifies - Static members- Java Doc comments
UNIT II INHERITANCE, INTERFACES AND PACKAGES 9
Overloading- Objects as Parameters – Returning Objects –Static, Nested and Inner Classes.
Inheritance: Basics– Types of Inheritance -Super keyword -Method Overriding - Dynamic binding, –
Abstract Classes – final with Inheritance. Packages and Interfaces: Packages – Packages and
Member Access –Importing Packages – Interfaces – Multiple inheritance – Default methods – Static
methods
UNIT III THREADS AND EXCEPTION HANDLING 9
Thread - Thread life cycle and methods, Runnable interface- Inter Thread Communication-
Suspending –Resuming, and Stopping Threads –Multi-threading - Exception handling with try- catch-
finally – Nested try-catch – User defined Exception.
UNIT IV: I/O, GENERICS, STRING HANDLING 9
I/O Basics – Reading and Writing Console I/O – Reading and Writing Files. Generics: Generic
Programming – Generic classes – Generic Methods – Bounded Types – Restrictions and Limitations.
Strings: Basic String class, methods and String Buffer Class.
UNIT V COLLECTIONS, JDBC 9
Collection framework – List – Set – Map – Comparing and Sorting- Regex – JDBC – The need –
JDBC API – JDBC Driver – Database Connection – Database Operations – Processing Results-
Memory Management and Garbage Collection.
Total : 45 Hours
List of Experiments:
1. Programs using class and methods using Java
2. Implementation of Inheritance using Java
3. Inheritance via Interface and Abstract class
4. Programs on Package implementations
5. Implementation of Java Applications using Generic collections
6. Demonstration of IO Streams in Java
7. Demonstration of User Defined Exception handling in Java
8. Implementation of multi-threading in Java
9. Programs using collection framework
10. Mini Project using Database connectivity
Total : 30 Hours
1. Herbert Schildt, “Java: The Complete Reference”, 11 th Edition, McGraw Hill
Education, New Delhi, 2019
2. Cay S. Horstmann, “Core Java Fundamentals”, Volume 1, 11 th Edition,
Prentice Hall, 2018.
References
3. KEN ARNOLD, Java Programming Language, Addison Wesely, 2000
4. John R Hubbard, Programming with Java, Tata Mcgraw Hill, 1998
5. https://infyspringboard.onwingspan.com/web/en/app/toc/lex_auth_0131933845
400207362 64_shared/overview
6. https://onlinecourses-archive.nptel.ac.in/noc19_cs07
UNIT I INTRODUCTION TO JAVA
The basics of OOPs. Object-Oriented Programming is a paradigm that provides many

concepts, such as inheritance, data binding, polymorphism, etc.
The main aim of object-oriented programming is to implement real-world entities,

for example, object, classes, abstraction, inheritance, polymorphism, etc.
OOPs (Object-Oriented Programming System)

Object means a real-world entity such as a pen, chair, table, computer, watch,
etc. Object-Oriented Programming is a methodology or paradigm to design a
program using classes and objects. It simplifies software development and
maintenance by providing some concepts:
 Object
 Class
 Inheritance
 Polymorphism
 Abstraction
 Encapsulation
Apart from these concepts, there are some other terms which are used in Object-
Oriented design:
 Coupling
 Cohesion
 Association
 Aggregation
 Composition
Object
Any entity that has state and behavior is known as an object. For example, a chair,
pen, table, keyboard, bike, etc. It can be physical or logical.
An Object can be defined as an instance of a class. An object contains an address and

takes up some space in memory. Objects can communicate without knowing the
details of each other's data or code. The only necessary thing is the type of message
accepted and the type of response returned by the objects.
Example: A dog is an object because it has states like color, name, breed, etc. as well
as behaviors like wagging the tail, barking, eating, etc.
Class
Collection of objects is called class. It is a logical entity.
A class can also be defined as a blueprint from which you can create an individual
object. Class doesn't consume any space.
Inheritance
When one object acquires all the properties and behaviors of a parent object, it is
known as inheritance. It provides code reusability. It is used to achieve runtime
polymorphism.
Polymorphism
If one task is performed in different ways, it is known as polymorphism. For example:
to convince the customer differently, to draw something, for example, shape,
triangle, rectangle, etc.
In Java, we use method overloading and method overriding to achieve

polymorphism.
Another example can be to speak something; for example, a cat speaks meow, dog
barks woof, etc.
Abstraction
Hiding internal details and showing functionality is known as abstraction. For example
phone call, we don't know the internal processing.
In Java, we use abstract class and interface to achieve abstraction.
Encapsulation
Binding (or wrapping) code and data together into a single unit are known as
encapsulation. For example, a capsule, it is wrapped with different medicines.
Features of Java
The primary objective of Java programming language creation was to make it
portable, simple and secure programming language. Apart from this, there are also
some excellent features which play an important role in the popularity of this
language. The features of Java are also known as Java buzzwords.
A list of the most important features of the Java language is given below.
1. Simple
2. Object-Oriented
3. Portable
4. Platform independent
5. Secured
6. Robust
7. Architecture neutral
8. Interpreted
9. High Performance
10. Multithreaded
11. Distributed
12. Dynamic
Data Types in Java

Data types specify the different sizes and values that can be stored in the variable.
There are two types of data types in Java:
1. Primitive data types: The primitive data types include boolean, char, byte, short, int,
long, float and double.
2. Non-primitive data types: The non-primitive data types include Classes, Interfaces,
and Arrays.
Java Primitive Data Types

In Java language, primitive data types are the building blocks of data manipulation.
These are the most basic data types available in Java language.
Java is a statically-typed programming language. It means, all variables must be

declared before its use. That is why we need to declare variable's type and name.
There are 8 types of primitive data types:
o boolean data type

o byte data type
o char data type
o short data type
o int data type
o long data type
o float data type
o double data type
Data Type Default Value Default size
boolean false 1 bit
char '\u0000' 2 byte
byte 0 1 byte
short 0 2 byte
int 0 4 byte
long 0L 8 byte
float 0.0f 4 byte
double 0.0d 8 byte

Boolean Data Type
The Boolean data type is used to store only two possible values: true and false. This
data type is used for simple flags that track true/false conditions.
The Boolean data type specifies one bit of information, but its "size" can't be defined
precisely.
Example:
1. Boolean one = false
Byte Data Type

The byte data type is an example of primitive data type. It isan 8-bit signed two's
complement integer. Its value-range lies between -128 to 127 (inclusive). Its
minimum value is -128 and maximum value is 127. Its default value is 0.
The byte data type is used to save memory in large arrays where the memory savings
is most required. It saves space because a byte is 4 times smaller than an integer. It
can also be used in place of "int" data type.
Example:
1. byte a = 10, byte b = -20
Short Data Type

The short data type is a 16-bit signed two's complement integer. Its value-range lies
between -32,768 to 32,767 (inclusive). Its minimum value is -32,768 and maximum
value is 32,767. Its default value is 0.
The short data type can also be used to save memory just like byte data type. A short
data type is 2 times smaller than an integer.
Example:
1. short s = 10000, short r = -5000
Int Data Type

The int data type is a 32-bit signed two's complement integer. Its value-range lies
between - 2,147,483,648 (-2^31) to 2,147,483,647 (2^31 -1) (inclusive). Its minimum
value is - 2,147,483,648and maximum value is 2,147,483,647. Its default value is 0.
The int data type is generally used as a default data type for integral values unless if
there is no problem about memory.
Example:
1. int a = 100000, int b = -200000
Long Data Type

The long data type is a 64-bit two's complement integer. Its value-range lies between
-9,223,372,036,854,775,808(-2^63) to 9,223,372,036,854,775,807(2^63 -1)(inclusive).
Its minimum value is - 9,223,372,036,854,775,808and maximum value is
9,223,372,036,854,775,807. Its default value is 0. The long data type is used when you
need a range of values more than those provided by int.
Example:
1. long a = 100000L, long b = -200000L
Float Data Type

The float data type is a single-precision 32-bit IEEE 754 floating point.Its value range
is unlimited. It is recommended to use a float (instead of double) if you need to save
memory in large arrays of floating point numbers. The float data type should never
be used for precise values, such as currency. Its default value is 0.0F.
Example:
1. float f1 = 234.5f
Double Data Type

The double data type is a double-precision 64-bit IEEE 754 floating point. Its value
range is unlimited. The double data type is generally used for decimal values just like
float. The double data type also should never be used for precise values, such as
currency. Its default value is 0.0d.
Example:
1. double d1 = 12.3
Char Data Type
The char data type is a single 16-bit Unicode character. Its value-range lies between
'\u0000' (or 0) to '\uffff' (or 65,535 inclusive).The char data type is used to store
characters.
Example:
1. char letterA = 'A'
Operators in Java
Operator in Java is a symbol that is used to perform operations. For example: +, -, *,
/ etc.
There are many types of operators in Java which are given below:
o Unary Operator,
o Arithmetic Operator,
o Shift Operator,
o Relational Operator,
o Bitwise Operator,
o Logical Operator,
o Ternary Operator and
o Assignment Operator.
Java Operator Precedence
Operator Type Category Precedence
Unary postfix expr++ expr--
prefix ++expr --expr +expr -expr ~ !
Arithmetic multiplicative * / %
additive + -
Shift shift << >> >>>
Relational comparison < > <= >= instanceof
equality == !=
Bitwise bitwise AND &
bitwise exclusive OR ^
bitwise inclusive OR |
Logical logical AND &&
logical OR ||
Ternary ternary ? :
Assignment assignment = += -= *= /= %= &= ^= |= <<= >>= >>>=
Java Unary Operator

The Java unary operators require only one operand. Unary operators are used to
perform various operations i.e.:
 incrementing/decrementing a value by one

 negating an expression
 inverting the value of a boolean
Java Unary Operator Example: ++ and --

1. public class OperatorExample{
2. public static void main(String args[]){
3. int x=10;
4. System.out.println(x++);//10 (11)
5. System.out.println(++x);//12
6. System.out.println(x--);//12 (11)
7. System.out.println(--x);//10
8. }}
Output:
10
12
12
10
Java Unary Operator Example 2: ++ and --

3. int a=10;
4. int b=10;
5. System.out.println(a++ + ++a);//10+12=22
6. System.out.println(b++ + b++);//10+11=21
7.
8. }}
Output:
22
21
Java Unary Operator Example: ~ and !

3. int a=10;
4. int b=-10;
5. boolean c=true;
6. boolean d=false;
7. System.out.println(~a);//-11 (minus of total positive value which starts from 0)
8. System.out.println(~b);//9 (positive of total minus, positive starts from 0)
9. System.out.println(!c);//false (opposite of boolean value)
10. System.out.println(!d);//true
11. }}
Output:
-11
9
false
true
Java Arithmetic Operators

Java arithmetic operators are used to perform addition, subtraction, multiplication,
and division. They act as basic mathematical operations.
Java Arithmetic Operator Example

3. int a=10;
4. int b=5;
5. System.out.println(a+b);//15
6. System.out.println(a-b);//5
7. System.out.println(a*b);//50
8. System.out.println(a/b);//2
9. System.out.println(a%b);//0
10. }}
Output:
15
5
50
2
0
Java Arithmetic Operator Example: Expression

3. System.out.println(10*10/5+3-1*4/2);
4. }}
Output:
21
Java Left Shift Operator

The Java left shift operator << is used to shift all of the bits in a value to the left side
of a specified number of times.
Java Left Shift Operator Example
3. System.out.println(10<<2);//10*2^2=10*4=40
7. }}
Output:
40
80
80
240
Java Right Shift Operator

The Java right shift operator >> is used to move the value of the left operand to
right by the number of bits specified by the right operand.
Java Right Shift Operator Example

1. public OperatorExample{
3. System.out.println(10>>2);//10/2^2=10/4=2
6. }}
Output:
2
5
2
Java Shift Operator Example: >> vs >>>

3. //For positive number, >> and >>> works same
4. System.out.println(20>>2);
5. System.out.println(20>>>2);
6. //For negative number, >>> changes parity bit (MSB) to 0
7. System.out.println(-20>>2);
8. System.out.println(-20>>>2);
9. }}
Output:
5
5
-5
1073741819
Java AND Operator Example: Logical && and Bitwise &

The logical && operator doesn't check the second condition if the first condition is
false. It checks the second condition only if the first one is true.
The bitwise & operator always checks both conditions whether first condition is true
or false.

3. int a=10;
4. int b=5;
5. int c=20;
6. System.out.println(a<b&&a<c);//false && true = false
7. System.out.println(a<b&a<c);//false & true = false
8. }}
Output:
false
false
Java AND Operator Example: Logical && vs Bitwise &

3. int a=10;
4. int b=5;
5. int c=20;
6. System.out.println(a<b&&a++<c);//false && true = false
7. System.out.println(a);//10 because second condition is not checked
8. System.out.println(a<b&a++<c);//false && true = false
9. System.out.println(a);//11 because second condition is checked
10. }}
Output:
false
10
false
11
Java OR Operator Example: Logical || and Bitwise |

The logical || operator doesn't check the second condition if the first condition is
true. It checks the second condition only if the first one is false.
The bitwise | operator always checks both conditions whether first condition is true
or false.

3. int a=10;
4. int b=5;
5. int c=20;
6. System.out.println(a>b||a<c);//true || true = true
7. System.out.println(a>b|a<c);//true | true = true
8. //|| vs |
9. System.out.println(a>b||a++<c);//true || true = true
10. System.out.println(a);//10 because second condition is not checked
11. System.out.println(a>b|a++<c);//true | true = true
12. System.out.println(a);//11 because second condition is checked
13. }}
Output:
true
true
true
10
true
11
Java Ternary Operator

Java Ternary operator is used as one line replacement for if-then-else statement and
used a lot in Java programming. It is the only conditional operator which takes three
operands.
Java Ternary Operator Example
3. int a=2;
4. int b=5;
5. int min=(a<b)?a:b;
6. System.out.println(min);
7. }}
Output:
Another Example:

3. int a=10;
4. int b=5;
5. int min=(a<b)?a:b;
6. System.out.println(min);
7. }}
Output:
Java Assignment Operator

Java assignment operator is one of the most common operators. It is used to assign
the value on its right to the operand on its left.
Java Assignment Operator Example

1. public class OperatorExample {
2. public static void main(String args[]) {
3. int a=10;
4. int b=20;
5. a+=4;//a=a+4 (a=10+4)
6. b-=4;//b=b-4 (b=20-4)
7. System.out.println(a);
8. System.out.println(b);
9. }}
Output:
14
16
Java Assignment Operator Example

2. public static void main(String[] args){
3. int a=10;
4. a+=3;//10+3
6. a-=4;//13-4
8. a*=2;//9*2
10. a/=2;//18/2
12. }}
Output:
13
9
18
9
Java Assignment Operator Example: Adding short

3. short a=10;
4. short b=10;
5. //a+=b;//a=a+b internally so fine
6. a=a+b;//Compile time error because 10+10=20 now int
8. }}
Output:
Compile time error
After type cast:

3. short a=10;
4. short b=10;
5. a=(short)(a+b);//20 which is int now converted to short
7. }}
Output:
20
Java Control Statements | Control Flow in

Java
Java compiler executes the code from top to bottom. The statements in the code are
executed according to the order in which they appear. However, Java provides
statements that can be used to control the flow of Java code. Such statements are
called control flow statements. It is one of the fundamental features of Java, which
provides a smooth flow of program.
Java provides three types of control flow statements.
1. Decision Making statements
 if statements
 switch statement
2. Loop statements
 do while loop
 while loop
 for loop
 for-each loop
3. Jump statements
 break statement
 continue statement
Decision-Making statements:
As the name suggests, decision-making statements decide which statement to
execute and when. Decision-making statements evaluate the Boolean expression and
control the program flow depending upon the result of the condition provided.
There are two types of decision-making statements in Java, i.e., If statement and
switch statement.
1) If Statement:
In Java, the "if" statement is used to evaluate a condition. The control of the program
is diverted depending upon the specific condition. The condition of the If statement
gives a Boolean value, either true or false. In Java, there are four types of if-
statements given below.
1. Simple if statement
2. if-else statement
3. if-else-if ladder
4. Nested if-statement
Let's understand the if-statements one by one.
1) Simple if statement:
It is the most basic statement among all control flow statements in Java. It evaluates
a Boolean expression and enables the program to enter a block of code if the
expression evaluates to true.
Syntax of if statement is given below.
1. if(condition) {
2. statement 1; //executes when condition is true
3. }
Consider the following example in which we have used the if statement in the java
code.
Student.java
Student.java
1. public class Student {

2. public static void main(String[] args) {
3. int x = 10;
4. int y = 12;
5. if(x+y > 20) {
6. System.out.println("x + y is greater than 20");
7. }
8. }
9. }
Output:
x + y is greater than 20
2) if-else statement
The if-else statement is an extension to the if-statement, which uses another block of
code, i.e., else block. The else block is executed if the condition of the if-block is
evaluated as false.
Syntax:
1. if(condition) {
2. statement 1; //executes when condition is true
3. }
4. else{
5. statement 2; //executes when condition is false
6. }
Consider the following example.
Student.java

3. int x = 10;
4. int y = 12;
5. if(x+y < 10) {
6. System.out.println("x + y is less than 10");
7. } else {
8. System.out.println("x + y is greater than 20");
9. }
10. }
11. }
Output:
x + y is greater than 20
3) if-else-if ladder:
The if-else-if statement contains the if-statement followed by multiple else-if

statements. In other words, we can say that it is the chain of if-else statements that
create a decision tree where the program may enter in the block of code where the
condition is true. We can also define an else statement at the end of the chain.
Syntax of if-else-if statement is given below.
1. if(condition 1) {
2. statement 1; //executes when condition 1 is true
3. }
4. else if(condition 2) {
6. }
7. else {
8. statement 2; //executes when all the conditions are false
9. }
Student.java

3. String city = "Delhi";
4. if(city == "Meerut") {
5. System.out.println("city is meerut");
6. }else if (city == "Noida") {
7. System.out.println("city is noida");
8. }else if(city == "Agra") {
9. System.out.println("city is agra");
10. }else {
11. System.out.println(city);
12. }
13. }
14. }
Output:
Delhi
4. Nested if-statement
In nested if-statements, the if statement can contain a if or if-else statement inside

another if or else-if statement.
Syntax of Nested if-statement is given below.
5. }
6. else{
7. statement 2; //executes when condition 2 is false
8. }
9. }
Student.java

3. String address = "Delhi, India";
4.
5. if(address.endsWith("India")) {
6. if(address.contains("Meerut")) {
7. System.out.println("Your city is Meerut");
8. }else if(address.contains("Noida")) {
9. System.out.println("Your city is Noida");
10. }else {
11. System.out.println(address.split(",")[0]);
12. }
13. }else {
14. System.out.println("You are not living in India");
15. }
16. }
17. }
Output:
Delhi
Switch Statement:
In Java, Switch statements are similar to if-else-if statements. The switch statement
contains multiple blocks of code called cases and a single case is executed based on
the variable which is being switched. The switch statement is easier to use instead of
if-else-if statements. It also enhances the readability of the program.
Points to be noted about switch statement:
 The case variables can be int, short, byte, char, or enumeration. String type is also
supported since version 7 of Java
 Cases cannot be duplicate
 Default statement is executed when any of the case doesn't match the value of
expression. It is optional.
 Break statement terminates the switch block when the condition is satisfied.
It is optional, if not used, next case is executed.
 While using switch statements, we must notice that the case expression will be of the
same type as the variable. However, it will also be a constant value.
The syntax to use the switch statement is given below.
1. switch (expression){
2. case value1:
3. statement1;
4. break;
5. .
6. .
7. .
8. case valueN:
9. statementN;
10. break;
11. default:
12. default statement;
13. }
Consider the following example to understand the flow of the switch statement.
Student.java
1. public class Student implements Cloneable {

3. int num = 2;
4. switch (num){
5. case 0:
6. System.out.println("number is 0");
7. break;
8. case 1:
9. System.out.println("number is 1");
10. break;
11. default:
12. System.out.println(num);
13. }
14. }
15. }
Output:
While using switch statements, we must notice that the case expression will be of the
same type as the variable. However, it will also be a constant value. The switch
permits only int, string, and Enum type variables to be used.
Loop Statements
In programming, sometimes we need to execute the block of code repeatedly while
some condition evaluates to true. However, loop statements are used to execute the
set of instructions in a repeated order. The execution of the set of instructions
depends upon a particular condition.
In Java, we have three types of loops that execute similarly. However, there are
differences in their syntax and condition checking time.
1. for loop
2. while loop
3. do-while loop
Let's understand the loop statements one by one.
Java for loop

In Java, for loop is similar to C and C++. It enables us to initialize the loop variable,
check the condition, and increment/decrement in a single line of code. We use the
for loop only when we exactly know the number of times, we want to execute the
block of code.
1. for(initialization, condition, increment/decrement) {

2. //block of statements
3. }
The flow chart for the for-loop is given below.
Consider the following example to understand the proper functioning of the for loop
in java.
Calculation.java
1. public class Calculattion {

3. // TODO Auto-generated method stub
4. int sum = 0;
5. for(int j = 1; j<=10; j++) {
6. sum = sum + j;
7. }
8. System.out.println("The sum of first 10 natural numbers is " + sum);
9. }
10. }
Output:
The sum of first 10 natural numbers is 55
Java for-each loop

Java provides an enhanced for loop to traverse the data structures like array or
collection. In the for-each loop, we don't need to update the loop variable. The
syntax to use the for-each loop in java is given below.
1. for(data_type var : array_name/collection_name){

2. //statements
3. }
Consider the following example to understand the functioning of the for-each loop
in Java.
Calculation.java
1. public class Calculation {

4. String[] names = {"Java","C","C++","Python","JavaScript"};
5. System.out.println("Printing the content of the array names:\n");
6. for(String name:names) {
7. System.out.println(name);
8. }
9. }
10. }
Output:
Printing the content of the array names:
Java
C
C++
Python
JavaScript
Java while loop

The while loop is also used to iterate over the number of statements multiple times.
However, if we don't know the number of iterations in advance, it is recommended to
use a while loop. Unlike for loop, the initialization and increment/decrement doesn't
take place inside the loop statement in while loop.
It is also known as the entry-controlled loop since the condition is checked at the
start of the loop. If the condition is true, then the loop body will be executed;
otherwise, the statements after the loop will be executed.
The syntax of the while loop is given below.
1. while(condition){
2. //looping statements
3. }
The flow chart for the while loop is given in the following image.

Calculation .java

4. int i = 0;
5. System.out.println("Printing the list of first 10 even numbers \n");
6. while(i<=10) {
7. System.out.println(i);
8. i = i + 2;
9. }
10. }
11. }
Output:
Printing the list of first 10 even numbers
0
2
4
6
8
10
Java do-while loop

The do-while loop checks the condition at the end of the loop after executing the
loop statements. When the number of iteration is not known and we have to execute
the loop at least once, we can use do-while loop.
It is also known as the exit-controlled loop since the condition is not checked in
advance. The syntax of the do-while loop is given below.
1. do
2. {
3. //statements
4. } while (condition);
The flow chart of the do-while loop is given in the following image.
Consider the following example to understand the functioning of the do-while loop
in Java.
Calculation.java

4. int i = 0;
5. System.out.println("Printing the list of first 10 even numbers \n");
6. do {
8. i = i + 2;
9. }while(i<=10);
10. }
11. }
Output:
Printing the list of first 10 even numbers

0
2
4
6
8
10
Jump Statements
Jump statements are used to transfer the control of the program to the specific
statements. In other words, jump statements transfer the execution control to the
other part of the program. There are two types of jump statements in Java, i.e., break
and continue.
Java break statement

As the name suggests, the break statement is used to break the current flow of the
program and transfer the control to the next statement outside a loop or switch
statement. However, it breaks only the inner loop in the case of the nested loop.
The break statement cannot be used independently in the Java program, i.e., it can
only be written inside the loop or switch statement.
The break statement example with for loop
Consider the following example in which we have used the break statement with the
for loop.
BreakExample.java
1. public class BreakExample {

2.
5. for(int i = 0; i<= 10; i++) {
7. if(i==6) {
8. break;
9. }
10. }
11. }
12. }
Output:
0
1
2
3
4
5
6
break statement example with labeled for loop
Calculation.java

2.
5. a:
6. for(int i = 0; i<= 10; i++) {
7. b:
8. for(int j = 0; j<=15;j++) {
9. c:
10. for (int k = 0; k<=20; k++) {
11. System.out.println(k);
12. if(k==5) {
13. break a;
14. }
15. }
16. }
17.
18. }
19. }
20.
21.
22. }
Output:
0
1
2
3
4
5
Java continue statement
Unlike break statement, the continue statement doesn't break the loop, whereas, it
skips the specific part of the loop and jumps to the next iteration of the loop
immediately.
Consider the following example to understand the functioning of the continue

statement in Java.
1. public class ContinueExample {

2.
5.
6. for(int i = 0; i<= 2; i++) {
7.
8. for (int j = i; j<=5; j++) {
9.
10. if(j == 4) {
11. continue;
12. }
13. System.out.println(j);
14. }
15. }
16. }
17.
18. }
Output:
0
1
2
3
5
1
2
3
5
2
3
5
Structure of Java Program
Java is an object-oriented programming, platform-independent and secures
programming language that makes it popular. Using the Java programming
language, we can develop a wide variety of applications. So, before diving in depth, it
is necessary to understand the basic structure of Java program in detail. In this
section, we have discussed the basic structure of a Java program. At the end of this
section, you will able to develop the Hello world Java program, easily.
Let's see which elements are included in the structure of a Java program. A typical
structure of a Java program contains the following elements:
 Documentation Section
 Package Declaration
 Import Statements
 Interface Section
 Class Definition
 Class Variables and Variables
 Main Method Class
 Methods and Behaviors
Documentation Section
The documentation section is an important section but optional for a Java program.
It includes basic information about a Java program. The information includes
the author's name, date of creation, version, program name, company
name, and description of the program. It improves the readability of the program.
Whatever we write in the documentation section, the Java compiler ignores the
statements during the execution of the program. To write the statements in the
documentation section, we use comments. The comments may be single-line,
multi-line, and documentation comments.
o Single-line Comment: It starts with a pair of forwarding slash (//). For example:
1. //First Java Program

o Multi-line Comment: It starts with a /* and ends with */. We write between these
two symbols. For example:
1. /*It is an example of
2. multiline comment*/
o Documentation Comment: It starts with the delimiter (/**) and ends with */. For
example:
1. /**It is an example of documentation comment*/
Package Declaration
The package declaration is optional. It is placed just after the documentation section.
In this section, we declare the package name in which the class is placed. Note that
there can be only one package statement in a Java program. It must be defined
before any class and interface declaration. It is necessary because a Java class can be
placed in different packages and directories based on the module they are used. For
all these classes package belongs to a single parent directory. We use the
keyword package to declare the package name. For example:
1. package javatpoint; //where javatpoint is the package name

2. package com.javatpoint; //where com is the root directory and javatpoint is the subdirectory
Import Statements
The package contains the many predefined classes and interfaces. If we want to use
any class of a particular package, we need to import that class. The import statement
represents the class stored in the other package. We use the import keyword to
import the class. It is written before the class declaration and after the package
statement. We use the import statement in two ways, either import a specific class or
import all classes of a particular package. In a Java program, we can use multiple
import statements. For example:
1. import java.util.Scanner; //it imports the Scanner class only

2. import java.util.*; //it imports all the class of the java.util package
Interface Section
It is an optional section. We can create an interface in this section if required. We
use the interface keyword to create an interface. An interface is a slightly different
from the class. It contains only constants and method declarations. Another
difference is that it cannot be instantiated. We can use interface in classes by using
the implements keyword. An interface can also be used with other interfaces by
using the extends keyword. For example:
1. interface car
2. {
3. void start();
4. void stop();
5. }
Class Definition
In this section, we define the class. It is vital part of a Java program. Without
the class, we cannot create any Java program. A Java program may conation more
than one class definition. We use the class keyword to define the class. The class is a
blueprint of a Java program. It contains information about user-defined methods,
variables, and constants. Every Java program has at least one class that contains the
main() method. For example:
1. class Student //class definition

2. {
3. }
Class Variables and Constants

In this section, we define variables and constants that are to be used later in the
program. In a Java program, the variables and constants are defined just after the
class definition. The variables and constants store values of the parameters. It is used
during the execution of the program. We can also decide and define the scope of
variables by using the modifiers. It defines the life of the variables. For example:
1. class Student //class definition
2. {
3. String sname; //variable
4. int id;
5. double percentage;
6. }
Main Method Class

In this section, we define the main() method. It is essential for all Java programs.
Because the execution of all Java programs starts from the main() method. In other
words, it is an entry point of the class. It must be inside the class. Inside the main
method, we create objects and call the methods. We use the following statement to
define the main() method:
1. public static void main(String args[])

2. {
3. }
For example:
1. public class Student //class definition

2. {
4. {
5. //statements
6. }
7. }
You can read more about the Java main() method here.
Methods and behavior

In this section, we define the functionality of the program by using the methods. The
methods are the set of instructions that we want to perform. These instructions
execute at runtime and perform the specified task. For example:
1. public class Demo //class definition

2. {
4. {
5. void display()
6. {
7. System.out.println("Welcome to javatpoint");
8. }
9. //statements
10. }
11. }
When we follow and use the above elements in a Java program, the program looks
like the following.
CheckPalindromeNumber.java
1. /*Program name: Palindrome*/

2. //Author's name: Mathew
3. /*Palindrome is number or string that will remains the same
4. When we write that in reverse order. Some example of
5. palindrome is 393, 010, madam, etc.*/
6. //imports the Scanner class of the java.util package
7. import java.util.Scanner;
8. //class definition
9. public class CheckPalindromeNumber
10. {
11. //main method
13. {
14. //variables to be used in program
15. int r, s=0, temp;
16. int x; //It is the number variable to be checked for palindrome
17. Scanner sc=new Scanner(System.in);
18. System.out.println("Enter the number to check: ");
19. //reading a number from the user
20. x=sc.nextInt();
21. //logic to check if the number id palindrome or not
22. temp=x;
23. while(x>0)
24. {
25. r=x%10; //finds remainder
26. s=(s*10)+r;
27. x=x/10;
28. }
29. if(temp==s)
30. System.out.println("The given number is palindrome.");
31. else
32. System.out.println("The given number is not palindrome.");
33. }
34. }
Output:
Class Definition in Java

In object-oriented programming, a class is a basic building block. It can be defined
as template that describes the data and behaviour associated with the class
instantiation. Instantiating is a class is to create an object (variable) of that class that
can be used to access the member variables and methods of the class.
A class can also be called a logical template to create the objects that share common
properties and methods.
For example, an Employee class may contain all the employee details in the form of
variables and methods. If the class is instantiated i.e. if an object of the class is
created (say e1), we can access all the methods or properties of the class.
Defining a Class in Java

Java provides a reserved keyword class to define a class. The keyword must be
followed by the class name. Inside the class, we declare methods and variables.
In general, class declaration includes the following in the order as it appears:
1. Modifiers: A class can be public or has default access.

2. class keyword: The class keyword is used to create a class.
3. Class name: The name must begin with an initial letter (capitalized by convention).
4. 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.
5. 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.
6. Body: The class body surrounded by braces, { }.
Syntax:
1. <access specifier> class class_name
2. {
3. // member variables
4. // class methods
5. }
Java Class Example

Example 1:
Let's consider the following example to understand how to define a class in Java and
implement it with the object of class.
Calculate.java
1. // class definition
2. public class Calculate {
3.
4. // instance variables
5. int a;
6. int b;
7.
8. // constructor to instantiate
9. public Calculate (int x, int y) {
10. this.a = x;
11. this.b = y;
12. }
13.
14. // method to add numbers
15. public int add () {
16. int res = a + b;
17. return res;
18. }
19.
20. // method to subtract numbers
21. public int subtract () {
22. int res = a - b;
23. return res;
24. }
25.
26. // method to multiply numbers
27. public int multiply () {
28. int res = a * b;
29. return res;
30. }
31.
32. // method to divide numbers
33. public int divide () {
34. int res = a / b;
35. return res;
36. }
37.
38.
39. // main method
41. // creating object of Class
42. Calculate c1 = new Calculate(45, 4);
43.
44. // calling the methods of Calculate class
45. System.out.println("Addition is :" + c1.add());
46. System.out.println("Subtraction is :" + c1.subtract());
47. System.out.println("Multiplication is :" + c1.multiply());
48. System.out.println("Division is :" + c1.divide());
49.
50.
51. }
Output:
Example 2:
In the following example, we are creating two classes Employee and EmployeeClass.
The Employee class fetches and displays the employee details. In the EmployeeClass,
we create the objects of Employee class and use its methods. Here, we are initializing
the objects using the class constructor.
EmployeeClass.java
1. // class to get the employee details

2. class Employee {
3. // declaring variables
4. int emp_id;
5. String name;
6. String dept;
7. float salary;
8.
9. // method to initialize the variables
10. void add_info (int id, String n, String d, float sal) {
11. this.emp_id = id;
12. this.name = n;
13. this.dept = d;
14. this.salary = sal;
15. }
16.
17. // method to display the employee details
18. void display() {
19. System.out.println("Employee id: " + emp_id );
20. System.out.println("Employee name: " + name );
21. System.out.println("Employee department: " + dept );
22. System.out.println("Employee salary: " + salary );
23. }
24. }
25.
26. public class EmployeeClass {
28. // creating objects of class Employee
29. Employee e1 = new Employee();
32.
33. // calling the methods
34. e1.add_info (101, "Naman", "Salesforce", 45000);
35. e2.add_info (102, "Riya", "Tax", 25000);
36. e3.add_info (103, "Anu", "Development", 55000);
37.
38. e1.display();
39. e2.display();
40. e3.display();
41. }
42. }
Output:
Constructors Methods - Access specifiers
There are two types of modifiers in Java: access modifiers and non-access
modifiers.
The access modifiers in Java specifies the accessibility or scope of a field, method,
constructor, or class. We can change the access level of fields, constructors, methods,
and class by applying the access modifier on it.
There are four types of Java access modifiers:
1. Private: The access level of a private modifier is only within the class. It cannot be
accessed from outside the class.
2. Default: The access level of a default modifier is only within the package. It cannot be
accessed from outside the package. If you do not specify any access level, it will be
the default.
3. Protected: The access level of a protected modifier is within the package and outside
the package through child class. If you do not make the child class, it cannot be
accessed from outside the package.
4. Public: The access level of a public modifier is everywhere. It can be accessed from
within the class, outside the class, within the package and outside the package.
There are many non-access modifiers, such as static, abstract, synchronized, native,
volatile, transient, etc. Here, we are going to learn the access modifiers only.
Understanding Java Access Modifiers

Let's understand the access modifiers in Java by a simple table.
Access within within outside package by subclass outside

Modifier class package only package
Private Y N N N
Default Y Y N N
Protected Y Y Y N
Public Y Y Y Y
1) Private
The private access modifier is accessible only within the class.
Simple example of private access modifier
In this example, we have created two classes A and Simple. A class contains private
data member and private method. We are accessing these private members from
outside the class, so there is a compile-time error.
1. class A{
2. private int data=40;
3. private void msg(){System.out.println("Hello java");}
4. }
5.
6. public class Simple{
8. A obj=new A();
9. System.out.println(obj.data);//Compile Time Error
10. obj.msg();//Compile Time Error
11. }
12. }
Role of Private Constructor
If you make any class constructor private, you cannot create the instance of that class
from outside the class. For example:
1. class A{
2. private A(){}//private constructor
3. void msg(){System.out.println("Hello java");}
4. }
7. A obj=new A();//Compile Time Error
8. }
9. }
Note: A class cannot be private or protected except nested class.
2) Default
If you don't use any modifier, it is treated as default by default. The default modifier
is accessible only within package. It cannot be accessed from outside the package. It
provides more accessibility than private. But, it is more restrictive than protected, and
public.
Example of default access modifier
In this example, we have created two packages pack and mypack. We are accessing
the A class from outside its package, since A class is not public, so it cannot be
accessed from outside the package.
1. //save by A.java
2. package pack;
3. class A{
4. void msg(){System.out.println("Hello");}
5. }
1. //save by B.java
2. package mypack;
3. import pack.*;
4. class B{
6. A obj = new A();//Compile Time Error
7. obj.msg();//Compile Time Error
8. }
9. }
In the above example, the scope of class A and its method msg() is default so it
cannot be accessed from outside the package.
3) Protected
The protected access modifier is accessible within package and outside the
package but through inheritance only.
The protected access modifier can be applied on the data member, method and
constructor. It can't be applied on the class.
It provides more accessibility than the default modifer.
Example of protected access modifier
In this example, we have created the two packages pack and mypack. The A class of
pack package is public, so can be accessed from outside the package. But msg
method of this package is declared as protected, so it can be accessed from outside
the class only through inheritance.
1. //save by A.java
2. package pack;
3. public class A{
4. protected void msg(){System.out.println("Hello");}
5. }
1. //save by B.java
2. package mypack;
3. import pack.*;
4.
5. class B extends A{
7. B obj = new B();
8. obj.msg();
9. }
10. }
Output:Hello
4) Public
The public access modifier is accessible everywhere. It has the widest scope among
all other modifiers.
Example of public access modifier

1. //save by A.java
2.
3. package pack;
4. public class A{
5. public void msg(){System.out.println("Hello");}
6. }
1. //save by B.java
2.
3. package mypack;
4. import pack.*;
5.
6. class B{
8. A obj = new A();
9. obj.msg();
10. }
11. }
Output:Hello
Java Access Modifiers with Method Overriding

If you are overriding any method, overridden method (i.e. declared in subclass) must
not be more restrictive.
1. class A{
2. protected void msg(){System.out.println("Hello java");}
3. }
4.
5. public class Simple extends A{
6. void msg(){System.out.println("Hello java");}//C.T.Error
8. Simple obj=new Simple();
9. obj.msg();
10. }
11. }
The default modifier is more restrictive than protected. That is why, there is a
compile-time error.
Java Comments
The Java comments are the statements in a program that are not executed by the
compiler and interpreter.
Types of Java Comments

There are three types of comments in Java.
1. Single Line Comment

2. Multi Line Comment
3. Documentation Comment
1) Java Single Line Comment
The single-line comment is used to comment only one line of the code. It is the
widely used and easiest way of commenting the statements.
Single line comments starts with two forward slashes (//). Any text in front of // is
not executed by Java.
Syntax:
1. //This is single line comment
Let's use single line comment in a Java program.
CommentExample1.java
1. public class CommentExample1 {

3. int i=10; // i is a variable with value 10
4. System.out.println(i); //printing the variable i
5. }
6. }
Output:
10
2) Java Multi Line Comment

The multi-line comment is used to comment multiple lines of code. It can be used to
explain a complex code snippet or to comment multiple lines of code at a time (as it
will be difficult to use single-line comments there).
Multi-line comments are placed between /* and */. Any text between /* and */ is not
executed by Java.
Syntax:
1. /*
2. This
3. is
4. multi line
5. comment
6. */
Let's use multi-line comment in a Java program.
CommentExample2.java
1. public class CommentExample2 {

3. /* Let's declare and
4. print variable in java. */
5. int i=10;
7. /* float j = 5.9;
8. float k = 4.4;
9. System.out.println( j + k ); */
10. }
11. }
Output:
10
Note: Usually // is used for short comments and /* */ is used for longer comments.
3) Java Documentation Comment

Documentation comments are usually used to write large programs for a project or
software application as it helps to create documentation API. These APIs are needed
for reference, i.e., which classes, methods, arguments, etc., are used in the code.
To create documentation API, we need to use the javadoc tool. The documentation
comments are placed between /** and */.
Syntax:
1. /**
2. *
3. *We can use various tags to depict the parameter
4. *or heading or author name
5. *We can also use HTML tags
6. *
7. */
UNIT II : INHERITANCE, INTERFACES AND PACKAGES
Method Overloading in Java

If a class has multiple methods having same name but different in parameters, it is
known as Method Overloading.
If we have to perform only one operation, having same name of the methods
increases the readability of the program.
Suppose you have to perform addition of the given numbers but there can be any
number of arguments, if you write the method such as a(int,int) for two parameters,
and b(int,int,int) for three parameters then it may be difficult for you as well as other
programmers to understand the behavior of the method because its name differs.
So, we perform method overloading to figure out the program quickly.ute
Advantage of method overloading
Method overloading increases the readability of the program.
Different ways to overload the method
There are two ways to overload the method in java
1. By changing number of arguments

2. By changing the data type
1) Method Overloading: changing no. of arguments

In this example, we have created two methods, first add() method performs addition
of two numbers and second add method performs addition of three numbers.
In this example, we are creating static methods so that we don't need to create
instance for calling methods.
1. class Adder{
2. static int add(int a,int b){return a+b;}
3. static int add(int a,int b,int c){return a+b+c;}
4. }
5. class TestOverloading1{
7. System.out.println(Adder.add(11,11));
8. System.out.println(Adder.add(11,11,11));
9. }}
Test it Now
Output:
22
33
2) Method Overloading: changing data type of arguments

In this example, we have created two methods that differs in data type. The first add
method receives two integer arguments and second add method receives two
double arguments.
1. class Adder{
2. static int add(int a, int b){return a+b;}
3. static double add(double a, double b){return a+b;}
4. }
5. class TestOverloading2{
7. System.out.println(Adder.add(11,11));
8. System.out.println(Adder.add(12.3,12.6));
9. }}
Test it Now
Output:
22
24.9
Objects as Parameters – Returning Objects
Java Pass by Value

People usually take the pass by value and pass by reference terms together. It is
really confusing and overhear questions in interviews, Is java pass by value or passes
by reference, or both? So the answer to this question is Java is strictly pass by value.
There is no pass by reference in Java.
Let's understand what some of the different mechanisms for passing parameters to
functions are:
 value
 reference
 result
 value-result
 name
Nowadays, the two most used and common mechanisms are pass by value and pass
by reference. Let's discuss them:
Call by (or) Pass by Value: In the pass by value concept, the method is called by
passing a value. So, it is called pass by value. It does not affect the original
parameter.
Call by (or) Pass by Reference: In the pass by reference concept, the method is
called using an alias or reference of the actual parameter. So, it is called pass by
reference. It forwards the unique identifier of the object to the method. If we made
changes to the parameter's instance member, it would affect the original value.
Java does not support pass by reference concept.

Java Inner Classes
Java inner class or nested class is a class which is declared inside the class or interface.
We use inner classes to logically group classes and interfaces in one place so that it can be
more
readable and maintainable.
Syntax of Inner class
1. class Java_Outer_class{
2. //code
3. class Java_Inner_class{
4. //code
5. } }
Advantage of java inner classes

There are basically three advantages of inner classes in java. They are as follows:
1) Nested classes represent a special type of relationship that is it can access all the
members
(data members and methods) of outer class including private.

2) Nested classes are used to develop more readable and maintainable code because
it
logically group classes and interfaces in one place only.
3) Code Optimization: It requires less code to write.

Difference between nested class and inner class in Java
Inner class is a part of nested class. Non-static nested classes are known as inner
classes.
Types of Nested classes

There are two types of nested classes non-static and static nested classes.The non-
static nested
classes are also known as inner classes.

Non-static nested class (inner class)
 Member inner class

 Anonymous inner class
 Local inner class

Static nested class
Java static nested class

A static class is a class that is created inside a class, is called a static nested class in
Java. It cannot access non-static data members and methods. It can be accessed by
outer class name.
 It can access static data members of the outer class, including private.
 The static nested class cannot access non-static (instance) data members or
Java static nested class example with instance

method
TestOuter1.java
1. class TestOuter1{
2. static int data=30;
3. static class Inner{
4. void msg(){System.out.println("data is "+data);}
5. }
7. TestOuter1.Inner obj=new TestOuter1.Inner();
8. obj.msg();
9. }
10. }
Output:
data is 30
In this example, you need to create the instance of static nested class because it has
instance method msg(). But you don't need to create the object of the Outer class
because the nested class is static and static properties, methods, or classes can be
accessed without an object.
Inheritance in Java
1. Inheritance
2. Types of Inheritance
3. Why multiple inheritance is not possible in Java in case of class?
Inheritance in Java is a mechanism in which one object acquires all the properties
and behaviors of a parent object. It is an important part of OOPs (Object Oriented
programming system).
The idea behind inheritance in Java is that you can create new classes that are built
upon existing classes. When you inherit from an existing class, you can reuse
methods and fields of the parent class. Moreover, you can add new methods and
fields in your current class also.
Inheritance represents the IS-A relationship which is also known as a parent-

child relationship.
Why use inheritance in java
o For Method Overriding (so runtime polymorphism can be achieved).

o For Code Reusability.
Terms used in Inheritance
o Class: A class is a group of objects which have common properties. It is a

template or blueprint from which objects are created.
o Sub Class/Child Class: Subclass is a class which inherits the other class. It is
also called a derived class, extended class, or child class.
o Super Class/Parent Class: Superclass is the class from where a subclass
inherits the features. It is also called a base class or a parent class.
o Reusability: As the name specifies, reusability is a mechanism which facilitates
you to reuse the fields and methods of the existing class when you create a
new class. You can use the same fields and methods already defined in the
previous class.
The syntax of Java Inheritance
1. class Subclass-name extends Superclass-name

2. {
3. //methods and fields
4. }
The extends keyword indicates that you are making a new class that derives from an
existing class. The meaning of "extends" is to increase the functionality.
In the terminology of Java, a class which is inherited is called a parent or superclass,

and the new class is called child or subclass.
Java Inheritance Example
As displayed in the above figure, Programmer is the subclass and Employee is the
superclass. The relationship between the two classes is Programmer IS-A Employee.
It means that Programmer is a type of Employee.
1. class Employee{
2. float salary=40000;
3. }
4. class Programmer extends Employee{
5. int bonus=10000;
7. Programmer p=new Programmer();
8. System.out.println("Programmer salary is:"+p.salary);
9. System.out.println("Bonus of Programmer is:"+p.bonus);
10. }
11. }
Programmer salary is:40000.0
Bonus of programmer is:10000
In the above example, Programmer object can access the field of own class as well as
of Employee class i.e. code reusability.
Types of inheritance in java

On the basis of class, there can be three types of inheritance in java: single, multilevel
and hierarchical.
In java programming, multiple and hybrid inheritance is supported through interface

only. We will learn about interfaces later.
Note: Multiple inheritance is not supported in Java through class.

When one class inherits multiple classes, it is known as multiple inheritance. For
Example:
Single Inheritance Example

When a class inherits another class, it is known as a single inheritance. In the example
given below, Dog class inherits the Animal class, so there is the single inheritance.
File: TestInheritance.java
1. class Animal{
2. void eat(){System.out.println("eating...");}
3. }
4. class Dog extends Animal{
5. void bark(){System.out.println("barking...");}
6. }
7. class TestInheritance{
9. Dog d=new Dog();
10. d.bark();
11. d.eat();
12. }}
Output:
barking...
eating...
Multilevel Inheritance Example

When there is a chain of inheritance, it is known as multilevel inheritance. As you can
see in the example given below, BabyDog class inherits the Dog class which again
inherits the Animal class, so there is a multilevel inheritance.
File: TestInheritance2.java
1. class Animal{
3. }
6. }
7. class BabyDog extends Dog{
8. void weep(){System.out.println("weeping...");}
9. }
10. class TestInheritance2{
12. BabyDog d=new BabyDog();
13. d.weep();
14. d.bark();
15. d.eat();
16. }}
Output:
weeping...
barking...
eating...
Hierarchical Inheritance Example
When two or more classes inherits a single class, it is known as hierarchical
inheritance. In the example given below, Dog and Cat classes inherits the Animal
class, so there is hierarchical inheritance.
File: TestInheritance3.java
1. class Animal{
3. }
6. }
7. class Cat extends Animal{
8. void meow(){System.out.println("meowing...");}
9. }
10. class TestInheritance3{
12. Cat c=new Cat();
13. c.meow();
14. c.eat();
15. //c.bark();//C.T.Error
16. }}
Output:
meowing...
eating...
Abstract class in Java

A class which is declared with the abstract keyword is known as an abstract class
in Java. It can have abstract and non-abstract methods (method with the body).
Before learning the Java abstract class, let's understand the abstraction in Java first.
Abstraction in Java
Abstraction is a process of hiding the implementation details and showing only
functionality to the user.
Another way, it shows only essential things to the user and hides the internal details,
for example, sending SMS where you type the text and send the message. You don't
know the internal processing about the message delivery.
Abstraction lets you focus on what the object does instead of how it does it.
Ways to achieve Abstraction
There are two ways to achieve abstraction in java
1. Abstract class (0 to 100%)

2. Interface (100%)
A class which is declared as abstract is known as an abstract class. It can have

abstract and non-abstract methods. It needs to be extended and its method
implemented. It cannot be instantiated.
Points to Remember
o An abstract class must be declared with an abstract keyword.

o It can have abstract and non-abstract methods.
o It cannot be instantiated.
o It can have constructors and static methods also.
o It can have final methods which will force the subclass not to change the body
of the method.
Example of abstract class
1. abstract class A{}
Abstract Method in Java

A method which is declared as abstract and does not have implementation is known
as an abstract method.
Example of abstract method
1. abstract void printStatus();//no method body and abstract
Example of Abstract class that has an abstract method

In this example, Bike is an abstract class that contains only one abstract method run.
Its implementation is provided by the Honda class.
1. abstract class Bike{

2. abstract void run();
3. }
4. class Honda4 extends Bike{
5. void run(){System.out.println("running safely");}
7. Bike obj = new Honda4();
8. obj.run();
9. }
10. }
running safely
Understanding the real scenario of Abstract class

In this example, Shape is the abstract class, and its implementation is provided by the
Rectangle and Circle classes.
Mostly, we don't know about the implementation class (which is hidden to the end
user), and an object of the implementation class is provided by the factory method.
A factory method is a method that returns the instance of the class. We will learn
about the factory method later.
In this example, if you create the instance of Rectangle class, draw() method of
Rectangle class will be invoked.
File: TestAbstraction1.java
1. abstract class Shape{

2. abstract void draw();
3. }
4. //In real scenario, implementation is provided by others i.e. unknown by end user
5. class Rectangle extends Shape{
6. void draw(){System.out.println("drawing rectangle");}
7. }
8. class Circle1 extends Shape{
9. void draw(){System.out.println("drawing circle");}
10. }
11. //In real scenario, method is called by programmer or user
12. class TestAbstraction1{
14. Shape s=new Circle1();//In a real scenario, object is provided through method, e.g., g
etShape() method
15. s.draw();
16. }
17. }
drawing circle
Java Packages
A java package is a group of similar types of classes, interfaces and sub-packages.
Package in java can be categorized in two form, built-in package and user-defined
package.
There are many built-in packages such as java, lang, awt, javax, swing, net, io, util, sql
etc.
Here, we will have the detailed learning of creating and using user-defined package
Advantage of Java Package
1) Java package is used to categorize the classes and interfaces so that they can be
easily maintained.
2) Java package provides access protection.
3) Java package removes naming collision.
Simple example of java package

The package keyword is used to create a package in java.
1. //save as Simple.java
2. package mypack;
5. System.out.println("Welcome to package");
6. }
7. }
How to compile java package
If you are not using any IDE, you need to follow the syntax given below:
1. javac -d directory javafilename
For example
1. javac -d . Simple.java
The -d switch specifies the destination where to put the generated class file. You can
use any directory name like /home (in case of Linux), d:/abc (in case of windows) etc.
If you want to keep the package within the same directory, you can use . (dot).
How to run java package program
You need to use fully qualified name e.g. mypack.Simple etc to run the class.
To Compile: javac -d . Simple.java

To Run: java mypack.Simple
Output:Welcome to package
The -d is a switch that tells the compiler where to put the class file i.e. it represents destination.
represents the current folder.
How to access package from another package?

There are three ways to access the package from outside the package.
1. import package.*;
2. import package.classname;
3. fully qualified name.
1) Using packagename.*
If you use package.* then all the classes and interfaces of this package will be
accessible but not subpackages.
The import keyword is used to make the classes and interface of another package
accessible to the current package.
Example of package that import the packagename.*
1. //save by A.java
2. package pack;
3. public class A{
5. }
1. //save by B.java
2. package mypack;
3. import pack.*;
4.
5. class B{
7. A obj = new A();
8. obj.msg();
9. }
10. }
Output:Hello
2) Using packagename.classname
If you import package.classname then only declared class of this package will be
accessible.
Example of package by import package.classname

1. //save by A.java
2.
3. package pack;
4. public class A{
6. }
1. //save by B.java
2. package mypack;
3. import pack.A;
4.
5. class B{
7. A obj = new A();
8. obj.msg();
9. }
10. }
Output:Hello
Interface in Java
An interface in Java is a blueprint of a class. It has static constants and abstract
methods.
The interface in Java is a mechanism to achieve abstraction. There can be only

abstract methods in the Java interface, not method body. It is used to achieve
abstraction and multiple inheritance in Java.
In other words, you can say that interfaces can have abstract methods and variables.
It cannot have a method body.
Java Interface also represents the IS-A relationship
It cannot be instantiated just like the abstract class.
Since Java 8, we can have default and static methods in an interface.
Since Java 9, we can have private methods in an interface.
Why use Java interface?

There are mainly three reasons to use interface. They are given below.
o It is used to achieve abstraction.

o By interface, we can support the functionality of multiple inheritance.
o It can be used to achieve loose coupling.
o It can be used to achieve loose coupling.

How to declare an interface?
An interface is declared by using the interface keyword. It provides total abstraction;
means all the methods in an interface are declared with the empty body, and all the
fields are public, static and final by default. A class that implements an interface must
implement all the methods declared in the interface.
Syntax:
1. interface <interface_name>{
2.
3. // declare constant fields
4. // declare methods that abstract
5. // by default.
6. }
Internal addition by the compiler

The Java compiler adds public and abstract keywords before the interface method.
Moreover, it adds public, static and final keywords before data members.
In other words, Interface fields are public, static and final by default, and the methods
are public and abstract.
The relationship between classes and interfaces
As shown in the figure given below, a class extends another class, an interface
extends another interface, but a class implements an interface.
Java Interface Example

In this example, the Printable interface has only one method, and its implementation
is provided in the A6 class.
1. interface printable{
2. void print();
3. }
4. class A6 implements printable{
5. public void print(){System.out.println("Hello");}
6.
8. A6 obj = new A6();
9. obj.print();
10. }
11. }
Output:
Hello
Multiple inheritance in Java by interface

If a class implements multiple interfaces, or an interface extends multiple interfaces, it
is known as multiple inheritance.
1. interface Printable{
2. void print();
3. }
4. interface Showable{
5. void show();
6. }
7. class A7 implements Printable,Showable{
8. public void print(){System.out.println("Hello");}
9. public void show(){System.out.println("Welcome");}
10.
12. A7 obj = new A7();
13. obj.print();
14. obj.show();
15. }
16. }
Output: Hello
Welcome
Java Default Methods

Java provides a facility to create default methods inside the interface. Methods which
are defined inside the interface and tagged with default are known as default
methods. These methods are non-abstract methods.
Java Default Method Example

In the following example, Sayable is a functional interface that contains a default and
an abstract method. The concept of default method is used to define a method with
default implementation. You can override default method also to provide more
specific implementation for the method.
Let's see a simple
1. interface Sayable{
2. // Default method
3. default void say(){
4. System.out.println("Hello, this is default method");
5. }
6. // Abstract method
7. void sayMore(String msg);
8. }
9. public class DefaultMethods implements Sayable{
10. public void sayMore(String msg){ // implementing abstract method
11. System.out.println(msg);
12. }
14. DefaultMethods dm = new DefaultMethods();
15. dm.say(); // calling default method
16. dm.sayMore("Work is worship"); // calling abstract method
17.
18. }
19. }
Output:
Hello, this is default method

Work is worship
Static Methods inside Java 8 Interface

You can also define static methods inside the interface. Static methods are used to
define utility methods. The following example explain, how to implement static
method in interface?
1. interface Sayable{
2. // default method
3. default void say(){
4. System.out.println("Hello, this is default method");
5. }
6. // Abstract method
7. void sayMore(String msg);
8. // static method
9. static void sayLouder(String msg){
11. }
12. }
13. public class DefaultMethods implements Sayable{
14. public void sayMore(String msg){ // implementing abstract method
16. }
18. DefaultMethods dm = new DefaultMethods();
19. dm.say(); // calling default method
20. dm.sayMore("Work is worship"); // calling abstract method
21. Sayable.sayLouder("Helloooo..."); // calling static method
22. }
23. }
Output:
Hello there
Work is worship
Helloooo...
UNIT III: THREADS AND EXCEPTION HANDLING
Exception Handling in Java

The Exception Handling in Java is one of the powerful mechanism to handle the
runtime errors so that the normal flow of the application can be maintained.
What is Exception in Java?

Dictionary Meaning: Exception is an abnormal condition.
In Java, an exception is an event that disrupts the normal flow of the program. It is an
object which is thrown at runtime.
Advantage of Exception Handling
The core advantage of exception handling is to maintain the normal flow of the
application. An exception normally disrupts the normal flow of the application; that
is why we need to handle exceptions. Let's consider a scenario:
1. statement 1;
2. statement 2;
3. statement 3;
4. statement 4;
5. statement 5;//exception occurs
6. statement 6;
7. statement 7;
8. statement 8;
9. statement 9;
10. statement 10;
Suppose there are 10 statements in a Java program and an exception occurs at

statement 5; the rest of the code will not be executed, i.e., statements 6 to 10 will not
be executed. However, when we perform exception handling, the rest of the
statements will be executed. That is why we use exception handling in Java.
Hierarchy of Java Exception classes
The java.lang.Throwable class is the root class of Java Exception hierarchy inherited
by two subclasses: Exception and Error. The hierarchy of Java Exception classes is
given below:
Types of Java Exceptions

There are mainly two types of exceptions: checked and unchecked. An error is
considered as the unchecked exception. However, according to Oracle, there are
three types of exceptions namely:
1. Checked Exception
2. Unchecked Exception
3. Error
Difference between Checked and Unchecked
Exceptions
1) Checked Exception
The classes that directly inherit the Throwable class except RuntimeException and
Error are known as checked exceptions. For example, IOException, SQLException, etc.
Checked exceptions are checked at compile-time.
2) Unchecked Exception
The classes that inherit the RuntimeException are known as unchecked exceptions.
For example, ArithmeticException, NullPointerException,
ArrayIndexOutOfBoundsException, etc. Unchecked exceptions are not checked at
compile-time, but they are checked at runtime.
3) Error
Error is irrecoverable. Some example of errors are OutOfMemoryError,

VirtualMachineError, AssertionError etc.
Java Exception Keywords

Java provides five keywords that are used to handle the exception. The following
table describes each.
Keyword Description
try The "try" keyword is used to specify a block where we should place an exception code. It
means we can't use try block alone. The try block must be followed by either catch or
finally.
catch The "catch" block is used to handle the exception. It must be preceded by try block which
means we can't use catch block alone. It can be followed by finally block later.
finally The "finally" block is used to execute the necessary code of the program. It is executed
whether an exception is handled or not.
throw The "throw" keyword is used to throw an exception.
throws The "throws" keyword is used to declare exceptions. It specifies that there may occur an
exception in the method. It doesn't throw an exception. It is always used with method
signature.
Java Exception Handling Example

Let's see an example of Java Exception Handling in which we are using a try-catch
statement to handle the exception.
JavaExceptionExample.java
1. public class JavaExceptionExample{

3. try{
4. //code that may raise exception
5. int data=100/0;
6. }catch(ArithmeticException e){System.out.println(e);}
7. //rest code of the program
8. System.out.println("rest of the code...");
9. }
10. }
Output:
Exception in thread main java.lang.ArithmeticException:/ by zero

rest of the code...
In the above example, 100/0 raises an ArithmeticException which is handled by a try-
catch block.
Java try-catch block

Java try block
Java try block is used to enclose the code that might throw an exception. It must be
used within the method.
If an exception occurs at the particular statement in the try block, the rest of the
block code will not execute. So, it is recommended not to keep the code in try block
that will not throw an exception.
Java try block must be followed by either catch or finally block.
Syntax of Java try-catch
1. try{
2. //code that may throw an exception
3. }catch(Exception_class_Name ref){}
Syntax of try-finally block
1. try{
2. //code that may throw an exception
3. }finally{}
Java catch block

Java catch block is used to handle the Exception by declaring the type of exception
within the parameter. The declared exception must be the parent class exception (
i.e., Exception) or the generated exception type. However, the good approach is to
declare the generated type of exception.
The catch block must be used after the try block only. You can use multiple catch
block with a single try block.
Internal Working of Java try-catch block

The JVM firstly checks whether the exception is handled or not. If exception is not
handled, JVM provides a default exception handler that performs the following tasks:
o Prints out exception description.

o Prints the stack trace (Hierarchy of methods where the exception occurred).
o Causes the program to terminate.
But if the application programmer handles the exception, the normal flow of the
application is maintained, i.e., rest of the code is executed.
Problem without exception handling

Let's try to understand the problem if we don't use a try-catch block.
Example 1
TryCatchExample1.java
1. public class TryCatchExample1 {

2.
4.
5. int data=50/0; //may throw exception
6.
7. System.out.println("rest of the code");
8.
9. }
10.
11. }
Life cycle of a Thread (Thread States)

In Java, a thread always exists in any one of the following states. These states are:
1. New
2. Active
3. Blocked / Waiting
4. Timed Waiting
5. Terminated
Explanation of Different Thread States

New: Whenever a new thread is created, it is always in the new state. For a thread in
the new state, the code has not been run yet and thus has not begun its execution.
Active: When a thread invokes the start() method, it moves from the new state to the
active state. The active state contains two states within it: one is runnable, and the
other is running.
Runnable: A thread, that is ready to run is then moved to the runnable state. In
the runnable state, the thread may be running or may be ready to run at any
given instant of time. It is the duty of the thread scheduler to provide the thread
time to run, i.e., moving the thread the running state.
A program implementing multithreading acquires a fixed slice of time to each
individual thread. Each and every thread runs for a short span of time and when
that allocated time slice is over, the thread voluntarily gives up the CPU to the
other thread, so that the other threads can also run for their slice of time.
Whenever such a scenario occurs, all those threads that are willing to run, waiting
for their turn to run, lie in the runnable state. In the runnable state, there is a
queue where the threads lie.
Running: When the thread gets the CPU, it moves from the runnable to the
running state. Generally, the most common change in the state of a thread is
from runnable to running and again back to runnable.
Blocked or Waiting: Whenever a thread is inactive for a span of time (not

permanently) then, either the thread is in the blocked state or is in the waiting state.
For example, a thread (let's say its name is A) may want to print some data from the
printer. However, at the same time, the other thread (let's say its name is B) is using
the printer to print some data. Therefore, thread A has to wait for thread B to use the
printer. Thus, thread A is in the blocked state. A thread in the blocked state is unable
to perform any execution and thus never consume any cycle of the Central
Processing Unit (CPU). Hence, we can say that thread A remains idle until the thread
scheduler reactivates thread A, which is in the waiting or blocked state.
When the main thread invokes the join() method then, it is said that the main thread
is in the waiting state. The main thread then waits for the child threads to complete
their tasks. When the child threads complete their job, a notification is sent to the
main thread, which again moves the thread from waiting to the active state.
If there are a lot of threads in the waiting or blocked state, then it is the duty of the
thread scheduler to determine which thread to choose and which one to reject, and
the chosen thread is then given the opportunity to run.
Timed Waiting: Sometimes, waiting for leads to starvation. For example, a thread (its
name is A) has entered the critical section of a code and is not willing to leave that
critical section. In such a scenario, another thread (its name is B) has to wait forever,
which leads to starvation. To avoid such scenario, a timed waiting state is given to
thread B. Thus, thread lies in the waiting state for a specific span of time, and not
forever. A real example of timed waiting is when we invoke the sleep() method on a
specific thread. The sleep() method puts the thread in the timed wait state. After the
time runs out, the thread wakes up and start its execution from when it has left
earlier.
Terminated: A thread reaches the termination state because of the following

reasons:
o When a thread has finished its job, then it exists or terminates normally.
o Abnormal termination: It occurs when some unusual events such as an
unhandled exception or segmentation fault.
A terminated thread means the thread is no more in the system. In other words, the
thread is dead, and there is no way one can respawn (active after kill) the dead
thread.
The following diagram shows the different states involved in the life cycle of a thread.
Implementation of Thread States

In Java, one can get the current state of a thread using the Thread.getState()
method. The java.lang.Thread.State class of Java provides the constants ENUM to
represent the state of a thread. These constants are:
1. public static final Thread.State NEW
It represents the first state of a thread that is the NEW state.
1. public static final Thread.State RUNNABLE
It represents the runnable state.It means a thread is waiting in the queue to run.
1. public static final Thread.State BLOCKED
It represents the blocked state. In this state, the thread is waiting to acquire a lock.
1. public static final Thread.State WAITING

It represents the waiting state. A thread will go to this state when it invokes the
Object.wait() method, or Thread.join() method with no timeout. A thread in the
waiting state is waiting for another thread to complete its task.
1. public static final Thread.State TIMED_WAITING
It represents the timed waiting state. The main difference between waiting and timed
waiting is the time constraint. Waiting has no time constraint, whereas timed waiting
has the time constraint. A thread invoking the following method reaches the timed
waiting state.
o sleep
o join with timeout
o wait with timeout
o parkUntil
o parkNanos
1. public static final Thread.State TERMINATED
It represents the final state of a thread that is terminated or dead. A terminated

thread means it has completed its execution.
Java Program for Demonstrating Thread States

The following Java program shows some of the states of a thread defined above.
FileName: ThreadState.java
1. // ABC class implements the interface Runnable

2. class ABC implements Runnable
3. {
4. public void run()
5. {
6.
7. // try-catch block
8. try
9. {
10. // moving thread t2 to the state timed waiting
11. Thread.sleep(100);
12. }
13. catch (InterruptedException ie)
14. {
15. ie.printStackTrace();
16. }
17.
18.
19. System.out.println("The state of thread t1 while it invoked the method join() on threa
d t2 -"+ ThreadState.t1.getState());
20.
21. // try-catch block
22. try
23. {
25. }
27. {
29. }
30. }
31. }
32.
33. // ThreadState class implements the interface Runnable
34. public class ThreadState implements Runnable
35. {
36. public static Thread t1;
37. public static ThreadState obj;
38.
39. // main method
40. public static void main(String argvs[])
41. {
42. // creating an object of the class ThreadState
43. obj = new ThreadState();
44. t1 = new Thread(obj);
45.
46. // thread t1 is spawned
47. // The thread t1 is currently in the NEW state.
48. System.out.println("The state of thread t1 after spawning it - " + t1.getState());
49.
50. // invoking the start() method on
51. // the thread t1
52. t1.start();
53.
54. // thread t1 is moved to the Runnable state
55. System.out.println("The state of thread t1 after invoking the method start() on it -
" + t1.getState());
56. }
57.
58. public void run()
59. {
60. ABC myObj = new ABC();
61. Thread t2 = new Thread(myObj);
62.
63. // thread t2 is created and is currently in the NEW state.
64. System.out.println("The state of thread t2 after spawning it - "+ t2.getState());
65. t2.start();
66.
67. // thread t2 is moved to the runnable state
68. System.out.println("the state of thread t2 after calling the method start() on it -
" + t2.getState());
69.
70. // try-catch block for the smooth flow of the program
71. try
72. {
73. // moving the thread t1 to the state timed waiting
75. }
77. {
79. }
80.
81. System.out.println("The state of thread t2 after invoking the method sleep() on it -
"+ t2.getState() );
82.
83. // try-catch block for the smooth flow of the program
84. try
85. {
86. // waiting for thread t2 to complete its execution
87. t2.join();
88. }
90. {
92. }
93. System.out.println("The state of thread t2 when it has completed it's execution -
" + t2.getState());
94. }
95.
96. }
Output:
The state of thread t1 after spawning it - NEW

The state of thread t1 after invoking the method start() on it - RUNNABLE
The state of thread t2 after spawning it - NEW
the state of thread t2 after calling the method start() on it - RUNNABLE
The state of thread t1 while it invoked the method join() on thread t2 -
TIMED_WAITING
The state of thread t2 after invoking the method sleep() on it -
TIMED_WAITING
The state of thread t2 when it has completed it's execution - TERMINATED
Explanation: Whenever we spawn a new thread, that thread attains the new state.
When the method start() is invoked on a thread, the thread scheduler moves that
thread to the runnable state. Whenever the join() method is invoked on any thread
instance, the current thread executing that statement has to wait for this thread to
finish its execution, i.e., move that thread to the terminated state. Therefore, before
the final print statement is printed on the console, the program invokes the method
join() on thread t2, making the thread t1 wait while the thread t2 finishes its
execution and thus, the thread t2 get to the terminated or dead state. Thread t1 goes
to the waiting state because it is waiting for thread t2 to finish it's execution as it has
invoked the method join() on thread t2.

Java Runnable Interface
Java runnable is an interface used to execute code on a concurrent thread. It is an
interface which is implemented by any class if we want that the instances of that class
should be executed by a thread.
The runnable interface has an undefined method run() with void as return type, and
it takes in no arguments. The method summary of the run() method is given below-
Method Description
public void This method takes in no arguments. When the object of a class implementing Runnable
run() class is used to create a thread, then the run method is invoked in the thread which
executes separately.
The runnable interface provides a standard set of rules for the instances of classes
which wish to execute code when they are active. The most common use case of the
Runnable interface is when we want only to override the run method. When a thread
is started by the object of any class which is implementing Runnable, then it invokes
the run method in the separately executing thread.
A class that implements Runnable runs on a different thread without subclassing

Thread as it instantiates a Thread instance and passes itself in as the target. This
becomes important as classes should not be subclassed unless there is an intention
of modifying or enhancing the fundamental behavior of the class.
Runnable class is extensively used in network programming as each thread

represents a separate flow of control. Also in multi-threaded programming, Runnable
class is used. This interface is present in java.lang package.
Implementing Runnable
It is the easiest way to create a thread by implementing Runnable. One can create a
thread on any object by implementing Runnable. To implement a Runnable, one has
only to implement the run method.
public void run()
In this method, we have the code which we want to execute on a concurrent thread.
In this method, we can use variables, instantiate classes, and perform an action like
the same way the main thread does. The thread remains until the return of this
method. The run method establishes an entry point to a new thread.
How to create a thread using Runnable interface
To create a thread using runnable, use the following code-
1. Runnable runnable = new MyRunnable();

2.
3. Thread thread = new Thread(runnable);
4. thread.start();
The thread will execute the code which is mentioned in the run() method of the
Runnable object passed in its argument.
A simple thread example using runnable

1. public class ExampleClass implements Runnable {
2.
3. @Override
4. public void run() {
5. System.out.println("Thread has ended");
6. }
7.
9. ExampleClass ex = new ExampleClass();
10. Thread t1= new Thread(ex);
11. t1.start();
12. System.out.println("Hi");
13. }
14. }
Output:
Thread vs. Runnable
There are several differences between Thread class and Runnable interface based on
their performance, memory usage, and composition.
 By extending thread, there is overhead of additional methods, i.e. they

consume excess or indirect memory, computation time, or other resources.
 Since in Java, we can only extend one class, and therefore if we extend
Thread class, then we will not be able to extend any other class. That is why
we should implement Runnable interface to create a thread.
 Runnable makes the code more flexible as, if we are extending a thread,
then our code will only be in a thread whereas, in case of runnable, one
can pass it in various executor services, or pass it to the single-threaded
environment.
 Maintenance of the code is easy if we implement the Runnable interface.
Multi-threading
Multithreading in Java is a process of executing multiple threads simultaneously.
A thread is a lightweight sub-process, the smallest unit of processing.

Multiprocessing and multithreading, both are used to achieve multitasking.
However, we use multithreading than multiprocessing because threads use a shared

memory area. They don't allocate separate memory area so saves memory, and
context-switching between the threads takes less time than process.
Java Multithreading is mostly used in games, animation, etc.

Advantages of Java Multithreading
1) It doesn't block the user because threads are independent and you can perform
multiple operations at the same time.
2) You can perform many operations together, so it saves time.
3) Threads are independent, so it doesn't affect other threads if an exception occurs

in a single thread.
Multitasking
Multitasking is a process of executing multiple tasks simultaneously. We use
multitasking to utilize the CPU. Multitasking can be achieved in two ways:
 Process-based Multitasking (Multiprocessing)

 Thread-based Multitasking (Multithreading)
1) Process-based Multitasking (Multiprocessing)

o Each process has an address in memory. In other words, each process allocates a
separate memory area.
o A process is heavyweight.
o Cost of communication between the process is high.
o Switching from one process to another requires some time for saving and
loading registers, memory maps, updating lists, etc.
2) Thread-based Multitasking (Multithreading)

o Threads share the same address space.
o A thread is lightweight.
o Cost of communication between the thread is low.
Note: At least one process is required for each thread.
What is Thread in java

A thread is a lightweight subprocess, the smallest unit of processing. It is a separate
path of execution.
Threads are independent. If there occurs exception in one thread, it doesn't affect
other threads. It uses a shared memory area.
As shown in the above figure, a thread is executed inside the process. There is
context-switching between the threads. There can be multiple processes inside
the OS, and one process can have multiple threads.
Note: At a time one thread is executed only.
Java Thread class

Java provides Thread class to achieve thread programming. Thread class
provides constructors and methods to create and perform operations on a thread.
Thread class extends Object class and implements Runnable interface
User defined Exception

An exception is an issue (run time error) that occurred during the execution of a
program. When an exception occurred the program gets terminated abruptly and,
the code past the line that generated the exception never gets executed.
Java provides us the facility to create our own exceptions which are basically
derived classes of Exception. Creating our own Exception is known as a custom
exception or user-defined exception. Basically, Java custom exceptions are used to
customize the exception according to user needs. In simple words, we can say that
a User-Defined Exception or custom exception is creating your own exception class
and throwing that exception using the ‘throw’ keyword.

22CS302 - UNIT 1 To 3 - Material

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

22CS302 - UNIT 1 To 3 - Material

Uploaded by

Copyright:

Available Formats

22CS302 - JAVA PROGRAMMING

UNIT I INTRODUCTION TO JAVA 9

The basics of OOPs. Object-Oriented Programming is a paradigm that provides many

The main aim of object-oriented programming is to implement real-world entities,

OOPs (Object-Oriented Programming System)

An Object can be defined as an instance of a class. An object contains an address and

In Java, we use method overloading and method overriding to achieve

In Java, we use abstract class and interface to achieve abstraction.

Data Types in Java

Java Primitive Data Types

Java is a statically-typed programming language. It means, all variables must be

There are 8 types of primitive data types:

o boolean data type

boolean false 1 bit

char '\u0000' 2 byte

float 0.0f 4 byte

double 0.0d 8 byte

1. Boolean one = false

Byte Data Type

1. byte a = 10, byte b = -20

Short Data Type

1. short s = 10000, short r = -5000

Int Data Type

1. int a = 100000, int b = -200000

Long Data Type

1. long a = 100000L, long b = -200000L

Float Data Type

Double Data Type

1. char letterA = 'A'

Java Operator Precedence

Operator Type Category Precedence

Unary postfix expr++ expr--

prefix ++expr --expr +expr -expr ~ !

Shift shift << >> >>>

Relational comparison < > <= >= instanceof

Bitwise bitwise AND &

Logical logical AND &&

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

Java Unary Operator

 incrementing/decrementing a value by one

Java Unary Operator Example: ++ and --

Java Unary Operator Example 2: ++ and --

Java Unary Operator Example: ~ and !

Java Arithmetic Operators

Java Arithmetic Operator Example

Java Arithmetic Operator Example: Expression

Java Left Shift Operator

Java Right Shift Operator

Java Right Shift Operator Example

Java Shift Operator Example: >> vs >>>

Java AND Operator Example: Logical && and Bitwise &

1. public class OperatorExample{

Java AND Operator Example: Logical && vs Bitwise &

Java OR Operator Example: Logical || and Bitwise |

1. public class OperatorExample{

Java Ternary Operator

1. public class OperatorExample{

Java Assignment Operator

Java Assignment Operator Example

Java Assignment Operator Example

Java Assignment Operator Example: Adding short

Compile time error

After type cast:

1. /Program name: Palindrome/