I’ll provide an in-depth explanation of all these Object-Oriented Programming

concepts in Java.

## Final Keyword

The `final` keyword in Java can be applied to variables, methods, and

classes:

- **Final Variables**: Cannot be reassigned after initialization

```java

Final int MAX_VALUE = 100; // Cannot be changed

```

- **Final Methods**: Cannot be overridden by subclasses

```java

Public final void displayInfo() { /* code */ }

```

- **Final Classes**: Cannot be extended/inherited

```java

Public final class ImmutableClass { /* code */ }

```

## Static Keyword

The `static` keyword creates class-level members rather than instance-level:

- **Static Variables**: Shared across all instances of a class

- **Static Methods**: Can be called without creating an object

- **Static Blocks**: Execute when class is loaded into memory

- **Static Classes**: Can only be nested classes (inner classes)

```java
Public class Counter {

Static int count = 0; // Shared across all instances

Public Counter() {

Count++; // Increments the shared counter

Public static void displayCount() {

[Link](“Count: “ + count);

```

## Dynamic Binding

Also known as late binding, it’s the process of determining the method to
invoke at runtime rather than compile time. In Java, all method calls to
objects are resolved during runtime.

```java

Class Animal {

Void makeSound() {

[Link](“Animal sound”);

Class Dog extends Animal {

@Override
 Void makeSound() {

[Link](“Bark”);

Public class Main {

Public static void main(String[] args) {

Animal animal = new Dog(); // Reference is Animal, object is Dog

[Link](); // Calls Dog’s makeSound() – resolved at runtime

```

## Compile-time Polymorphism

Also called static polymorphism or method overloading, this occurs when

multiple methods with the same name but different parameters exist in a
class.

```java

Class Calculator {

// Method overloading examples

Int add(int a, int b) {

Return a + b;

Double add(double a, double b) {

Return a + b;
 }

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

Return a + b + c;

```

## Runtime Polymorphism

Also called dynamic polymorphism or method overriding, this occurs when a

subclass provides a specific implementation of a method that’s already
defined in its parent class.

```java

Class Shape {

Void draw() {

[Link](“Drawing a shape”);

Class Circle extends Shape {

@Override

Void draw() {

[Link](“Drawing a circle”);

}
Class Rectangle extends Shape {

@Override

Void draw() {

[Link](“Drawing a rectangle”);

```

## Inheritance

Inheritance is a mechanism where a new class inherits properties and

behaviors from an existing class:

- **Single Inheritance**: A class inherits from only one class

- **Multilevel Inheritance**: A class inherits from a child class

- **Hierarchical Inheritance**: Multiple classes inherit from one class

- Java doesn’t support multiple inheritance with classes (but does with
interfaces)

```java

// Single inheritance

Class Vehicle {

Void start() {

[Link](“Vehicle starting”);

Class Car extends Vehicle {

Void accelerate() {
 [Link](“Car accelerating”);

// Multilevel inheritance

Class SportsCar extends Car {

Void turboBoost() {

[Link](“Sports car boosting”);

```

## Abstract Class

An abstract class cannot be instantiated and may contain abstract methods

(methods without implementation). Abstract classes are designed to be
extended by concrete subclasses.

```java

Abstract class Animal {

// Regular method with implementation

Void eat() {

[Link](“The animal eats food”);

// Abstract method – no implementation

Abstract void makeSound();

}
Class Dog extends Animal {

// Must implement all abstract methods

@Override

Void makeSound() {

[Link](“The dog barks”);

```

## Interface

An interface is a completely abstract type that contains only method

signatures and constants. All methods are implicitly `public` and `abstract`.

```java

Interface Drawable {

Void draw(); // Abstract by default

// Default method (Java 8+)

Default void displayInfo() {

[Link](“Drawing object”);

// Static method (Java 8+)

Static void commonMethod() {

[Link](“Common drawing method”);

}
}

Class Circle implements Drawable {

@Override

Public void draw() {

[Link](“Drawing a circle”);

```

