Encapsulation added

Signed-off-by: Someshdiwan <[email protected]>

Author: Someshdiwan

Section14Interfaces/src/Callback Method in Java.txt

@@ -1,10 +1,12 @@
 Callback Method in Java:
 
-A callback method in Java is a method that is passed as an argument to another method, and it gets executed at a later time when a certain event occurs or a condition is met.
+A callback method in Java is a method that is passed as an argument to another method, and it gets
+executed at a later time when a certain event occurs or a condition is met.
 
 How Callbacks Work in Java
 
-Since Java does not support passing functions directly (like JavaScript or Python), **callback methods are typically implemented using interfaces, anonymous classes, or lambda expressions.
+Since Java does not support passing functions directly (like JavaScript or Python), **callback methods are typically
+implemented using interfaces, anonymous classes, or lambda expressions.
 
 ---
 

Section14Interfaces/src/Interfaces.txt

@@ -0,0 +1,49 @@
+An interface in Java contributes to polymorphism by defining a contract for implementing classes.
+
+It declares a set of abstract methods that must be implemented by any class that implements the interface.
+
+This allows for polymorphic behavior, as different classes can provide their own implementations of the interface methods.
+
+Objects of these implementing classes can be treated as instances of the interface type, enabling runtime polymorphism
+
+and promoting loose coupling in the code.
+
+This code shows an interface Animal with a method makeSound(). Two classes, Dog and Cat, implement this interface and provide their own implementations of makeSound(). The AnimalSounds class demonstrates how objects of Dog and Cat can be treated as Animal objects, exhibiting polymorphic behavior.
+
+// Define an interface
+interface Animal {
+    void makeSound();
+}
+
+// Implement the interface with a Dog class
+class Dog implements Animal {
+    @Override
+    public void makeSound() {
+        System.out.println("Woof!");
+    }
+}
+
+// Implement the interface with a Cat class
+class Cat implements Animal {
+    @Override
+    public void makeSound() {
+        System.out.println("Meow!");
+    }
+}
+
+// Demonstrate polymorphism
+public class AnimalSounds {
+    public static void main(String[] args) {
+        Animal myDog = new Dog();
+        Animal myCat = new Cat();
+
+        myDog.makeSound(); // Output: Woof!
+        myCat.makeSound(); // Output: Meow!
+    }
+}
+In this example, the Animal interface defines a contract that both Dog and Cat classes adhere to.
+
+This allows us to treat instances of Dog and Cat as Animal objects, and when we call the makeSound() method,
+the appropriate implementation is executed based on the actual object type.
+
+This is a clear demonstration of polymorphism in action.

Section18ExceptionHandling/src/ExceptionHandling.txt

@@ -0,0 +1,41 @@
+When using multiple catch blocks, it's important to order them from most specific to most general exceptions.
+If a more general exception is caught first, it will catch all of its subclasses, preventing more specific catch blocks
+from being reached.
+
+This is why we typically see catch blocks for specific exceptions like NullPointerException before a catch block for the general Exception class.
+
+The 'throws' clause in a method signature is used to declare that the method might throw certain checked exceptions.
+It doesn't actually throw or handle the exception, but rather informs the caller that they need to either catch these
+exceptions or declare them in their own method signature.
+
+This is part of Java's checked exception mechanism, ensuring that potential exceptions are dealt with at compile-time.
+
+To create a custom checked exception, you should extend the Exception class. Extending RuntimeException would create an
+unchecked exception. Extending Error is not appropriate for application-level exceptions, and Throwable is too general.
+
+By extending Exception, you create a checked exception that must be either caught or declared in the method signature,
+enforcing proper exception handling at compile-time.
+
+The main advantage of try-with-resources is that it automatically closes resources that implement the AutoCloseable
+interface. This feature, introduced in Java 7, simplifies resource management and helps prevent resource leaks.
+
+It ensures that resources are closed in the correct order and handles exceptions that might occur during closing.
+
+This leads to cleaner, more reliable code compared to manually closing resources in a finally block.
+
+When an exception is not caught in a method, it is propagated up the call stack to the calling method.
+This process continues until the exception is either caught and handled or reaches the top of the call stack.
+
+If it reaches the top without being caught, the default exception handler prints the stack trace and terminates the program.
+
+This mechanism allows for centralized exception handling and gives flexibility in where exceptions are handled.
+
+The addSuppressed() method is used to add a suppressed exception in Java. This method was introduced along with the
+try-with-resources statement in Java 7.
+
+When an exception occurs in the try block and another exception occurs while closing resources in the implicit finally
+block, the latter exception is suppressed and added to the original exception.
+
+This allows for preserving information about multiple exceptions that occurred during the execution of a block of code.
+
+You can retrieve suppressed exceptions using the getSuppressed() method.