OOP

Concurrent Programming Concurrent Programming in Java allows multiple threads to run simultaneously, making programs more efficient and responsive, especially for tasks that are independent or I/O-bound. Why Concurrency? Efficient CPU utilization Better performance in multi-core systems Responsiveness in interactive applications Threads in Java Java supports multithreading through the Thread class and Runnable interface. A thread represents a single sequence of execution within a program. Creating Threads 1. By Extending Thread Class class MyThread extends Thread { public void run() { System.out.println("Thread running..."); } } public class Main { public static void main(String[] args) { MyThread t1 = new MyThread(); t1.start(); // Starts a new thread } } 2. By Implementing Runnable Interface class MyRunnable implements Runnable { public void run() { System.out.println("Runnable thread running..."); } } public class Main { public static void main(String[] args) { Thread t = new Thread(new MyRunnable()); t.start(); } } Thread Lifecycle New Runnable Running Blocked/Waiting Terminated Synchronization Used to control thread access to shared resources to prevent data inconsistency. ...

Exception Handlers Exception Handlers in Java are constructs used to handle exceptions that occur during the execution of a program. The primary way to handle exceptions is by using try, catch, and finally blocks. try-catch Block The try block contains code that might throw an exception. The catch block handles the exception type declared in its parameter. try { int[] arr = new int[5]; arr[10] = 50; // This will throw ArrayIndexOutOfBoundsException } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Caught exception: " + e); } Multiple catch Blocks You can catch different types of exceptions separately. ...

Exception Handling Exception Handling in Java is a powerful mechanism that handles runtime errors to maintain the normal flow of application execution. Java provides a robust and object-oriented way to handle exceptions using try, catch, throw, throws, and finally blocks. Why Use Exception Handling? Avoid abnormal termination of the program. Gracefully handle unexpected situations like file not found, divide by zero, etc. Help in debugging and maintaining the code. Keywords in Exception Handling try – Defines a block of code to test for errors. catch – Defines a block of code to handle errors. finally – Defines a block of code that will always execute after try/catch, regardless of the outcome. throw – Used to explicitly throw an exception. throws – Declares exceptions that a method might throw. Example: public class ExceptionExample { public static void main(String[] args) { try { int result = 10 / 0; // ArithmeticException } catch (ArithmeticException e) { System.out.println("Error: " + e.getMessage()); } finally { System.out.println("This will always execute."); } } } Output: ...

Types of Nested Classes Java supports four types of nested classes. Each type serves different use cases and has unique access rules. 1. Static Nested Class Defined using the static keyword inside another class. Can access only static members of the outer class. Does not require an instance of the outer class to be instantiated. class Outer { static int value = 10; static class StaticNested { void show() { System.out.println("Value: " + value); } } } Usage: ...

Nested Classes A Nested Class is a class that is defined within another class. In Java, nested classes can be categorized into several types, such as static nested classes, inner classes, local classes, and anonymous classes. Types of Nested Classes: Static Nested Class: A nested class that is declared static. It can access the static members of the outer class but cannot access the non-static members. Example: class Outer { static int num = 10; static class Inner { void display() { System.out.println(num); } } } 2. **Inner Class (Non-static Nested Class)**: A class that is defined inside another class without the `static` keyword. It can access both static and non-static members of the outer class. * Example: ```java class Outer { int num = 10; class Inner { void display() { System.out.println(num); } } } Local Inner Class: A class defined inside a method. It can access the local variables and parameters of the method. ...

User-defined Interfaces In Java, User-defined Interfaces are interfaces that you create to define a contract that classes must follow. These interfaces allow you to define abstract methods without providing implementations. Classes that implement the interface must provide their own implementations for the abstract methods. Key Points: A user-defined interface can contain abstract methods (methods without implementations) and constants (static final variables). A class that implements a user-defined interface must provide an implementation for all abstract methods in the interface. Multiple interfaces can be implemented by a single class. Example of User-defined Interface: Defining an Interface: interface Animal { void sound(); // Abstract method void move(); // Abstract method } Implementing the Interface in a Class: class Dog implements Animal { @Override public void sound() { System.out.println("Bark"); } @Override public void move() { System.out.println("Dog runs"); } } public class Main { public static void main(String[] args) { Dog dog = new Dog(); dog.sound(); // Output: Bark dog.move(); // Output: Dog runs } } Example of Multiple Interfaces Implementation: interface Animal { void sound(); } interface Mammal { void move(); } class Dog implements Animal, Mammal { @Override public void sound() { System.out.println("Bark"); } @Override public void move() { System.out.println("Dog runs"); } } public class Main { public static void main(String[] args) { Dog dog = new Dog(); dog.sound(); // Output: Bark dog.move(); // Output: Dog runs } } 🔗 Related Notes Packages and Interfaces Access Modifiers Method Overloading Static Keyword Inheritance Types of Inheritance Method Overriding

Build-in Interface In Java, Built-in Interfaces are interfaces that are part of the Java standard library. These interfaces are provided by Java and can be used directly in your applications without needing to define them yourself. Common Built-in Interfaces: Comparable: This interface is used to compare objects for sorting. A class that implements Comparable must provide an implementation for the compareTo() method. Method: int compareTo(T o) Cloneable: This interface is used to indicate that objects of a class can be cloned using the clone() method. ...

Interfaces An interface in Java is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. Interfaces define a contract that classes must implement. Key Points: A class can implement multiple interfaces. Interfaces provide a way to achieve abstraction by allowing methods to be declared without providing their implementation. An interface can be used to define common behaviors that multiple classes can share. Example of Defining and Implementing an Interface: Defining an interface: interface Animal { void sound(); } Implementing the interface in a class: class Dog implements Animal { @Override public void sound() { System.out.println("Bark"); } } public class Main { public static void main(String[] args) { Animal dog = new Dog(); dog.sound(); // Output: Bark } } Example with Multiple Interfaces: interface Animal { void sound(); } interface Mammal { void move(); } class Dog implements Animal, Mammal { @Override public void sound() { System.out.println("Bark"); } @Override public void move() { System.out.println("Dog runs"); } } public class Main { public static void main(String[] args) { Dog dog = new Dog(); dog.sound(); // Output: Bark dog.move(); // Output: Dog runs } } 🔗 Related Notes Access Modifiers Method Overloading Static Keyword Inheritance Types of Inheritance Method Overriding

Packages In Java, a package is a namespace used to organize classes and interfaces. Packages help avoid name conflicts and make it easier to locate and use classes and interfaces. Types of Packages: Built-in Packages: These are provided by Java. Examples include: java.util java.io java.math User-defined Packages: These are created by developers to organize their own classes. Example of Creating and Using Packages: Creating a package: package com.example.animals; class Dog { void bark() { System.out.println("Barking..."); } } Using a class from a package: import com.example.animals.Dog; public class Main { public static void main(String[] args) { Dog dog = new Dog(); dog.bark(); // Output: Barking... } } 🔗 Related Notes Access Modifiers Method Overloading Static Keyword Inheritance Types of Inheritance Method Overriding

Using final The final keyword in Java is used to apply restrictions on classes, methods, and variables. It can be used to prevent inheritance, method overriding, and modification of variables. Key Points: final class: A class declared as final cannot be subclassed. final method: A method declared as final cannot be overridden by subclasses. final variable: A variable declared as final cannot be reassigned after initialization. Example 1: Using final with a class When a class is declared final, it cannot be extended (inherited). ...