## Abstract Class vs Interface

| Feature | Abstract Class | Interface |

| Instantiation | Cannot be instantiated | Cannot be instantiated |

| Methods | Can have abstract and concrete methods | All methods are
abstract by default (Java 8+ allows default and static methods) |

| Variables | Can have non-final variables | All variables are final and static by
default |

| Constructor | Can have constructors | Cannot have constructors |

| Access Modifiers | Can use all access modifiers | All methods are implicitly
public |

| Inheritance | Supports single inheritance | A class can implement multiple

interfaces |

| Purpose | When there’s a IS-A relationship | When there’s a HAS-A capability

relationship |

## Access Modifiers
Java has four access modifiers:

1. **Private**: Accessible only within the declared class

2. **Default (Package-Private)**: Accessible within the same package (no

explicit modifier)

3. **Protected**: Accessible within the same package and subclasses

4. **Public**: Accessible from anywhere

```java

Public class AccessDemo {

Private int privateVar; // Only within this class

Int defaultVar; // Within this package

Protected int protectedVar; // Within this package and subclasses

Public int publicVar; // Everywhere

```

**Default vs Protected**:

- Default: Accessible only in the same package

- Protected: Accessible in the same package AND in subclasses (even in

different packages)

## JVM vs JRE vs JDK

**JVM (Java Virtual Machine)**:

- Executes Java bytecode

- Platform-dependent (different implementations for different operating

systems)
- Core responsibilities: Loading, verifying, executing code and providing
runtime environment

**JRE (Java Runtime Environment)**:

- Contains JVM plus libraries and other components needed to run Java
applications

- End users only need JRE to run Java applications

**JDK (Java Development Kit)**:

- Contains JRE plus development tools (compiler, debugger, etc.)

- Required for Java development

## Characteristics of OOP

1. **Encapsulation**: Bundling data (attributes) and methods that

operate on the data into a single unit (class) and restricting direct
access to some of the object’s components

```java

Public class Person {

Private String name; // Encapsulated data

// Getter and Setter methods

Public String getName() { return name; }

Public void setName(String name) { [Link] = name; }

```
 2. **Inheritance**: Mechanism where a class inherits properties and
behaviors from another class

```java

Class Vehicle { /* code */ }

Class Car extends Vehicle { /* code */ }

```

3. **Polymorphism**: Ability of different objects to respond to the same

method call in different ways

```java

Class Animal { void makeSound() { /* code */ } }

Class Dog extends Animal { void makeSound() { /* code */ } }

Class Cat extends Animal { void makeSound() { /* code */ } }

```

4. **Abstraction**: Hiding complex implementation details and showing

only necessary features

```java

Abstract class Shape {

Abstract double calculateArea();

```

## Characteristics of Java

1. **Platform Independent**: “Write Once, Run Anywhere” (WORA)

2. **Object-Oriented**: Based on objects rather than just functions and

procedures
3. **Simple**: No pointers, operator overloading, multiple inheritance (via
classes)

4. **Secure**: Runs in JVM sandbox, automatic memory management

5. **Robust**: Strong memory management, exception handling, type

checking

6. **Multithreaded**: Built-in support for concurrent programming

7. **Architecture Neutral**: No implementation-dependent features

8. **Portable**: Same behavior on all platforms

9. **High Performance**: Just-In-Time compiler for efficient execution

10. **Distributed**: Extensive networking capabilities

## Super Keyword

The `super` keyword refers to the parent class objects:

- Access parent class variables

- Invoke parent class methods

- Call parent class constructor

```java

Class Parent {

Int value = 10;

Void display() {

[Link](“Parent class method”);

Parent(int value) {
 [Link] = value;

Class Child extends Parent {

Int value = 20;

Child(int value) {

Super(value); // Call parent constructor

Void display() {

[Link](“Child value: “ + value);

[Link](“Parent value: “ + [Link]); // Access parent

variable

[Link](); // Call parent method

```

