Basics of JAVA programming

MODULE-1
An Overview of Java: Object-Oriented Programming, A First Simple Program, A Second
Short Program, Two Control Statements, Using Blocks of Code, Lexical Issues, The Java
Class Libraries, Data Types, Variables, and Arrays: Java Is a Strongly Typed Language,
The Primitive Types, Integers, Floating-Point Types, Characters, Booleans, A Closer Look
at Literals, Variables, Type Conversion and Casting, Automatic Type Promotion in
Expressions, Arrays, A Few Words About Strings

Explain object oriented principles.

Object-oriented principles, also known as the four pillars of object-oriented programming

(OOP), are fundamental concepts that guide the design and implementation of object-oriented
systems. These principles help in building modular, reusable, and maintainable code. The four
main principles of OOP are:

Encapsulation:
Encapsulation is the principle of bundling data (attributes) and the methods (behaviors) that
operate on that data into a single unit called an object. It enables data hiding, as the internal state
of an object can only be accessed and modified through the defined methods, providing control
and ensuring data integrity. Encapsulation helps achieve modularity, as objects can be
independently developed, tested, and modified without affecting other parts of the system.

Inheritance:
Inheritance allows the creation of new classes (derived or child classes) based on existing
classes (base or parent classes). The derived classes inherit the attributes and behaviors of the
parent class, allowing code reuse and promoting hierarchical organization. Inheritance supports
the "is-a" relationship, where a derived class is a specialized version of the base class. It enables
the reuse of code, enhances maintainability, and provides a way to model real-world
relationships.

Polymorphism:
Polymorphism allows objects of different classes to be treated as objects of a common
superclass. It enables methods in different classes to have the same name but different
implementations. Polymorphism supports method overriding (runtime polymorphism), where a
derived class provides its own implementation of a method inherited from the base class, and
method overloading (compile-time polymorphism), where multiple methods with the same

Prof Megha S Kulkarni Page 1

 Basics of JAVA programming

name but different parameter lists exist within a class. Polymorphism promotes code flexibility,
extensibility, and modularity.

Abstraction:
Abstraction focuses on providing simplified and generalized representations of real-world
entities. It allows the creation of abstract classes and interfaces that define common
characteristics and behaviors of related objects. Abstract classes cannot be instantiated and
serve as blueprints for concrete classes, whereas interfaces define contracts that concrete
classes must implement. Abstraction reduces complexity by hiding unnecessary details and
focusing on essential features. It enhances code maintainability, flexibility, and modularity.

These four principles form the foundation of object-oriented programming and provide a
systematic approach to designing and implementing software systems. By leveraging
encapsulation, inheritance,

polymorphism, and abstraction, developers can create modular, reusable, and extensible code
that promotes code organization, reduces redundancy, and enhances maintainability and
scalability.

Describe the meaning of each of the keyword in "public static void main".

In the statement "public static void main", each keyword has a specific meaning in the context
of a Java program:

public: It is an access modifier that specifies the visibility of the method. In this case, public
indicates that the main method can be accessed from any other class.

static: It is a keyword that denotes that the method belongs to the class itself, rather than to an
instance of the class. The main method is always declared as static since it serves as the entry
point of the Java program and can be invoked without creating an object of the class.

void: It is the return type of the method, indicating that the main method does not return any
value.
void means the method performs some actions but does not produce a result that needs to be
returned.

main: It is the name of the method. The main method is a special method in Java that serves as
the entry point for the program. It is the method that gets executed when the program starts
running. It has a specific signature (public static void main(String[] args)) that Java expects to
find in the program.

The complete signature public static void main(String[] args) is the standard declaration for the
main method in Java. The String[] args parameter is an array of strings that can be used to pass
command-line arguments to the program, allowing it to receive input or configuration values
during execution.

Prof Megha S Kulkarni Page 2

 Basics of JAVA programming

EX:
class demo{
Public static void main(String[]args)
{
System.out.println(“HELLO WORLD”);
}
}

In summary, the keywords in public static void main define the visibility, behavior, return type,
and entry point of the main method in a Java program.

Explain different lexical issues in JAVA.

In Java, lexical issues refer to problems or errors related to the lexical structure of the code.
These issues occur when the code violates the rules and conventions defined by the Java
language for forming valid tokens and constructs. Here are some common lexical issues in Java:
Spelling and Case Sensitivity:
Misspelling keywords, class names, variable names, or method names can lead to lexical
errors. Java is case-sensitive, so it's important to use the correct casing when referencing
identifiers. Missing or Mismatched Braces:

For every opening brace {, there should be a corresponding closing brace }. Missing or
mismatched braces can cause syntax errors and lead to incorrect program flow. Incorrect or
Unbalanced Quotes:

Strings in Java should be enclosed in double quotes (" "). Missing or unbalanced quotes can
result in syntax errors or unexpected behavior.
Missing or Extra Semicolons:
Semicolons (;) are used to terminate statements in Java. Missing a semicolon or adding
an extra semicolon in the wrong place can lead to syntax errors. Invalid Escape
Sequences:

Escape sequences, such as \n for a new line or \t for a tab, have specific meanings in Java.
Using invalid or unrecognized escape sequences can cause compilation errors. Incorrect
Operators or Symbols:

Using operators or symbols incorrectly, such as assigning = instead of comparing ==, can lead to
logical errors or unexpected behavior.
Reserved Keywords and Identifiers:

Using reserved keywords as identifiers (variable names, class names, etc.) will cause compilation
errors.
Identifiers should not match with Java's reserved keywords.
Improper Indentation or Whitespace:
While indentation and whitespace don't affect the program's functionality, inconsistent or
incorrect indentation can make the code harder to read and understand.

Prof Megha S Kulkarni Page 3

 Basics of JAVA programming

These are some common lexical issues encountered in Java programming. To resolve these
issues, it is important to carefully follow Java's syntax and naming conventions, pay attention
to details, and use proper coding practices. Compiler error messages can provide valuable
information in identifying and resolving these lexical issues.

Explain different promotion rules in JAVA.

In Java, promotion rules define how operands of different data types are automatically
converted or promoted to a common type before performing certain operations. These rules
ensure that operations involving operands of different types are carried out in a consistent and
predictable manner. Here are the different promotion rules in Java:
1. Widening Primitive Conversion:

- In Java, smaller data types are automatically widened or promoted to larger data types.
This conversion is also known as implicit or automatic type conversion. The widening
conversions are performed when:
- A byte can be promoted to a short, int, long, float, or double.
- A short can be promoted to an int, long, float, or double.
- A char can be promoted to an int, long, float, or double.
- An int can be promoted to a long, float, or double.
- A long can be promoted to a float or double.
- A float can be promoted to a double.

