MODULE 1

The static keyword in Java is used to indicate that a particular

member (variable, method, block, or nested class) belongs to the
class rather than any specific instance of the class. This means that
static members are shared among all instances of the class.
Key Points:
 Static Variables: They are common to all instances of the class.
When you modify a static variable, the change reflects across all
instances.
 Static Methods: They can be called directly using the class
name, without needing an instance of the class. Static methods
can only access other static members of the class.
 Static Blocks: Used for static initialization of a class. It runs once
when the class is loaded into memory.
 Static Classes: In nested classes, the static keyword indicates
that the nested class can be instantiated without an instance of
the outer class.
Example:
java
Copy code
class MyClass {
static int count = 0; // Static variable

static void incrementCount() { // Static method

count++;
}
}

public class Main {

public static void main(String[] args) {
MyClass.incrementCount(); // Calling static method without an
instance
System.out.println(MyClass.count); // Accessing static variable
}
}
2. final Keyword:
The final keyword in Java is used to define constants, prevent method
overriding, and prevent class inheritance. When applied to a variable,
method, or class, it restricts modification in different ways.
Key Points:
 Final Variables: Once assigned a value, a final variable cannot
be modified.
 Final Methods: A final method cannot be overridden by
subclasses.
 Final Classes: A final class cannot be subclassed (inherited
from).
Differences Between static and final:

Aspect static final

Used to define class-level Used to make variables,

Purpose members, shared across all methods, or classes
instances. immutable or unmodifiable.
Makes a variable constant
Effect on Makes a variable shared by
(cannot be reassigned once
Variables all instances of the class.
initialized).
Allows methods to be
Effect on Prevents method overriding
called without an instance
Methods by subclasses.
of the class.
Makes a class member Prevents subclassing (i.e.,
Effect on
belong to the class rather the class cannot be
Classes
than an instance. extended).
Primarily used with Primarily used with
variables and methods that constants, methods, or
Usage
should belong to the class classes that should not
itself. change.
In summary, static is used to share variables or methods across all instances of a class,
while final is used to prevent further modification or inheritance.
Early Binding (Static Binding):

Early Binding, also known as Static Binding, refers to the process of linking a method call
or variable reference to its definition at compile-time. In early binding, the method or
variable is resolved and assigned by the compiler, meaning that the method call or reference
to a variable is resolved before the program starts executing.

Key Points:

 Occurs at Compile Time: The method or variable is resolved at compile-time, and

the appropriate method is bound to the call.
 Typically Associated with Static Methods and Variables: Static methods and
variables are bound at compile-time since they are resolved before runtime.
 Faster: Early binding is faster because the compiler knows exactly which method or
variable to call during program execution.

Example (Early Binding):