## Wrapper Classes

Wrapper classes provide a way to use primitive data types as objects:

| Primitive Type | Wrapper Class |

| byte | Byte |

| short | Short |
| int | Integer |

| long | Long |

| float | Float |

| double | Double |

| char | Character |

| boolean | Boolean |

Uses of wrapper classes:

- Collections only store objects, not primitives

- Provide utility methods for conversion and manipulation

- Support null values unlike primitives

```java

// Autoboxing (primitive to wrapper)

Int primitiveInt = 42;

Integer wrapperInt = primitiveInt;

// Unboxing (wrapper to primitive)

Integer wrapperDouble = 3.14;

Double primitiveDouble = wrapperDouble;

```

## Procedural vs OOP

**Procedural Programming**:

- Focuses on procedures/functions that operate on data

- Data and functions are separate entities

- Top-down approach

- Examples: C, Pascal

**Object-Oriented Programming**:

- Focuses on objects that contain data and methods

- Data and methods are bundled together

- Bottom-up approach

- Examples: Java, C++, Python, C#

Key differences:

- OOP provides better code reusability through inheritance

- OOP offers better security through encapsulation

- OOP models real-world entities more effectively

- OOP facilitates easier maintenance and modification

## Conditional Statements

Java supports several conditional statements:

1. **If Statement**:

```java

If (condition) {

// Code executed if condition is true

```

2. **If-Else Statement**:
```java

If (condition) {

// Code executed if condition is true

} else {

// Code executed if condition is false

```

3. **If-Else-If Ladder**:

```java

If (condition1) {

// Code executed if condition1 is true

} else if (condition2) {

// Code executed if condition2 is true

} else {

// Code executed if all conditions are false

```

4. **Switch Statement**:

```java

Switch (expression) {

Case value1:

// Code

Break;

Case value2:

// Code
 Break;

Default:

// Code

```

5. **Ternary Operator**:

```java

Result = (condition) ? valueIfTrue : valueIfFalse;

```

## Looping Statements

Java supports several looping constructs:

1. **For Loop**:

```java

For (initialization; condition; update) {

// Code to be repeated

```

2. **Enhanced For Loop (For-Each)**:

```java

For (dataType item : collection) {

// Code to process item

}
 ```

3. **While Loop**:

```java

While (condition) {

// Code to be repeated

```

4. **Do-While Loop**:

```java

Do {

// Code to be repeated

} while (condition);

```

5. **Loop Control Statements**:

- `break`: Exits the loop completely

- `continue`: Skips the current iteration

- `return`: Exits the method (and loop)

## Arrays

An array is a collection of similar data types stored at contiguous memory

locations.

**Declaration and Initialization**:

```java

// Declaration

Int[] numbers;

// or

Int numbers[];

// Initialization

Numbers = new int[5]; // Creates array of size 5

// Declaration and initialization together

Int[] numbers = new int[5];

Int[] numbers = {1, 2, 3, 4, 5};

```

**Accessing Elements**:

```java

Int firstElement = numbers[0]; // Access first element

Numbers[2] = 10; // Modify third element

```

**Array Properties**:

- Fixed size (cannot be changed after creation)

- Zero-indexed (first element is at index 0)

- Store elements of the same data type

- Length is accessed via `[Link]` property

**Multi-dimensional Arrays**:
```java

// 2D array declaration and initialization

Int[][] matrix = new int[3][3];

Int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

// Accessing elements

Int element = matrix[1][2]; // Access element at row 1, column 2

```

**Array Operations**:

- Iteration using loops

- Searching and sorting

- Passing to methods

- Returning from methods

```java

// Iterating through an array

For (int I = 0; I < [Link]; i++) {

[Link](numbers[i]);

// Enhanced for loop

For (int number : numbers) {

[Link](number);

```
These concepts form the foundation of Object-Oriented Programming in Java,
providing a robust framework for creating modular, reusable, and
maintainable code.