2. Binary Numeric Promotion:

- When performing binary operations (such as arithmetic or bitwise operations) on two
operands of different types, Java automatically promotes the operands to a common type
before executing the operation. The binary numeric promotion rules are as follows:
- If either operand is of type double, the other operand is promoted to double.
- Otherwise, if either operand is of type float, the other operand is promoted to float.
- Otherwise, if either operand is of type long, the other operand is promoted to long.
- Otherwise, both operands are promoted to int.

3. Assignment Conversion:
- When assigning a value of one type to a variable of another type, Java automatically
performs an assignment conversion. Assignment conversions follow similar rules as widening
primitive conversion, where smaller data types are implicitly widened to larger data types.

4. Object Type Conversion (Casting):

- Object type conversion involves explicitly converting an object from one type to another
using casting. Casting allows you to convert an object to a more specific type or a less
specific type. Casting can be done between compatible types within the same class hierarchy
or between classes in an inheritance relationship.

It's important to note that some conversions may result in loss of precision or potential data
truncation.
In such cases, explicit type casting may be necessary to handle the conversion properly.

Prof Megha S Kulkarni Page 4

 Basics of JAVA programming

These promotion rules in Java help maintain compatibility and consistency when working with
different data types, ensuring that operations and assignments are performed correctly and
according to the language's specification.

Give different syntax of array allocation in JAVA.

In Java, there are different syntaxes for allocating arrays depending on the context and the
desired approach. Here are the various syntaxes for array allocation in Java:

1. Basic Syntax:
- To allocate an array with a specified size, you can use the following
syntax: java
dataType[] arrayName = new dataType[arraySize];

Example:

int[] numbers = new int[5]; // Allocates an integer array of size 5

2. Inline Initialization:
- You can allocate and initialize an array in a single line using curly braces to specify the

initial values: dataType[] arrayName = {value1, value2, value3, ...};

Example:

String[] fruits = {"Apple", "Banana", "Orange"}; // Allocates and initializes a String array
with three elements

3. Multidimensional Arrays:
- For allocating multidimensional arrays, you can use the following

- syntax: dataType[][] arrayName = new dataType[rowSize][columnSize];

- Example:

int[][] matrix = new int[3][3]; // Allocates a 3x3 integer matrix

4. Anonymous Arrays:
- Anonymous arrays are arrays that are created without explicitly assigning them to a
variable. They are mainly used for passing array arguments to methods.

- The syntax is:

dataType[] arrayName = new dataType[]{value1, value2, value3, ...};

Prof Megha S Kulkarni Page 5

 Basics of JAVA programming

Example:

printArray(new int[]{1, 2, 3, 4, 5}); // Passing an anonymous integer array to the printArray

method

These are the different syntaxes for allocating arrays in Java. The choice of syntax
depends on the specific requirements and context of your code.

Explain different type of integer literals with examples.

In Java, integer literals are used to represent integer values in different formats. There are
several types of integer literals available in Java. Here are the different types of integer literals
with examples:

1. Decimal Literal:
- A decimal literal represents an integer value in base 10 (decimal). It consists of a sequence
of digits without any prefix. Example: `int num = 123;`

2. Binary Literal:
- A binary literal represents an integer value in base 2 (binary). It starts with the prefix `0b`
or `0B`, followed by a sequence of binary digits (0 or 1). Example: int binaryNum =
0b10101; (decimal value: 21)

3. Octal Literal:
- An octal literal represents an integer value in base 8 (octal). It starts with the prefix `0`,
followed by a sequence of octal digits (0 to 7). Example: `int octalNum = 037;` (decimal value:
31)

4. Hexadecimal Literal:
- A hexadecimal literal represents an integer value in base 16 (hexadecimal). It starts with the
prefix `0x` or `0X`, followed by a sequence of hexadecimal digits (0 to 9 and A to F, case-
insensitive). Example: int hexNum = 0xFF; (decimal value: 255)

5. Underscore in Numeric Literals (Java 7 and later):

- Underscores can be used as a visual separator in numeric literals to enhance readability. They
can be placed anywhere between digits, except at the beginning or end of a literal or right after a
prefix. Example: int million = 1_000_000;

Note: The type of the variable used to store the integer literal should be compatible with the
range of values represented by the literal. For example, if a literal exceeds the range of `int`, it
should be assigned to a `long` variable by appending `L` or `l` to the literal value (e.g., `long
largeNum = 1234567890L;`).

It's important to use the appropriate type and syntax for integer literals based on the
specific requirements of your code.

Prof Megha S Kulkarni Page 6

 Basics of JAVA programming

MODULE-2

Explain the following operations with example. (i) << (ii) >> (iii) >>> (iv) &

(i) << - Left Shift Operator:

- The left shift operator (`<<`) shifts the bits of a number to the left by a specified number of
positions. It effectively multiplies the number by 2 raised to the power of the specified shift
count. The leftmost bits are shifted out, and zero bits are filled in on the right. The general
syntax is `num << shiftCount`.

Example:

int num = 5; // Binary: 00000101

int shiftedNum = num << 2; // Shifted left by 2 positions
System.out.println(shiftedNum); // Output: 20 (Binary:
00010100)

(ii) >> - Right Shift Operator (Arithmetic Shift):

- The right shift operator (`>>`) shifts the bits of a number to the right by a specified number of
positions. It effectively divides the number by 2 raised to the power of the specified shift count.
The sign bit (leftmost bit) is preserved, meaning the empty bits on the left are filled with the sign
bit for signed numbers (positive or negative). For positive numbers, zero bits are filled in on the
left. The general syntax is `num >> shiftCount`.

Example:

int num = 20; // Binary: 00010100

int shiftedNum = num >> 2; // Shifted right by 2 positions
System.out.println(shiftedNum); // Output: 5 (Binary:
00000101)

(iii) >>> - Right Shift Operator (Logical Shift):

- The unsigned right shift operator (`>>>`) also shifts the bits of a number to the right by a
specified number of positions. It behaves similar to the right shift operator (`>>`), but the
empty bits on the left are always filled with zero bits, regardless of the sign. This operator is
used for logical shifting. The general syntax is `num >>> shiftCount`.

Example:

int num = -20; // Binary: 11111111111111111111111111101100 (signed

representation) int shiftedNum = num >>> 2; // Shifted right by 2 positions
System.out.println(shiftedNum); // Output: 1073741828 (Binary:
001111111111111111111111111011)

Prof Megha S Kulkarni Page 7

 Basics of JAVA programming

(iv) & - Bitwise AND Operator:

- The bitwise AND operator (`&`) performs a bitwise AND operation between the
corresponding bits of two numbers. It evaluates to 1 only if both corresponding bits are 1;
otherwise, it evaluates to 0. The general syntax is `num1 & num2`.