class MyClass {

static void display() {

System.out.println("Static method called");

public class Main {

public static void main(String[] args) {

MyClass.display(); // Early binding: Static method resolved at compile-time

Late Binding (Dynamic Binding):

Late Binding, also known as Dynamic Binding, refers to the process of linking a method
call to its definition at runtime. This occurs when the method to be called is determined
during the execution of the program, typically used in the context of method overriding with
inheritance or polymorphism.

Key Points:
  Occurs at Runtime: The method or variable is resolved during the execution of the
program, and the actual method is determined based on the object's type.
 Typically Associated with Instance Methods: Methods that are overridden in
subclasses, where the actual method to be invoked is determined at runtime.
 Slower: Late binding is slower than early binding because it involves additional
overhead at runtime to determine which method or variable to call.

Example (Late Binding):

class Animal {

void sound() {

System.out.println("Animal makes a sound");

class Dog extends Animal {

void sound() {

System.out.println("Dog barks");

public class Main {

public static void main(String[] args) {

Animal myAnimal = new Dog(); // Reference of Animal, but object of Dog

myAnimal.sound(); // Late binding: The method resolved at runtime based on the object
type

In this example, myAnimal.sound() calls the sound method of the Dog class, even though the
reference is of type Animal. This decision happens at runtime, hence it is an example of late
binding.
Differences Between Early Binding and Late Binding:

Aspect Early Binding (Static Binding) Late Binding (Dynamic Binding)

Binding Time Occurs at compile-time. Occurs at runtime.
Method Method is resolved at compile-time Method is resolved at runtime based
Resolution based on the reference type. on the actual object type.
Slower due to runtime method
Performance Faster due to compile-time resolution.
lookup.
Type of Static methods, private methods, or Instance methods that are overridden
Methods final methods. in subclasses.
Method calls to static methods or
Method calls to overridden methods
Example method calls with a fixed reference
using polymorphism.
type.
Less flexible, as the method to be More flexible, as it allows method
Flexibility
called is fixed at compile-time. overriding and polymorphism.

In summary:

 Early Binding happens at compile-time and is used for static methods and variables,
where the method call is resolved by the compiler.
 Late Binding happens at runtime and is used for instance methods (especially
overridden ones), where the method call is resolved based on the actual object type at
execution time.

The main characteristics of an Object-Oriented Programming (OOP) language are as

follows:

1. Encapsulation:

 Definition: Encapsulation is the concept of bundling the data (variables) and the
methods (functions) that operate on the data into a single unit called a class. It also
restricts direct access to some of an object's components and can prevent the
accidental modification of data.
 Key Points:
o Data is hidden inside the class and can only be accessed or modified using
getter and setter methods.
o Helps achieve data hiding and abstraction.

Example:

class Person {

private String name; // Encapsulation (data hiding)

 public String getName() { // Getter method

return name;

public void setName(String name) { // Setter method

this.name = name;

2. Inheritance:

 Definition: Inheritance is a mechanism in which one class (child or subclass) inherits

the properties and behaviors (methods) of another class (parent or superclass). It
allows for hierarchical classification.
 Key Points:
o Promotes code reusability.
o A subclass can add its own specific features while retaining the features of the
parent class.
o Supports is-a relationships (e.g., a Dog is a type of Animal).

Example:

class Animal {

void speak() {

System.out.println("Animal speaks");

class Dog extends Animal {

void speak() {

System.out.println("Dog barks");

}
3. Polymorphism:

 Definition: Polymorphism means many forms. It allows objects of different classes

to be treated as objects of a common superclass. The two types of polymorphism in
OOP are compile-time (method overloading) and runtime (method overriding)
polymorphism.
 Key Points:
o Method Overloading (compile-time): Same method name with different
parameter lists.
o Method Overriding (runtime): A subclass provides a specific implementation
for a method already defined in its superclass.

Example:

class Animal {

void speak() {

System.out.println("Animal speaks");

class Dog extends Animal {

@Override

void speak() {

System.out.println("Dog barks");

class Main {

public static void main(String[] args) {

Animal myAnimal = new Dog();

myAnimal.speak(); // Method overriding: Dog barks

}
}

4. Abstraction:

 Definition: Abstraction is the process of hiding the complexity and only showing the
essential features of an object. It can be achieved through abstract classes and
interfaces in OOP.
 Key Points:
o Allows focusing on what an object does, rather than how it does it.
o Abstract classes can have abstract methods (methods without implementation),
which must be implemented by subclasses.

Example:

abstract class Animal {

abstract void sound(); // Abstract method

class Dog extends Animal {

void sound() {

System.out.println("Barks");

5. Classes and Objects:

 Definition: A class is a blueprint or template for creating objects. An object is an

instance of a class.
 Key Points:
o Classes define the properties (attributes) and behaviors (methods) of objects.
o Objects are real-world entities created based on class definitions.

Example:

class Car {

String model;

int year;
 void drive() {

System.out.println("Driving the car");

class Main {

public static void main(String[] args) {

Car myCar = new Car(); // Creating an object of Car class

myCar.model = "Toyota";

myCar.year = 2020;

myCar.drive();

6. Message Passing:

 Definition: Objects communicate with each other by sending messages, which

typically correspond to method calls.
 Key Points:
o In OOP, message passing is central to how objects interact with each other.
o It involves invoking methods on objects, passing data as parameters, and
receiving results.

Example:

class Printer {

void print(String message) {

System.out.println(message);

class Main {
 public static void main(String[] args) {

Printer printer = new Printer();

printer.print("Hello, world!"); // Message passing (method call)

Summary of Key Characteristics:

1. Encapsulation - Hiding internal state and requiring all interaction to be performed via
methods.
2. Inheritance - Creating new classes based on existing ones to promote code reuse.
3. Polymorphism - Allowing methods to behave differently based on the object type.
4. Abstraction - Hiding complexity by exposing only necessary features.
5. Classes and Objects - A class is a blueprint, and objects are instances created from
the class.
6. Message Passing - Objects communicate with each other by invoking methods and
exchanging information.

These characteristics combine to form the foundation of object-oriented programming and

provide a structured, modular approach to building software applications.

Message Passing is a concept in Object-Oriented Programming (OOP) where objects

communicate with each other by sending and receiving messages. These messages typically
correspond to method calls that objects make on other objects, often passing information
(parameters) to perform actions or obtain results.

In simple terms, message passing is how objects interact with one another in an OOP system.
The idea is that objects don’t directly access each other’s data or methods, but instead, they
send messages to each other (usually by invoking methods) to request actions or share
information.

Key Points:

1. Method Invocation: When one object calls a method of another object, it's essentially
passing a message to the other object to perform some action.
2. Passing Data: The message can include parameters or data that the receiving object
needs to process the request.
3. Encapsulation: The concept supports the idea of encapsulation because objects do
not directly manipulate each other’s internal state. Instead, they communicate via
methods (messages).

Example:
Let's take an example where two objects, Car and Driver, communicate using message
passing.

class Car {

void startEngine() {

System.out.println("Car engine started.");

class Driver {

Car car;

Driver(Car car) {

this.car = car;

void driveCar() {

car.startEngine(); // Driver sends a message to Car to start the engine.

System.out.println("Driving the car.");

public class Main {

public static void main(String[] args) {

Car myCar = new Car(); // Create a Car object

Driver driver = new Driver(myCar); // Create a Driver object and pass the Car object

driver.driveCar(); // Driver sends a message to Car to start the engine and drive
 }

In the example:

 Message Passing: The Driver object sends a message to the Car object by calling the
startEngine() method.
 Encapsulation: The Driver doesn't directly start the engine or access internal
properties of the Car object. Instead, it sends a message (method call) to the Car to
request the engine start.

Summary:

Message passing in OOP is a way of interacting with objects through methods, where one
object invokes a method on another object, sending a message to perform an action. It is an
essential concept that promotes modularity, data encapsulation, and abstraction in object-
oriented systems.

Qualified Association is a concept in Object-Oriented Modeling (OOM), particularly in

UML (Unified Modeling Language), used to represent the relationship between two classes,
where one class has a collection or reference of objects of another class, but with a
qualification or identifier that helps in identifying or accessing a specific object within that
collection.

Key Features of Qualified Association:

 Qualification: A class (referred to as the "qualified" class) holds an identifier or key

that allows it to select a specific object from a collection of related objects.
 Mapping: The key or identifier is used to map to a particular instance in the
collection, effectively qualifying the association.
 Multiplicity: The qualified association often implies that each object in the qualified
class is linked to multiple objects in the other class, but the key allows for unique
identification or selection.

Common Scenario:

In many cases, a qualified association can represent situations where a container class holds
references to multiple objects, but each reference can be uniquely accessed via a qualification
value. For example, a Library class could have multiple Book objects, and a qualified
association might use a ISBN number as a qualification to uniquely identify each book.

Example of Qualified Association:

Let's consider an example of a Library and a Book class. The Library holds multiple Book
objects, but each Book can be accessed using its ISBN number as a qualification.
+----------------+ 1 +----------------+

| Library |------------| Book |

+----------------+ +----------------+

| +books: Set | | +isbn: String |

+----------------+ | +title: String |

+----------------+

In the above diagram:

 The Library class has a qualified association with the Book class.
 The qualification is based on the ISBN of each book.
 The Library can access each Book uniquely by its ISBN.

In Code (Illustration in Java-like Pseudocode):

class Book {

String isbn;

String title;

Book(String isbn, String title) {

this.isbn = isbn;

this.title = title;

class Library {

private Map<String, Book> books = new HashMap<>();

void addBook(Book book) {

books.put(book.isbn, book);
 }

Book getBookByISBN(String isbn) {

return books.get(isbn); // Qualified association: retrieving by ISBN

Explanation:

 The Library holds a collection of Book objects in a Map, where the key is the ISBN
(the qualification) and the value is the Book object.
 The getBookByISBN method allows accessing any Book in the Library using the
ISBN as a qualification.

Benefits of Qualified Association:

1. Efficient Access: By using a qualification like an ID or key, specific objects within a

collection can be quickly and uniquely accessed.
2. Clarity: It simplifies the representation of relationships where objects need to be
uniquely identified within a collection.
3. Flexibility: Allows for more complex relationships where objects within a container
can be accessed in different ways based on the qualification.

Summary:

A qualified association is a relationship between two classes where one class holds a
collection of objects from another class, and a qualification (like a key or identifier) is used to
access specific objects within that collection. This provides a more structured way to model
relationships that require identification or filtering within a group of related objects.

Abstract Class:

An abstract class in Java is a class that cannot be instantiated directly. It is meant to be

subclassed by other classes. An abstract class may contain abstract methods (methods
without a body) and concrete methods (methods with a body). Abstract classes are used to
define common behaviors that can be shared across subclasses while allowing for
customization in the subclasses.

Key Features of Abstract Class:

 1. Abstract Methods: Methods without implementation (i.e., method signature only, no
body). These must be implemented by subclasses.
2. Concrete Methods: Methods with a full implementation that can be inherited by
subclasses.
3. Instance Variables: An abstract class can have instance variables, constructors, and
static methods.
4. Inheritance: A class can inherit from only one abstract class (since Java does not
support multiple inheritance).
5. Cannot Be Instantiated: You cannot create an object of an abstract class directly.

Example:

abstract class Animal {

// Abstract method (no body)

abstract void sound();

// Concrete method (with body)

void eat() {

System.out.println("This animal eats food.");

class Dog extends Animal {

// Implementing the abstract method

void sound() {

System.out.println("The dog barks.");

Interface:

An interface in Java is a reference type, similar to a class, that can contain only abstract
methods, default methods, and static methods. Interfaces define a contract that a class must
adhere to if it implements the interface. A class that implements an interface must provide
implementations for all abstract methods of the interface.
Key Features of Interface:

1. Abstract Methods: All methods in an interface are abstract by default (until Java 8,
after which default and static methods can be added).
2. Default Methods: Since Java 8, interfaces can have methods with default
implementations using the default keyword.
3. Static Methods: Interfaces can contain static methods.
4. No Instance Variables: Interfaces cannot have instance variables; only constants
(static and final variables) are allowed.
5. Multiple Inheritance: A class can implement multiple interfaces, enabling multiple
inheritance.
6. Cannot Have Constructors: Interfaces do not have constructors.

Example:

interface Animal {

// Abstract method (no body)

void sound();

// Default method

default void eat() {

System.out.println("This animal eats food.");

class Dog implements Animal {

// Implementing the abstract method

public void sound() {

System.out.println("The dog barks.");

Difference Between Abstract Class and Interface:

Feature Abstract Class Interface
Can have both abstract and All methods are abstract (except default
Methods
concrete methods and static methods)
A class can inherit from only
Inheritance A class can implement multiple interfaces
one abstract class
Constructor Can have constructors Cannot have constructors
Can have instance variables Can only have constants (static final
Fields
(fields) variables)
Can have access modifiers All methods are implicitly public, cannot
Access Modifiers
(public, private) have other access modifiers
Default Methods Cannot have default methods Can have default methods (since Java 8)
Multiple Yes, a class can implement multiple
No (single inheritance)
Inheritance interfaces
Used for common behavior Used to define a contract for unrelated
Purpose
among related classes classes

When to Use Each:

 Abstract Class: When you want to provide a common base class with some shared
implementation, and the classes you are working with are closely related in a
hierarchy.
 Interface: When you want to define a contract for behavior that can be implemented
by any class, irrespective of its position in the class hierarchy. Interfaces are often
used for cross-cutting concerns like logging, event handling, or defining APIs.

Summary:

 Abstract Class: Can have both abstract and concrete methods, instance variables, and
constructors. It allows for a more hierarchical design.
 Interface: Primarily defines a contract with abstract methods and constants, and is
more suited for defining capabilities or behaviors that can be implemented across
different class hierarchies.

Parameter Passing:

Parameter passing refers to how arguments (or values) are passed to a method or function
when it is invoked. In programming, there are mainly two ways to pass arguments to
functions or methods: Call-by-Value and Call-by-Reference.

Call-by-Value and Call-by-Reference:

1. Call-by-Value:
o Definition: In Call-by-Value, a copy of the actual value is passed to the
function. This means any changes made to the parameter inside the function
do not affect the original argument.
o Effect on Original Value: Since the function operates on a copy, the original
value in the calling environment is unchanged after the function call.
 2. Call-by-Reference:
o Definition: In Call-by-Reference, a reference (memory address) of the
argument is passed to the function, so the function works with the actual data.
This means that changes made to the parameter inside the function directly
affect the original argument.
o Effect on Original Value: Since the function works directly with the
argument, changes to the parameter inside the function also change the
original value.

Call-by-Value Example:

class CallByValueExample {

public static void main(String[] args) {

int x = 10;

System.out.println("Before calling modifyValue, x = " + x);

modifyValue(x);

System.out.println("After calling modifyValue, x = " + x);

static void modifyValue(int num) {

num = 20; // Modifying the local copy of num

System.out.println("Inside modifyValue, num = " + num);

Output:

Before calling modifyValue, x = 10

Inside modifyValue, num = 20

After calling modifyValue, x = 10

Explanation:

 In Call-by-Value, the method modifyValue gets a copy of x, and changes made

inside the function do not affect the original value of x in the main method. Thus, x
remains 10 after the function call.
Call-by-Reference Example:

class CallByReferenceExample {

public static void main(String[] args) {

int[] arr = {10};

System.out.println("Before calling modifyValue, arr[0] = " + arr[0]);

modifyValue(arr);

System.out.println("After calling modifyValue, arr[0] = " + arr[0]);

static void modifyValue(int[] arr) {

arr[0] = 20; // Modifying the original array's value

System.out.println("Inside modifyValue, arr[0] = " + arr[0]);

Output:

Before calling modifyValue, arr[0] = 10

Inside modifyValue, arr[0] = 20

After calling modifyValue, arr[0] = 20

Explanation:

 In Call-by-Reference, the method modifyValue receives a reference to the original

array arr. Any changes made to arr inside the method directly affect the original array,
so arr[0] becomes 20.

Difference Between Call-by-Value and Call-by-Reference:

Feature Call-by-Value Call-by-Reference
The reference (memory address) of
What is passed A copy of the value is passed.
the argument is passed.
Effect on The original value in the calling The original value in the calling
Original Value function remains unchanged. function is affected.
Method The method receives a copy of the
The method receives the address of the
Parameter actual argument (primitive data
argument (objects, arrays, etc.).
Type types).
Suitable for primitive data types Suitable when changes need to reflect
Usage where changes should not affect the in the original argument (e.g.,
original argument. modifying an array or object).
More memory is used as the value Less memory is used as only the
Memory
is copied. reference is passed.
Example Primitive types like int, float, etc. Objects, arrays, etc.

Summary:

 Call-by-Value: A copy of the value is passed to the function, and changes made
inside the function do not affect the original value.
 Call-by-Reference: The reference (or memory address) of the original argument is
passed to the function, and changes made inside the function directly affect the
original value.

THROW and THROWS Clause:

1. THROW:
o The throw keyword is used to explicitly throw an exception from a method or
block of code.
o When you use throw, you are creating and throwing a specific exception.
o throw is used inside the method to indicate that something went wrong, and
the method should terminate or pass the exception to a higher level in the call
stack.
o Example:
o class ThrowExample {
o public static void checkAge(int age) {
o if (age < 18) {
o throw new ArithmeticException("Age must be 18 or above.");
o } else {
o System.out.println("Age is valid.");
o }
o }
o
o public static void main(String[] args) {
o checkAge(15); // This will throw an exception
o }
}o
2. THROWS:
 o The throws keyword is used in the method signature to declare that the
method might throw one or more exceptions.
o throws tells the calling code that it should handle or declare the exceptions that
could arise from the method.
o This is used for checked exceptions (exceptions that are checked at compile-
time).
o Example:
o class ThrowsExample {
o public static void readFile() throws IOException {
o FileReader fr = new FileReader("file.txt");
o BufferedReader br = new BufferedReader(fr);
o br.readLine();
o }
o
o public static void main(String[] args) {
o try {
o readFile();
o } catch (IOException e) {
o System.out.println("IOException caught: " + e);
o }
o }
o }

FINAL and FINALLY:

1. FINAL:
o final is a keyword used to declare constants, prevent method overriding, and
prevent inheritance of classes.
o It can be applied to:
 Variables: When a variable is declared as final, its value cannot be
changed after initialization. These are constants.
 Methods: When a method is declared as final, it cannot be overridden
by any subclass.
 Classes: When a class is declared as final, it cannot be subclassed
(inherited).
o Example of final variable:
o final int MAX_VALUE = 100;
o // MAX_VALUE = 200; // This will cause an error as the variable is final.
o Example of final method:
o class Parent {
o public final void display() {
o System.out.println("Display in Parent");
o }
o }
o
o class Child extends Parent {
o // public void display() { } // This will cause an error, as the method is final.
o }
o Example of final class:
 final class FinalClass {
o
o // This class cannot be subclassed.
}
o
2. FINALLY:
o finally is a block of code that is always executed after the try block, whether
an exception is thrown or not. It is used to release resources or perform
cleanup actions like closing files or database connections.
o The finally block is optional, but when it is present, it will always execute
after the try block (even if there is a return statement in the try block or if an
exception occurs).
o Example of finally block:
o class FinallyExample {
o public static void main(String[] args) {
o try {
o System.out.println("Inside try block.");
o int result = 10 / 0; // This will throw an exception
o } catch (ArithmeticException e) {
o System.out.println("Inside catch block.");
o } finally {
o System.out.println("Inside finally block.");
o }
o }
o }

Output:

Inside try block.

Inside catch block.

Inside finally block.

o Even though an exception occurs, the finally block is always executed.

Difference Between FINAL, FINALLY, THROW, and THROWS:

Keyword Definition Usage Example

Used to define - final variable: constant
constants, prevent value - final method:
final int MAX_VALUE =
FINAL method overriding, cannot be overridden -
100;final void display() {...}
and prevent class final class: cannot be
inheritance. subclassed
A block of code that is
Used for cleanup code,
FINALLY always executed after finally { ... }
like closing resources.
try and catch blocks.
THROW Used to explicitly To throw an exception. throw new
throw an exception ArithmeticException("Error
Keyword Definition Usage Example
from a method or
message");
block of code.
Declares that a
Used in method
method might throw public void readFile() throws
THROWS signatures to declare
one or more IOException { ... }
exceptions.
exceptions.

Summary:

 throw is used to throw an exception explicitly in the code, while throws is used in
the method signature to declare the exceptions that might be thrown.
 final is used to declare constants, prevent method overriding, or prevent class
inheritance, while finally is used to ensure that a block of code is executed after the
try-catch blocks, regardless of whether an exception occurs.

Exceptions:

An exception in Java is an event that disrupts the normal flow of the program's execution.
Exceptions can occur for various reasons, such as invalid input, file not found, or dividing by
zero. When an exception occurs, it creates an object that contains information about the error
and its cause, and the program may either handle the exception or terminate.

Java has a built-in mechanism for handling exceptions using try, catch, throw, throws, and
finally blocks.

User-Defined Exceptions:

 User-defined exceptions are exceptions created by the programmer by extending the

Exception class or one of its subclasses. These exceptions are used when the
predefined exceptions do not sufficiently describe the specific problem.
 To create a user-defined exception:
o Define a new class that inherits from Exception or RuntimeException.
o Optionally, provide a constructor to pass a custom error message.

Example:

// User-defined exception

class InvalidAgeException extends Exception {

public InvalidAgeException(String message) {

super(message); // Passing message to the superclass constructor

}
class TestUserDefinedException {

static void validateAge(int age) throws InvalidAgeException {

if (age < 18) {

throw new InvalidAgeException("Age must be 18 or above");

} else {

System.out.println("Valid age");

public static void main(String[] args) {

try {

validateAge(16); // This will throw the custom exception

} catch (InvalidAgeException e) {

System.out.println("Caught exception: " + e.getMessage());

System-Defined Exceptions:

 System-defined exceptions are exceptions that are already provided by Java in the
standard library. These exceptions are subclasses of the Throwable class and are
divided into:
o Checked exceptions: These exceptions must be either caught or declared to
be thrown (e.g., IOException, SQLException).
o Unchecked exceptions: These exceptions do not need to be explicitly handled
or declared. They are subclasses of RuntimeException (e.g.,
NullPointerException, ArrayIndexOutOfBoundsException).

Example of system-defined exception:

class TestSystemDefinedException {
 public static void main(String[] args) {

int[] arr = new int[5];

try {

System.out.println(arr[10]); // This will throw ArrayIndexOutOfBoundsException

} catch (ArrayIndexOutOfBoundsException e) {

System.out.println("Caught exception: " + e);

this Keyword:

 The this keyword in Java refers to the current instance of the class. It is used within
an instance method or constructor to refer to the current object.
o It can be used to differentiate between class attributes and parameters if they
have the same name.
o It can also be used to call another constructor within the same class
(constructor chaining).

Example:

class Person {

private String name;

Person(String name) {

this.name = name; // "this" refers to the current object

void display() {

System.out.println("Name: " + this.name); // "this" refers to the current object's name

}
public class TestThis {

public static void main(String[] args) {

Person person = new Person("John");

person.display();

super Keyword:

 The super keyword refers to the parent class of the current object. It is used to:
o Access the parent class's methods and constructors.
o Call a parent class's constructor from a subclass.
o Invoke the parent class method when it is overridden in the subclass.

Example:

class Animal {

void sound() {

System.out.println("Animal makes sound");

class Dog extends Animal {

@Override

void sound() {

super.sound(); // Calling parent class method

System.out.println("Dog barks");

}
public class TestSuper {

public static void main(String[] args) {

Dog dog = new Dog();

dog.sound(); // Will call the method from Dog class and use the parent method

Difference Between == Operator and equals() Method in String Comparison:

1. == Operator:
o The == operator in Java is used to compare references (memory locations) of
objects, not the content. For String objects, == checks if both string variables
point to the same object in memory (i.e., they refer to the same memory
location).

Example:

String str1 = new String("Hello");

String str2 = new String("Hello");

System.out.println(str1 == str2); // false, because they refer to different objects in memory

2. equals() Method:
o The equals() method is used to compare the content of the strings. It checks if
the actual characters inside the two String objects are the same, even if they
are stored in different memory locations.

Example:

String str1 = new String("Hello");

String str2 = new String("Hello");

System.out.println(str1.equals(str2)); // true, because their content is the same

Difference Between == and equals():

Operator/Method Comparison Type Usage Result

== Compares Used to compare Returns true if both
reference (memory whether two references references point to the
Operator/Method Comparison Type Usage Result
same object; false
address) point to the same object
otherwise.
Returns true if the contents
Compares content Used to compare the
equals() of the two objects are the
(actual values) contents of two objects
same; false otherwise.

Summary:

 Exceptions are events that disrupt the normal flow of execution in a program. They
can be user-defined (created by the programmer) or system-defined (provided by the
Java library).
 The this keyword refers to the current instance of the class, while super refers to the
parent class of the current object.
 The == operator compares object references, while the equals() method compares the
contents of the objects.

1. Dynamic Method Dispatch:

Dynamic Method Dispatch is a technique in Java where a call to an overridden method is

resolved at runtime, rather than at compile time. This allows Java to determine which method
to execute based on the actual object type, even if the reference variable is of a superclass
type.

Example:

class Animal {

void sound() {

System.out.println("Animal makes sound");

class Dog extends Animal {

@Override

void sound() {

System.out.println("Dog barks");
 }

public class Test {

public static void main(String[] args) {

Animal animal = new Dog();

animal.sound(); // Dog's sound() method is called, demonstrating dynamic method

dispatch

2. Encapsulation:

Encapsulation is an OOP concept where the internal details of an object are hidden from the
outside world. Only the necessary functionality is exposed, usually through getter and setter
methods. This helps in maintaining data integrity and protecting the internal state of the
object.

Example:

class Person {

private String name;

public String getName() {

return name;

public void setName(String name) {

this.name = name;

}
3. Link and Association:

 Association refers to a relationship between two classes where one class can be
associated with another, representing a "has-a" relationship. It can be one-to-one, one-
to-many, or many-to-many.
 Link refers to the connection or reference between objects of different classes. It can
be unidirectional or bidirectional.

4. Covariant Return:

Covariant Return is a feature in Java where a method in a subclass can return a type that is a
subclass of the return type declared in the superclass method. This allows more specific
return types while still adhering to the parent method's signature.

Example:

class Animal {

Animal getInstance() {

return new Animal();

class Dog extends Animal {

@Override

Dog getInstance() {

return new Dog();

5. Polymorphism:

Polymorphism is the ability of an object to take many forms. In Java, this is implemented
through method overloading (compile-time polymorphism) and method overriding (runtime
polymorphism). It allows a single method or object to behave differently based on the
context.

Example (Method Overloading):

class Calculator {
 int add(int a, int b) {

return a + b;

double add(double a, double b) {

return a + b;

6. Abstract Class:

An abstract class is a class that cannot be instantiated on its own and may contain abstract
methods (methods without a body) that must be implemented by its subclasses. It provides a
blueprint for other classes.

Example:

abstract class Animal {

abstract void sound();

void sleep() {

System.out.println("Animal is sleeping");

class Dog extends Animal {

@Override

void sound() {

System.out.println("Dog barks");

}
}

7. Dynamic Binding:

Dynamic Binding refers to the process where the method that gets called is determined at
runtime, not compile-time. This is typically used in the context of method overriding in
polymorphism.

Example:

class Animal {

void sound() {

System.out.println("Animal makes sound");

class Dog extends Animal {

@Override

void sound() {

System.out.println("Dog barks");

public class Test {

public static void main(String[] args) {

Animal animal = new Dog();

animal.sound(); // Dynamic binding calls Dog's sound method at runtime

8. Method Overriding:
Method Overriding allows a subclass to provide a specific implementation of a method that is
already defined in its superclass. The overridden method must have the same name, return
type, and parameters.

Example:

class Animal {

void sound() {

System.out.println("Animal makes sound");

class Dog extends Animal {

@Override

void sound() {

System.out.println("Dog barks");

public class Test {

public static void main(String[] args) {

Animal animal = new Dog();

animal.sound(); // Calls Dog's overridden sound method

9. Properties of OOP:

The key properties of Object-Oriented Programming (OOP) are:

 Encapsulation: Bundling of data and methods that operate on the data into a single
unit (class).
  Abstraction: Hiding the implementation details and showing only the essential
features of the object.
 Inheritance: Mechanism that allows one class to inherit the properties and behaviors
of another class.
 Polymorphism: The ability of an object to take many forms, achieved through
method overloading and overriding.

1. Java and Multiple Inheritance:

Java does not support multiple inheritance directly through classes. This means that a class
cannot inherit from more than one class, as multiple inheritance can lead to ambiguity (e.g.,
the Diamond Problem). However, Java provides a way to implement multiple inheritance
using interfaces.

Java implements multiple inheritance using interfaces. In Java, a class can implement
multiple interfaces, thereby achieving multiple inheritance of behavior without the issues
related to multiple inheritance from classes.

Example:

interface A {

void methodA();

interface B {

void methodB();

}
class C implements A, B {

@Override

public void methodA() {

System.out.println("Method A from Interface A");

@Override

public void methodB() {

System.out.println("Method B from Interface B");

public class Test {

public static void main(String[] args) {

C obj = new C();

obj.methodA();

obj.methodB();

In this example, class C implements both interfaces A and B, thereby achieving the effect of
multiple inheritance.

2. Method Overloading:

Method overloading refers to defining multiple methods in the same class with the same
name but with different parameter lists (i.e., different numbers of parameters, types, or both).

 Function Overloading is essentially the same as method overloading.

  It allows the class to define multiple methods that perform similar tasks but operate on
different types or numbers of arguments.

Example:

class Calculator {

// Method with two parameters

int add(int a, int b) {

return a + b;

// Method with three parameters (overloaded method)

int add(int a, int b, int c) {

return a + b + c;

public class Test {

public static void main(String[] args) {

Calculator calc = new Calculator();

System.out.println(calc.add(10, 20)); // Calls method with two parameters

System.out.println(calc.add(10, 20, 30)); // Calls method with three parameters

In this example, the method add is overloaded with two different parameter lists: one with
two integers and the other with three integers.

3. Method Overloading vs. Method Overriding:

 Method Overloading:
 o Occurs when two or more methods in the same class have the same name but
different parameters (different number or types of parameters).
o It is resolved at compile-time (also known as compile-time polymorphism).
o It doesn't change the behavior of the method; it's just a way to provide
multiple methods with the same name but different parameters.

Example of Method Overloading:

class Demo {

void display(int a) {

System.out.println("Display with one argument: " + a);

void display(int a, int b) {

System.out.println("Display with two arguments: " + a + ", " + b);

 Method Overriding:
o Method overriding occurs when a subclass provides a specific implementation
for a method that is already defined in its superclass.
o It is resolved at runtime (also known as runtime polymorphism).
o The method signature (name and parameters) in the subclass must be the same
as that in the superclass.

Example of Method Overriding:

class Animal {

void sound() {

System.out.println("Animal makes sound");

class Dog extends Animal {

@Override
 void sound() {

System.out.println("Dog barks");

4. Differentiating Between Method Overloading and Method Overriding:

Feature Method Overloading Method Overriding

Same method name, different Same method name and parameters in both
Definition
parameters (number/type). parent and child.
Allows methods to perform
Provides specific implementation in
Purpose similar tasks with different
subclass.
input.
Compile-time/ Resolved at runtime (dynamic
Resolved at compile-time.
Runtime polymorphism).
Method name must be the
Method Method signature must be identical in both
same, but the parameters
Signature superclass and subclass.
must differ.
Return type can be the same Return type must be the same as the
Return Type
or different. superclass method (or covariant).
Access modifier can be The access modifier in the subclass method
Access Modifier changed (e.g., private, should be the same or more accessible than
public). the parent class method.

Inheritance in Java:

Inheritance is a fundamental concept in Object-Oriented Programming (OOP), where a new

class (child class) inherits the properties and behaviors (methods) of an existing class (parent
class). It allows for code reusability, as the child class can use the methods and fields of the
parent class and even add its own specific methods and fields.
The primary purpose of inheritance is to model real-world relationships and build hierarchies
of classes.

Types of Inheritance in Java:

Java supports the following types of inheritance:

1. Single Inheritance:

Single inheritance occurs when a class (child class) inherits from one and only one class
(parent class).

 Example:

class Animal {

void sound() {

System.out.println("Animal makes sound");

class Dog extends Animal {

void sound() {

System.out.println("Dog barks");

public class Test {

public static void main(String[] args) {

Dog dog = new Dog();

dog.sound(); // Calls Dog's sound method, inherited from Animal

}
In this example, Dog inherits from Animal and can access or override the sound() method.

2. Multilevel Inheritance:

Multilevel inheritance occurs when a class (child class) inherits from another child class,
forming a chain of inheritance.

 Example:

class Animal {

void sound() {

System.out.println("Animal makes sound");

class Dog extends Animal {

void sound() {

System.out.println("Dog barks");

class Puppy extends Dog {

void sound() {

System.out.println("Puppy whines");

public class Test {

public static void main(String[] args) {

Puppy puppy = new Puppy();

 puppy.sound(); // Calls Puppy’s sound method, inherited from Dog

In this example, Puppy inherits from Dog, and Dog inherits from Animal, forming a
multilevel inheritance hierarchy.

3. Hierarchical Inheritance:

Hierarchical inheritance occurs when multiple classes inherit from the same parent class.

 Example:

class Animal {

void sound() {

System.out.println("Animal makes sound");

class Dog extends Animal {

void sound() {

System.out.println("Dog barks");

class Cat extends Animal {

void sound() {

System.out.println("Cat meows");

}
public class Test {

public static void main(String[] args) {

Dog dog = new Dog();

dog.sound(); // Calls Dog's sound method

Cat cat = new Cat();

cat.sound(); // Calls Cat's sound method

Here, both Dog and Cat inherit from the same parent class Animal.

4. Multiple Inheritance (through Interfaces):

Java does not allow multiple inheritance through classes due to ambiguity issues, but it
supports multiple inheritance through interfaces. A class can implement multiple interfaces,
thus inheriting behaviors from multiple sources.

 Example:

interface Animal {

void sound();

interface Movable {

void move();

class Dog implements Animal, Movable {

public void sound() {

System.out.println("Dog barks");
 }

public void move() {

System.out.println("Dog runs");

public class Test {

public static void main(String[] args) {

Dog dog = new Dog();

dog.sound(); // Calls Dog's sound method

dog.move(); // Calls Dog's move method

In this example, Dog implements both Animal and Movable interfaces, allowing it to inherit
behaviors from both.

5. Hybrid Inheritance:

Hybrid inheritance is a combination of two or more types of inheritance, typically involving a

combination of single, multilevel, hierarchical, and multiple inheritance.

Java does not support hybrid inheritance directly through classes, but a class can inherit from
multiple interfaces, which can be considered as hybrid inheritance through interfaces.

 Example (Hybrid through interfaces):

interface Animal {

void sound();

interface Movable {
 void move();

class Dog extends Animal implements Movable {

@Override

public void sound() {

System.out.println("Dog barks");

@Override

public void move() {

System.out.println("Dog runs");

public class Test {

public static void main(String[] args) {

Dog dog = new Dog();

dog.sound(); // Calls Dog's sound method

dog.move(); // Calls Dog's move method

Advantages of Inheritance:

 Code Reusability: Inherited methods and properties from the parent class can be
reused in the child class.
 Method Overriding: Allows for the modification of parent class methods in the child
class.
  Extensibility: New functionality can be added without altering the parent class.

Conclusion:

Inheritance helps in organizing and managing the relationships between classes by creating
hierarchies and providing a mechanism for code reuse. While Java allows inheritance through
classes and interfaces, multiple inheritance is only supported through interfaces to avoid
ambiguity.

Yes, you can override a method in a subclass to throw an exception, but there are rules:

1. Unchecked exceptions (like RuntimeException or its subclasses) can be thrown in

the subclass method without any restrictions, even if the superclass method doesn't
declare any exceptions.
2. Checked exceptions (like IOException or SQLException) can only be thrown in the
subclass method if they are a subclass of any exception declared in the superclass
method. If the superclass method doesn't declare any exceptions, you can throw any
checked exception.

Example:

1. Valid:
2. class Superclass {
3. void myMethod() {
4. System.out.println("Superclass method");
5. }
6. }
7.
8. class Subclass extends Superclass {
9. @Override
10. void myMethod() throws IOException { // Throws a checked exception
11. System.out.println("Subclass method");
12. throw new IOException("Exception");
13. }
14. }
15. Invalid (throws an incompatible exception):
16. class Superclass {
17. void myMethod() {
18. System.out.println("Superclass method");
19. }
20. }
21.
22. class Subclass extends Superclass {
23. @Override
 24. void myMethod() throws SQLException { // Compilation error, SQLException is
not compatible
25. System.out.println("Subclass method");
26. throw new SQLException("Exception");
27. }
28. }

So, you can throw an exception in the subclass, but it must follow these rules.

What is JVM?

JVM stands for Java Virtual Machine. It is a part of the Java Runtime Environment (JRE)
that is responsible for executing Java bytecode. The JVM converts the compiled Java code
(bytecode) into machine code so that it can run on any operating system and hardware
platform. The JVM is what allows Java to be platform-independent, meaning the same Java
program can run on different devices or operating systems without modification.

Functions of JVM:

1. Loading of Class Files: The JVM loads compiled .class files (bytecode) into memory
for execution.
2. Bytecode Verification: The JVM verifies the bytecode to ensure that it adheres to the
Java language specification and does not perform illegal operations.
3. Execution of Bytecode: The JVM executes the bytecode by converting it into
machine code specific to the underlying operating system and hardware architecture.
This is done using an interpreter or Just-In-Time (JIT) compiler.
4. Memory Management: The JVM manages memory through garbage collection,
automatically freeing up memory from objects that are no longer needed.
5. Exception Handling: The JVM handles exceptions (errors in the program) by
providing mechanisms like try-catch blocks.
6. Security: The JVM includes a security manager that controls access to system
resources like file I/O or network connections, ensuring that Java programs run in a
safe environment.

What do you mean by Java being a platform-dependent language?

Java is often described as a platform-independent language, which means that Java code
can run on any platform that has a compatible JVM. However, it might seem confusing
because the JVM itself is platform-dependent.

To clarify:
  Java is platform-independent because the Java source code is compiled into
bytecode. This bytecode can be run on any platform with a JVM.
 The JVM is platform-dependent because it is specific to the underlying operating
system and hardware. Each operating system has its own JVM implementation
(Windows, Linux, macOS, etc.).

So, Java programs are platform-independent at the source code and bytecode level, but they
require a JVM that is specific to the platform they are running on.

In summary:

 JVM: Converts bytecode into machine code and provides the runtime environment
for Java applications.
 Platform Independence: Java code can run on any platform with a compatible JVM,
making it platform-independent at the source code level but platform-dependent at the
JVM level.

Garbage Collector in Java

The garbage collector in Java is an automatic memory management system that reclaims
memory from objects that are no longer in use, preventing memory leaks and optimizing
resource utilization.

Garbage Collection Procedure

1. Identification of Unused Objects: The garbage collector identifies objects that are
no longer referenced by any part of the program (i.e., unreachable objects).
2. Marking: It marks all reachable objects, starting from active references (like
variables, method parameters, etc.).
3. Sweeping (Deletion): Unreachable objects that were not marked are removed from
memory, freeing up space.
4. Compacting (Optional): The memory may be reorganized to eliminate
fragmentation and optimize free space.

This process runs automatically in the background, and developers don’t need to manually
manage memory.

Compilation and Interpretation in Java

Java follows a two-step process: compilation and interpretation.

 1. Compilation:
o The Java compiler (javac) converts the Java source code (.java files) into an
intermediate code called bytecode (.class files).
o This bytecode is platform-independent, meaning it can run on any system that
has a Java Virtual Machine (JVM).
2. Interpretation:
o The JVM interprets the bytecode or uses a Just-In-Time (JIT) compiler to
convert the bytecode into machine code that the underlying operating system
can execute.
o This allows Java to be platform-independent, as the same bytecode can run on
any machine with a compatible JVM.

In summary, Java is compiled into bytecode, and then interpreted (or compiled to machine
code) by the JVM for execution.

Virtual Method Table (VMT)

The Virtual Method Table (VMT) is a mechanism used in object-oriented programming

(OOP) languages like Java to support dynamic method dispatch (runtime polymorphism). It
is used to store references to methods that can be called on an object.

 Each class with methods that can be overridden by subclasses has a corresponding
VMT.
 When a method is called on an object, the JVM checks the object's class's VMT to
determine which method implementation to invoke, especially when method
overriding is used.
 This allows for dynamic method calls at runtime, depending on the object's actual
type, not its reference type.

Command-Line Arguments

Command-line arguments allow users to pass inputs to a Java program when it is executed
from the command line.

 These arguments are passed as an array of strings (String[] args) to the main method
in Java.
 They provide a way to customize the behavior of a program without modifying its
source code.

Example:

public class CommandLineExample {

 public static void main(String[] args) {

System.out.println("Argument 1: " + args[0]);

System.out.println("Argument 2: " + args[1]);

If run with the command java CommandLineExample Hello World, it will print:

Argument 1: Hello

Argument 2: World

Thread-Like Cycle

A thread-like cycle refers to the lifecycle of a thread in Java, which defines the different
states a thread can be in during its execution:

1. New: The thread is created but not yet started.

2. Runnable: The thread is ready to run, and the scheduler will assign CPU time to it.
3. Blocked: The thread is waiting for resources (e.g., waiting for I/O operations to
complete).
4. Waiting: The thread is waiting for another thread to perform a specific action (e.g.,
waiting for a notification).
5. Terminated: The thread has finished execution and is no longer alive.

The thread cycle involves these transitions based on the thread's state and execution flow,
controlled by the JVM and the operating system.