Example:

int num1 = 12; // Binary: 00001100

int num2 = 10; // Binary: 00001010
int result = num1 & num2; // Bitwise AND operation
System.out.println(result); // Output: 8 (Binary:
00001000)

These operations provide bitwise manipulation and logical operations on individual bits of
numbers, allowing you to perform various bitwise calculations and manipulations in your
Java programs.

Demonstrate the working of enhanced for loop.

Here's an example that demonstrates the working of the enhanced for loop, also known as
the "for-each" loop, in Java:

public class EnhancedForLoopDemo {

public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};

// Enhanced for loop (for-each loop)

for (int number : numbers) {
System.out.println(number);
}
}
}

In this example, we have an array `numbers` containing integer values. We use the enhanced for
loop to iterate over each element of the array and print its value.

Explanation:
- The enhanced for loop syntax is `for (dataType variable : array)`, where `dataType` is the
type of elements in the array, `variable` is the iteration variable that represents each element in
the loop, and `array` is the array or collection to be iterated.
- In our example, `int number` is the iteration variable that represents each element of the
`numbers` array in each iteration of the loop.
- The loop executes once for each element in the array. In each iteration, the current
element is assigned to the iteration variable (`number` in this case), and the loop body is
executed.

Prof Megha S Kulkarni Page 8

 Basics of JAVA programming

- Within the loop body, we print the value of the current element using
`System.out.println(number)`.
- The loop continues until all elements of the array have been processed.

Output:

1
2
3
4
5

The enhanced for loop simplifies the process of iterating over arrays or collections in Java,
eliminating the need for maintaining an index variable and explicitly accessing array
elements. It enhances code readability and reduces the chances of errors in loop indexing.

Write a program to sort the elements using for loop.

Here's an example program that sorts an array of integers using a for loop in ascending order:

public class SortArrayUsingForLoop {

public static void main(String[] args) {
int[] numbers = {5, 2, 8, 1, 9};

// Sorting the array using for loop

for (int i = 0; i < numbers.length - 1; i++) {
for (int j = 0; j < numbers.length - i - 1; j++) {
if (numbers[j] > numbers[j + 1]) {
// Swap the elements if they are in the wrong
order int temp = numbers[j];
numbers[j] = numbers[j +
1]; numbers[j + 1] = temp;
}
}
}
// Printing the sorted array
System.out.println("Sorted
Array:"); for (int number :
numbers) {
System.out.print(number + " ");
}
}
}

Prof Megha S Kulkarni Page 9

 Basics of JAVA programming

In this program, we have an array `numbers` containing integer values. We use a nested for
loop to compare adjacent elements and swap them if they are in the wrong order. The outer
loop controls the number of passes, and the inner loop performs the comparisons and swaps.

Explanation:
- The outer for loop (`i`) iterates from 0 to `numbers.length - 1`. It controls the number of
passes required to sort the array. Since the largest element moves to the end in each pass,
the number of comparisons decreases with each pass.

- The inner for loop (`j`) iterates from 0 to `numbers.length - i - 1`. It performs the
comparisons and swaps between adjacent elements.

- Inside the inner loop, we compare `numbers[j]` and `numbers[j + 1]`. If `numbers[j]` is
greater than `numbers[j + 1]`, we swap the elements using a temporary variable `temp`.

- After the sorting process is completed, we print the sorted array using an enhanced

for loop. Output:

Sorted Array:
12589

The program sorts the elements of the array using a for loop, implementing the bubble sort
algorithm.
Each pass moves the largest element to its correct position, resulting in a sorted array.

Explain four different types of if statements in JAVA.

In Java, there are several types of if statements that can be used to conditionally control the
flow of execution in a program. Here are four different types of if statements:

1. Standard if Statement:
- The standard if statement is the most basic and commonly used type. It
evaluates a boolean expression and executes a block of code only if the expression
evaluates to true.

Syntax:

if (condition) {
// Code to be executed if the condition is true
}

Example:

int num = 10;

if (num > 5) {

Prof Megha S Kulkarni Page 10

 Basics of JAVA programming

System.out.println("The number is greater than 5");

}

2. if-else Statement:
- The if-else statement provides an alternative path of execution. It evaluates a boolean
expression,
and if it is true, the code block associated with the if statement is executed. Otherwise, if the
expression is false, the code block associated with the else statement is executed.

Syntax:

if (condition) {
// Code to be executed if the condition is
true } else {
// Code to be executed if the condition is false
}

Example:

int num = 3;
if (num > 5) {
System.out.println("The number is greater than 5");
}
else {
System.out.println("The number is less than or equal to 5");
}

3. Nested if Statement:
- A nested if statement is an if statement within another if statement. It allows multiple
levels of conditions to be checked and different actions to be taken based on the
combinations of those conditions.

Syntax:

if (condition1) {
// Code to be executed if condition1 is
true if (condition2) {
// Code to be executed if both condition1 and condition2 are true
}
}

Example:

int num = 7;
if (num > 5) {
System.out.println("The number is greater than 5");
if (num % 2 == 0) {
Prof Megha S Kulkarni Page 11
 Basics of JAVA programming

System.out.println("The number is even");

}
}

4. if-else if-else Statement:

- The if-else if-else statement allows you to test multiple conditions and execute different
blocks of code based on those conditions. It provides a way to handle multiple alternative
cases.

Syntax:

if (condition1) {
// Code to be executed if condition1 is
true } else if (condition2) {
// Code to be executed if condition1 is false and condition2
is true } else {
// Code to be executed if both condition1 and condition2 are false
}

Example:

int num = 0;
if (num > 0) {
System.out.println("The number is positive");
} else if (num < 0) {
System.out.println("The number is negative");
} else {
System.out.println("The number is zero");
}

These four types of if statements in Java provide different ways to conditionally execute blocks
of code based on specified conditions. By using these statements effectively, you can control
the flow of your program and make decisions based on different scenarios.

Demonstrate working of break with labels in JAVA.

In Java, the `break` statement with labels allows you to terminate an outer loop or switch
statement from within an inner loop or nested switch statement. It provides a way to break out
of multiple levels of nested loops or switch statements. Here's an example to demonstrate the
working of `break` with labels:

public class BreakWithLabelsDemo {

public static void main(String[] args) {
outerLoop:
for (int i = 1; i <= 3; i++) {

Prof Megha S Kulkarni Page 12

 Basics of JAVA programming

System.out.println("Outer loop iteration: " + i);

innerLoop:
for (int j = 1; j <= 3; j++) {
System.out.println("Inner loop iteration: " + j);

if (i == 2 && j == 2) {
break outerLoop; // Breaking out of the outer loop when i = 2 and j = 2
}
}
}
}
}

In this example, we have an outer loop labeled as `outerLoop` and an inner loop labeled as
`innerLoop`. The `break` statement with the label `outerLoop` is used to terminate the outer loop
when the condition `i == 2` and `j == 2` is met.

Explanation:
- The outer loop (`i`) iterates from 1 to 3, and the inner loop (`j`) iterates from 1 to 3 for each
iteration of the outer loop.

- Within the inner loop, we check the condition `i == 2` and `j == 2`. If the condition is true,
the `break` statement with the label `outerLoop` is executed.
- When the `break` statement with the label `outerLoop` is encountered, it immediately
terminates the outer loop and the program flow continues after the outer loop.

- As a result, the output of the program will be as follows:

Outer loop iteration: 1

Inner loop iteration: 1
Inner loop iteration: 2
Outer loop iteration: 2

The program terminates after printing "Outer loop iteration: 2" because the `break` statement
with the label `outerLoop` is executed when `i` is 2 and `j` is 2.

The use of `break` with labels provides control over the flow of nested loops or switch
statements, allowing you to break out of a specific loop or switch construct from within an
inner block.

Write a program to find the biggest of three numbers using ternary operator.

Here's an example program that uses the ternary operator to find the largest of three numbers:

Prof Megha S Kulkarni Page 13

 Basics of JAVA programming

public class LargestNumberTernaryOperator {

public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
int num3 = 15;

int largest = (num1 > num2) ? ((num1 > num3) ? num1 : num3) : ((num2 > num3) ? num2 :
num3);

System.out.println("The largest number is: " + largest);

}
}

In this program, we have three variables `num1`, `num2`, and `num3`, representing the three
numbers. We use the ternary operator `(condition) ? expression1 : expression2` to compare the
numbers and assign the largest value to the variable `largest`.

Explanation:
- The ternary operator works by evaluating a condition. If the condition is true, it returns
`expression1`, otherwise, it returns `expression2`.
- In our program, we use nested ternary operators to compare the numbers. The outer ternary
operator compares `num1` and `num2`. If `num1` is greater than `num2`, it evaluates the first
expression `((num1 > num3) ? num1 : num3)`; otherwise, it evaluates the second expression
`((num2 > num3) ? num2 : num3)`.

- The nested ternary operator inside the first expression compares `num1` and `num3`. If
`num1` is greater than `num3`, it returns `num1`; otherwise, it returns `num3`.

- The nested ternary operator inside the second expression compares `num2` and `num3`. If
`num2` is greater than `num3`, it returns `num2`; otherwise, it returns `num3`.

- The resulting largest value is assigned to the variable `largest`.

- Finally, we print the value of `largest`, which represents the largest number among the three.

Output:

The largest number is: 20

The program uses the ternary operator to find the largest number among three given
numbers in a concise and efficient manner.

Prof Megha S Kulkarni Page 14

 Basics of JAVA programming
MODULE-3

What are constructors? Explain two types of constructors.

Constructors are special methods in object-oriented programming languages that are used to
initialize and create objects of a class. They are called when an object of a class is instantiated
or created. Constructors play a crucial role in setting up the initial state of an object and
performing any necessary setup operations.

There are two main types of constructors:

1. Default Constructor:
- A default constructor is automatically provided by the programming language if no
explicit constructor is defined by the programmer.
- It initializes the object with default values. For example, numeric variables might be
initialized to 0, string variables might be initialized to an empty string, and so on.
- The default constructor is used when an object is created without any arguments.
- Example in
Python: python
class MyClass:
def __init__(self): print("Default
constructor called")

obj = MyClass() # Creates an object and calls the default constructor

2. Parameterized Constructor:
- A parameterized constructor allows you to pass arguments while creating an object. It enables
you to set initial values based on the values provided during object creation.
- Parameterized constructors typically have parameters that match the attributes of the class.
These parameters are used to initialize the attributes of the object.

- Example in Java:

class Student {
String name;
int age;

// Parameterized constructor
Student(String n, int a) {
name = n;
age = a;
}
}

Student student1 = new Student("Alice", 20); // Using parameterized constructor

Prof Megha S Kulkarni Page 15

 Basics of JAVA programming

Constructors allow you to ensure that objects are properly initialized, avoiding situations where
objects are created with incorrect or undefined values. They help maintain the integrity of the
object's state and provide a clear way to initialize object attributes.

Explain static variable and static methods in JAVA.

In Java, `static` is a keyword that is used to define a member (variable or method) of a class as
belonging to the class itself rather than to individual instances (objects) of the class. Static
members are associated with the class definition and not with the individual objects created from
that class. Here's an explanation of static variables and static methods in Java:

Static Variables:
A static variable, also known as a class variable, is a variable that belongs to the class itself
rather than to any specific instance of the class. There is only one copy of the static variable that
is shared among all instances of the class. Static variables are typically used for values that
should be common to all instances of the class.

Example of a static variable:

class MyClass {
static int count = 0; // Static variable

MyClass() {
count++; // Increment count whenever a new object is created
}
}

public class Main {

public static void main(String[] args) {
MyClass obj1 = new MyClass();
MyClass obj2 = new MyClass();
System.out.println("Total objects created: " + MyClass.count); // Accessing static variable
}
}
Static Methods:
A static method is a method that belongs to the class itself rather than to any specific instance of
the class. Static methods can be called using the class name without creating an object of the
class. Static methods are often used for utility functions or operations that do not require access
to instance-specific data.

Example of a static method:

class MathUtils {
static int add(int a, int b) {
return a + b;
}
}

Prof Megha S Kulkarni Page 16

 Basics of JAVA programming

public class Main {

public static void main(String[] args) {
int result = MathUtils.add(5, 3); // Calling static method using class
name System.out.println("Result: " + result);
}
}

Static methods cannot directly access non-static (instance) variables or methods, as they
are not associated with any specific object. However, they can access other static members
(variables and methods) directly.

In summary, static variables and static methods in Java belong to the class itself rather than to
individual objects. They are used for storing shared data and performing operations that are not
dependent on instance-specific data.

Write a program to perform Stack operation using proper class and methods.

Here's an example of a Java program that performs stack operations using a custom class and
methods:

class Stack {
private int maxSize;
private int top;
private int[] arr;

public Stack(int size) {

maxSize = size;
top = -1;
arr = new int[maxSize];
}

public boolean isEmpty() {

return top == -1;
}

public boolean isFull() {

return top == maxSize - 1;
}

public void push(int value) {

if (isFull()) {
System.out.println("Stack is full. Cannot push " + value);
return;
}
arr[++top] = value;

Prof Megha S Kulkarni Page 17

 Basics of JAVA programming

System.out.println(value + " pushed onto the stack");

}

public int pop() {

if (isEmpty()) {
System.out.println("Stack is empty. Cannot pop.");
return -1;
}
int value = arr[top--];
System.out.println(value + " popped from thestack");
return value;
}

public int peek() {

if (isEmpty()) {
System.out.println("Stack is empty. Cannot peek.");
return -1;
}
return arr[top];
}
}

public class Main {

public static void main(String[] args) {

Stack stack = new Stack(5);

stack.push(10);
stack.push(20);
stack.push(30);

System.out.println("Top element: " + stack.peek());

stack.pop();
stack.pop();

System.out.println("Top element after pops: " + stack.peek());

}
}

This program defines a `Stack` class with methods for `push`, `pop`, `peek`, `isEmpty`,
and `isFull` operations. The `Main` class demonstrates the usage of these stack
operations.

Prof Megha S Kulkarni Page 18

 Basics of JAVA programming

Explain memory allocation and use of garbage collector in JAVA.

Memory Allocation in Java:

Memory allocation in Java refers to the process of reserving memory space for objects and data
structures during program execution. Java manages memory allocation dynamically through its
built-in memory management system. The primary goal is to efficiently allocate and manage
memory to ensure that objects are created, used, and deallocated properly to avoid memory
leaks and optimize memory usage.

In Java, memory allocation occurs in two main areas:

1. Heap Memory: This is the area where objects are stored. When you create an object using
the `new` keyword, memory is allocated on the heap for that object. The heap is shared among
all threads in a Java application.

2. Stack Memory: This is where local variables and method call information are stored. Each
thread in Java has its own stack memory, and it's used for storing primitive data types,
references to objects, and method call frames.

Garbage Collector in Java:

The Java Virtual Machine (JVM) includes a Garbage Collector (GC) as part of its memory
management system. The purpose of the garbage collector is to automatically reclaim memory
that is no longer being
used by objects, freeing up space for new objects. This helps prevent memory leaks and
ensures efficient memory usage.

The key features of Java's garbage collector include:

- Automatic Memory Management: Java's garbage collector automatically identifies and

reclaims memory that is no longer reachable by the program. Objects that are no longer
referenced by any variable or data structure become eligible for garbage collection.

- Mark-and-Sweep Algorithm: One of the common garbage collection algorithms used is the
mark-and-sweep algorithm. It involves marking objects that are reachable from the root of the
object graph and then sweeping the memory to identify and deallocate the remaining
unreachable objects.

- Generational Garbage Collection: The heap memory is divided into generations, with the young
generation holding recently created objects and the old generation holding long-lived objects.
This allows the garbage collector to focus on the most frequently collected objects, minimizing
the impact on the application's performance.

- Parallel and Concurrent Collectors: Java provides different types of garbage collectors,
including parallel collectors for multi-threaded environments and concurrent collectors that can
run concurrently with the application threads to minimize pause times.

Prof Megha S Kulkarni Page 19

 Basics of JAVA programming

- Tuning and Customization: Java allows developers to customize the behavior of the garbage
collector using command-line options and configuration files. This is useful for optimizing
memory usage based on the application's requirements.

In summary, memory allocation in Java involves reserving memory space for objects and data
structures. The garbage collector plays a crucial role in automatically reclaiming memory from
objects that are no longer in use, ensuring efficient memory usage and preventing memory leaks
in Java applications.

Explain use of this in JAVA.

In Java, `this` is a keyword that refers to the current instance of the class in which it is used.
It is primarily used to differentiate between instance variables (fields) of the class and local
variables or method parameters with the same name. Here's how `this` is used and its
significance in Java:

1. Avoiding Name Conflicts:

When a method parameter or a local variable has the same name as an instance variable, the
`this` keyword helps distinguish between them. It allows you to access the instance variable
instead of the local variable or parameter.
public class MyClass {
private int num;

public void setNum(int num) {

// Using 'this' to refer to the instance
variable this.num = num;
}
}

2. Constructor Chaining:
In a class with multiple constructors, you can use `this()` to call another constructor within
the same class. This is known as constructor chaining and helps avoid code duplication.

public class MyClass

{
private int value;

public MyClass() {
this(0); // Calls the parameterized constructor with a default value
}

public MyClass(int value) {

this.value = value;
}
}

Prof Megha S Kulkarni Page 20

 Basics of JAVA programming

3. Returning the Current Instance:

Methods can return the current instance of the class using the `this` keyword. This is often
used for method chaining or fluent-style programming.

public class MyClass {

public MyClass doSomething() {
// Do something
return this; // Returns the current instance
}
}

4. Passing the Current Object:

When calling a method of another object and passing the current object as an argument, you
can use `this` to refer to the current object.

public class MyClass {

public void interactWithOtherObject(OtherClass other) {
other.process(this); // Passes the current object to the other
object
}
}

In summary, the `this` keyword in Java is used to refer to the current instance of a class. It is
useful for avoiding naming conflicts, constructor chaining, returning the current instance, and
passing the current object to methods of other objects.

Write a JAVA program demonstrating Method overloading.

Method overloading in Java allows you to define multiple methods with the same name in a
class, but with different parameter lists. The methods are differentiated based on the number
or types of parameters they accept. Here's an example of method overloading:

public class MathOperations {

public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
public int add(int a, int b, int c) {
return a + b + c;
}
public String add(String s1, String s2) {
return s1 + s2;
}

Prof Megha S Kulkarni Page 21

 Basics of JAVA programming

public static void main(String[] args) {

MathOperations math = new MathOperations();

System.out.println("Sum of integers: " + math.add(5, 3));

System.out.println("Sum of doubles: " + math.add(5.5, 3.2));
System.out.println("Sum of three integers: " + math.add(5, 3, 8));
System.out.println("Concatenated strings: " + math.add("Hello, ", "world!"));
}
}

In this example, the `MathOperations` class demonstrates method overloading with the `add`
method. The method is defined with different parameter lists to handle different types and
numbers of arguments. The `main` method demonstrates the usage of the overloaded methods
by creating an instance of the class and calling the methods with different arguments.

Output:

Sum of integers: 8
Sum of doubles: 8.7
Sum of three integers: 16
Concatenated strings: Hello, world!

In this program, the `add` method is overloaded with different parameter types (`int`, `double`,
`String`) and numbers of parameters. The appropriate method is automatically selected based on
the arguments provided during the method call.

Prof Megha S Kulkarni Page 22

 Basics of JAVA programming

MODULE-4

Explain different types of inheritance in JAVA.

In Java, inheritance is a mechanism that allows a class to inherit the properties and behaviors
(methods and fields) of another class. There are several types of inheritance that you can use to
create a hierarchy of classes with varying levels of specialization. Here are the different types of
inheritance in Java:

1. Single Inheritance:
Single inheritance refers to the scenario where a class inherits properties and behaviors from
a single parent class. Java supports single inheritance, meaning a class can extend only one
parent class.

class Parent {
// Parent class properties and methods
}

class Child extends Parent {

// Child class inherits from Parent class
}

2. Multilevel Inheritance:
Multilevel inheritance occurs when a class inherits from a parent class, and another class
inherits from the derived class. This creates a chain of inheritance.

class Grandparent {
// Grandparent class properties and methods
}

class Parent extends Grandparent {

// Parent class inherits from Grandparent class
}

class Child extends Parent {

// Child class inherits from Parent class
}

3. Hierarchical Inheritance:
Hierarchical inheritance happens when multiple classes inherit from a single parent class.
This creates a hierarchy where multiple classes share the same parent class.

class Parent {
// Parent class properties and methods
}

Prof Megha S Kulkarni Page 23

 Basics of JAVA programming

class Child1 extends Parent {

// Child1 class inherits from Parent class
}

class Child2 extends Parent {

// Child2 class inherits from Parent class
}

4. Multiple Inheritance (through Interfaces):

Although Java does not support multiple inheritance (inheriting from multiple classes), it
supports multiple inheritance through interfaces. An interface defines a contract for methods
that implementing classes must provide.

interface Interface1 {
void method1();
}

interface Interface2 {
void method2();
}

class MyClass implements Interface1, Interface2

{
// Implements methods from both interfaces
}

5. Hybrid Inheritance:
Hybrid inheritance is a combination of two or more types of inheritance. For example, it could
involve a combination of single, multilevel, and hierarchical inheritance in the same program.

It's important to note that Java does not support multiple inheritance of classes, but it provides a
flexible way to achieve similar effects through interfaces. When designing your class hierarchy,
consider the relationships between classes and the type of inheritance that best models those
relationships.

Example two uses of super keyword with example.

The `super` keyword in Java is used to refer to the superclass, parent class, or immediate
ancestor of a subclass. It is often used in scenarios where there is a need to differentiate
between superclass and
subclass members with the same name, or to call superclass constructors and methods. Here
are two common uses of the `super` keyword with examples:

1. Accessing Superclass Members:

Prof Megha S Kulkarni Page 24

 Basics of JAVA programming
When a subclass has a member (field or method) with the same name as a member in the
superclass, the `super` keyword is used to explicitly refer to the superclass member.

class Parent {
int value = 10;

void display() {
System.out.println("Value in parent: " + value);
}
}
class Child extends Parent {
int value = 20;
void display() {
System.out.println("Value in child: " + value);
System.out.println("Value in parent using super: " + super.value);
}
}
public class Main {
public static void main(String[] args) {
Child child = new Child();
child.display();
}
}
Output:

Value in child: 20
Value in parent using super: 10

2. Calling Superclass Constructor:

When creating an instance of a subclass, you can use the `super` keyword to call a
constructor from the superclass. This is especially useful when the superclass constructor
initializes some common properties.

class Parent {
int value;

Parent(int value) {
this.value = value;
}
}

class Child extends Parent {

int bonus;

Child(int value, int bonus) {

super(value); // Call superclass constructor

Prof Megha S Kulkarni Page 25

 Basics of JAVA programming

this.bonus = bonus;
}

void display() {
System.out.println("Value: " + value);
System.out.println("Bonus: " + bonus);
}
}

public class Main {

public static void main(String[] args) {
Child child = new Child(100, 20);
child.display();
}
}

Output:

Value: 100
Bonus: 20

In the first example, the `super` keyword is used to access a member from the superclass. In the
second example, the `super` keyword is used to call the superclass constructor and initialize
superclass properties during subclass object creation.

Demonstrate the working of final class and final method in JAVA.

In Java, the `final` keyword is used to indicate that a class, method, or variable cannot be
further modified or overridden. Here's how to demonstrate the working of a final class and
a final method:

1. Final Class:
When a class is declared as `final`, it cannot be subclassed or extended by other classes.

final class Parent {

// Class implementation
}
// Error: Cannot extend final
class class Child extends
Parent {
// Class implementation
}

2. Final Method:

Prof Megha S Kulkarni Page 26

 Basics of JAVA programming
When a method is declared as `final` within a class, it cannot be overridden by subclasses.
This is often used to prevent subclasses from altering the behavior of a specific method.

class Parent {
final void display() {
System.out.println("Display method in parent");
}
}

class Child extends Parent {

// Error: Cannot override final
method void display() {
System.out.println("Display method in child");
}
}

In the example above, attempting to override the `display` method in the `Child` class will
result in a compilation error.

3. Final Variable (Constant):

A `final` variable, also known as a constant, is a variable that cannot be reassigned after
its initial assignment.

class Constants {
final double PI = 3.14159;
}
public class Main {
public static void main(String[] args) {
Constants constants = new Constants();
// Error: Cannot assign a new value to final variable PI constants.PI = 3.14;
}
}

In this example, attempting to assign a new value to the `PI` constant will result in a compilation
error.

The use of `final` classes, methods, and variables helps in creating code that is more robust and
prevents unintended modifications that might lead to errors or security vulnerabilities.

What is abstract class? Explain with example.

An abstract class in Java is a class that cannot be instantiated directly and is meant to be
subclassed. It serves as a blueprint for other classes and may contain abstract methods (methods
without a body) that must be implemented by its subclasses. Abstract classes are used to define
common attributes and methods that are shared among multiple related classes.

Prof Megha S Kulkarni Page 27

 Basics of JAVA programming

Here's an example of an abstract class in Java:

// Abstract class
abstract class Shape
{
protected String name;
// Abstract method (no
implementation) abstract double
area();

// Concrete method
void setName(String name) {
this.name = name;
}

// Concrete
method String
getName() {
return name;
}
}
// Subclass of abstract
class class Circle extends
Shape {
private double radius;

Circle(double radius) {
this.radius = radius;
setName("Circle");
}

@Override
double area() {
return Math.PI * radius * radius;
}
}
// Subclass of abstract class
class Rectangle extends
Shape {
private double length;
private double width;

Rectangle(double length, double width) {

this.length = length;
this.width = width;
setName("Rectangle");
}

Prof Megha S Kulkarni Page 28

 Basics of JAVA programming

@Override
double area() {
return length * width;
}
}

public class Main {

public static void main(String[] args) {
Circle circle = new Circle(5);
System.out.println("Area of " + circle.getName() + ": " + circle.area());

Rectangle rectangle = new Rectangle(4, 6);

System.out.println("Area of " + rectangle.getName() + ": " + rectangle.area());
}
}
In this example, the `Shape` class is an abstract class with an abstract method `area()`. The
`Circle` and `Rectangle` classes are subclasses of `Shape` and provide concrete implementations
of the `area()` method. The abstract class defines common methods like `setName()` and
`getName()` that can be used by all subclasses.

Note that an abstract class cannot be instantiated directly using the `new` keyword. Instead, you
create instances of its subclasses and use their implementations. Abstract classes are
particularly useful when you want to provide a common structure for related classes while
enforcing certain methods to be implemented by the subclasses.

Give example for method overriding.

Method overriding in Java allows a subclass to provide a specific implementation for a method
that is already defined in its superclass. The overriding method must have the same method
signature (name, parameters, return type) as the method in the superclass. Here's an example of
method overriding:

class Animal {
void makeSound() {
System.out.println("Animal makes a sound");
}
}

class Dog extends Animal {

@Override
void makeSound() {
System.out.println("Dog barks");
}
}

Prof Megha S Kulkarni Page 29

 Basics of JAVA programming

class Cat extends Animal {

@Override
void makeSound() {
System.out.println("Cat meows");
}
}

public class Main {

public static void main(String[] args) {
Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.makeSound(); // Output: Dog barks
animal2.makeSound(); // Output: Cat meows
}
}
In this example, the `Animal` class has a method `makeSound()`. Both the `Dog` and `Cat`
subclasses override this method to provide their specific implementations. When you create
instances of the subclasses and call the `makeSound()` method, the overridden methods in the
subclasses are invoked instead of the method in the superclass.

Method overriding allows you to provide a specialized behavior for each subclass while
adhering to the common method signature defined in the superclass. This is a key feature of
polymorphism in object-oriented programming.

Demonstrate dynamic dispatch using abstract class in JAVA.

Dynamic dispatch, also known as runtime polymorphism, occurs when a method call is
resolved at runtime based on the actual object type rather than the reference type. This
behavior is achieved through method overriding. Here's how dynamic dispatch works
using an abstract class and its subclasses:

abstract class Shape {

abstract void draw();
}

class Circle extends Shape {

@Override
void draw() {
System.out.println("Drawing a circle");
}
}

class Square extends Shape {

Prof Megha S Kulkarni Page 30

 Basics of JAVA programming

@Override
void draw() {
System.out.println("Drawing a square");
}
}

public class Main {

public static void main(String[] args) {
Shape shape1 = new Circle();
Shape shape2 = new Square();
shape1.draw(); // Output: Drawing a circle
shape2.draw(); // Output: Drawing a square
}
}

In this example, the `Shape` class is an abstract class with an abstract method `draw()`. The
`Circle` and `Square` classes are subclasses of `Shape` and provide their own implementations
of the `draw()` method.

When you create instances of the subclasses and call the `draw()` method using references of
the `Shape` type (`Shape shape1` and `Shape shape2`), dynamic dispatch comes into play. The
actual method that gets executed is determined at runtime based on the actual object type. This
allows you to call the appropriate `draw()` method even though the references are of the abstract
`Shape` type.

Dynamic dispatch is a powerful feature of object-oriented programming that enables

polymorphism, where different objects can respond to the same method call in a specialized
way based on their individual implementations.

Prof Megha S Kulkarni Page 31

 Basics of JAVA programming

MODULE-5

What is a package? Explain with example.

In Java, a package is a way to organize related classes, interfaces, and sub-packages. It helps in
avoiding naming conflicts, improving code readability, and making it easier to manage and
locate classes. A package is a directory that holds the Java files related to a specific
functionality or module.

Here's an example of using packages in Java:

Suppose you have a project that involves different aspects of a library, such as books,
members, and transactions. You can organize your code into packages like this:

com
└── library
├── books
│ ├── Book.java
│ └── Fiction.java
│
├── members
│ ├── Member.java
│ └── Staff.java
│
├── transactions
│ ├── Transaction.java
│ └── Loan.java
│
└── LibraryApp.java

In this example, the `com.library` package contains sub-packages `books`, `members`, and
`transactions`, each with their own classes. Here's a brief explanation of each:

- `books` package: Contains classes related to books, like `Book` and `Fiction`.

- `members` package: Contains classes related to library members, like `Member` and `Staff`.

- `transactions` package: Contains classes related to transactions, like `Transaction` and `Loan`.

- `LibraryApp.java`: This class can be outside the package or in a default package. It serves as
the entry point of your application and can access the classes from different packages.

To access classes from different packages, you need to use their fully qualified names. For
example, in `LibraryApp.java`, you might write:

Prof Megha S Kulkarni Page 32

 Basics of JAVA programming

import com.library.books.Book;
import com.library.members.Member;
import com.library.transactions.Transaction;

public class LibraryApp {

public static void main(String[] args) {
Book book = new Book();
Member member = new Member();
Transaction transaction = new Transaction();

// Perform operations using the objects

}
}

By using packages, you can structure your code logically, avoid class name clashes, and create a
modular and organized project.

Demonstrate the working of interface in JAVA.

An interface in Java defines a contract that specifies a set of methods that implementing
classes must provide. It serves as a blueprint for classes that want to provide specific
functionalities. Here's how to demonstrate the working of an interface:

// Interface definition
interface Shape {
double calculateArea();
double calculatePerimeter();
}

// Implementing class for Circle

class Circle implements Shape {
private double radius;

Circle(double radius)
{
this.radius = radius;
}

@Override
public double calculateArea() {
return Math.PI * radius * radius;
}

@Override
public double calculatePerimeter() {

Prof Megha S Kulkarni Page 33

 Basics of JAVA programming

return 2 * Math.PI * radius;

}
}

// Implementing class for

Rectangle class Rectangle
implements Shape {
private double length;
private double width;

Rectangle(double length, double width) {

this.length = length;
this.width = width;
}

@Override
public double calculateArea() {
return length * width;
}

@Override
public double calculatePerimeter() {
return 2 * (length + width);
}
}

public class Main {

public static void main(String[] args) {
Shape circle = new Circle(5);
System.out.println("Circle Area: " + circle.calculateArea());
System.out.println("Circle Perimeter: " + circle.calculatePerimeter());

Shape rectangle = new Rectangle(4, 6);

System.out.println("Rectangle Area: " + rectangle.calculateArea());
System.out.println("Rectangle Perimeter: " + rectangle.calculatePerimeter());
}
}

In this example, the `Shape` interface defines two methods: `calculateArea()` and
`calculatePerimeter()`. Both the `Circle` and `Rectangle` classes implement this interface and
provide their own implementations for the methods.

When you create instances of the implementing classes and call the interface methods, the
methods defined in the implementing classes are invoked. This demonstrates the concept of
polymorphism, where different objects can be treated as instances of a common interface and
can respond to method calls in their own specialized way.

Prof Megha S Kulkarni Page 34

 Basics of JAVA programming

Explain different access modifiers in JAVA.

In Java, access modifiers are keywords that specify the visibility and accessibility of classes,
methods, variables, and constructors. They control which parts of your code can be accessed
from other parts of the code. There are four main access modifiers in Java:

1. public: The `public` access modifier makes a class, method, variable, or constructor
accessible from any other class. There are no restrictions on access.

- Classes: Accessible from anywhere.

- Methods: Accessible from anywhere.
- Variables: Accessible from anywhere.
- Constructors: Accessible from anywhere.

2. protected: The `protected` access modifier allows access within the same package or by
subclasses of the class in other packages. It provides a level of access higher than `default`
(package-private) and lower than `public`.

- Classes: Not applicable (classes cannot have `protected` access).

- Methods: Accessible from the same package and subclasses (even if they are in a different
package).
- Variables: Accessible from the same package and subclasses.
- Constructors: Accessible from the same package and subclasses.

3. Default (Package-Private): If no access modifier is specified, it is considered `default` or

package-private. It allows access only within the same package.

- Classes: Accessible within the same package.

- Methods: Accessible within the same package.
- Variables: Accessible within the same package.
- Constructors: Accessible within the same package.

4. private: The `private` access modifier restricts access to within the same class. It is the most
restrictive access level and provides strong encapsulation.

- Classes: Not applicable (classes cannot have `private` access).

- Methods: Accessible only within the same class.
- Variables: Accessible only within the same class.
- Constructors: Accessible only within the same class.

These access modifiers help you control the visibility and accessibility of your code, promoting
encapsulation and modularity. By carefully selecting access modifiers, you can define the
appropriate level of exposure for your classes, methods, and variables, ensuring the proper
functioning and security of your code.

Prof Megha S Kulkarni Page 35

 Basics of JAVA programming

What is an exception? Give an example.

An exception in Java is an event that disrupts the normal flow of the program's execution due to
an error or unexpected condition. Exceptions are used to handle runtime errors and exceptional
situations that may occur during the execution of a program. They help in gracefully handling
errors and providing meaningful feedback to the user.

Here's an example of an exception in Java:

public class DivideByZeroExample {

public static void main(String[] args) {
int numerator = 10;
int denominator = 0;

try {
int result = numerator / denominator;
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
System.out.println("An error occurred: " + e.getMessage());
}
}
}

In this example, we're attempting to divide `numerator` by `denominator`, which is 0. This

division by zero will throw an `ArithmeticException` at runtime, as it's an invalid operation.
To handle this exception, we use a `try-catch` block.

- The `try` block contains the code that might throw an exception.
- The `catch` block catches the exception and provides an alternative course of action. It prints
an error message along with the exception's message using `e.getMessage()`.

When you run the program, you'll see the output:

An error occurred: / by zero

This example demonstrates how exceptions help in handling unexpected situations and prevent
the program from crashing. By catching exceptions, you can take appropriate actions, such as
displaying an error message or handling the situation in a different way, instead of letting the
program terminate abruptly.

Explain the procedure of creating our own exception.

Prof Megha S Kulkarni Page 36

 Basics of JAVA programming

Creating your own exception in Java involves defining a new class that extends the built-in
`Exception` class or one of its subclasses. This new class represents your custom exception,
and you can add constructors, methods, and fields to it as needed. Here's the procedure to
create your own exception:

1. Create a Custom Exception Class:

Define a new class that extends `Exception` or a more specific subclass of `Exception`. This
class will serve as your custom exception. You can add constructors and methods to provide
additional functionality if required.

2. Add Constructors:
Just like any other class, your custom exception class can have constructors. These
constructors can initialize the exception with specific messages or other relevant information.

3. Throw Your Custom Exception:

In your code, when you encounter a situation that requires throwing your custom exception,
you use the `throw` keyword followed by an instance of your custom exception class.

Here's an example of creating a custom exception called `InvalidAgeException`:

class InvalidAgeException extends Exception {

InvalidAgeException(String message) {
super(message);
}
}

public class CustomExceptionExample {

static void validateAge(int age) throws InvalidAgeException {
if (age < 18) {
throw new InvalidAgeException("Age must be 18 or above");
}
System.out.println("Age is valid");
}
public static void main(String[] args) {
try {
validateAge(15);
} catch (InvalidAgeException e) {
System.out.println("Exception: " + e.getMessage());
}
}
}

In this example:
- We create a custom exception class `InvalidAgeException` that extends `Exception`.
- The `validateAge` method checks if the given age is less than 18. If it is, it
throws an `InvalidAgeException` with a message.

Prof Megha S Kulkarni Page 37

 Basics of JAVA programming
- In the `main` method, we call `validateAge(15)` which throws the `InvalidAgeException`. We
catch this exception and print the message.

By creating and using your own custom exceptions, you can make your code more
meaningful and organized when handling specific exceptional situations.

Explain different mechanism of handling the exceptions in JAVA.

In Java, there are three main mechanisms for handling exceptions: `try-catch` blocks, `throws`
clause, and `finally` block. Each mechanism serves a different purpose and can be used in
different scenarios to manage and control exceptions effectively.

1. try-catch Blocks:
A `try-catch` block is used to enclose the code that might throw an exception. If an exception is
thrown within the `try` block, the corresponding `catch` block is executed to handle the
exception. This prevents the program from crashing and allows you to provide a graceful
response to the error.

try {
// Code that might throw an exception
} catch (ExceptionType e) {
// Code to handle the exception
}

2. throws` Clause:
The `throws` clause is used to indicate that a method might throw a particular type of
exception. It is part of the method signature and informs the caller that they need to handle the
exception or pass it on to the next higher level of the call stack.

returnType methodName(parameters) throws ExceptionType

{ // Method body
}

3. finally Block:
The `finally` block is used to define a block of code that will be executed regardless of whether
an exception occurs or not. It's often used for cleanup operations like closing resources (e.g.,
files, streams) to ensure that resources are properly released.

try {
// Code that might throw an exception
} catch (ExceptionType e) {
// Code to handle the exception
} finally {
// Code that will be executed regardless of exceptions
}

Prof Megha S Kulkarni Page 38

 Basics of JAVA programming

These mechanisms can be used together to provide comprehensive exception handling:

- You can use `try-catch` blocks to catch exceptions and handle them within a specific scope.
- You can use the `throws` clause to delegate the responsibility of handling exceptions to the
caller.
- You can use `finally` blocks to ensure that certain cleanup operations are always performed,
whether an exception occurs or not.

By effectively using these mechanisms, you can create robust and reliable Java programs that
gracefully handle various exceptions and ensure proper resource management.

Prof Megha S Kulkarni Page 39