Add files via upload

Author: rhalbhavi

OOP/Classes/Types of Classes/Abstract Class/Abstract_Class.java

@@ -0,0 +1,52 @@
+// -- Abstract Class -- //
+
+// Parent abstract class
+abstract class ParentClass {
+    String parentName = "Parent";
+    abstract void department();
+    void show() {
+        System.out.println("Parent class: "   + parentName);
+    }
+}
+
+// Subclass that extends the abstract class
+class SubClass1 extends ParentClass {
+    // Override the abstract method
+    @Override
+    void department() {
+        System.out.println("Department: Science");
+  }
+}
+
+// Another subclass that extends the abstract class
+class SubClass2 extends ParentClass {
+    // Override the abstract method
+    @Override
+    void department() {
+        System.out.println("Department: Commerce");
+  }
+}
+
+// Main class - tests the abstract class and its subclasses
+public class Abstract_Class {
+    // MAIN Method Class
+    public static void main(String[] args) {
+        SubClass1 obj1 = new SubClass1();
+
+        System.out.println("--- SubClass1 Details ---");
+        obj1.show(); // Inherited method
+        obj1.department(); // Overridden method
+
+        SubClass2 obj2 = new SubClass2();
+
+        System.out.println("\n--- SubClass2 Details ---");
+        obj2.show(); // Inherited method
+        obj2.department(); // Overridden method
+    }
+}
+
+
+
+
+
+

OOP/Classes/Types of Classes/Abstract Class/Constructors_In_Abstract_Class.java

@@ -0,0 +1,30 @@
+// -- Constructors in Abstract Class -- //
+
+// Abstract class with a constructor
+abstract class ParentClass {
+    protected final String P;
+
+    // Constructor
+    ParentClass(String P) {
+        this.P = P;
+    }
+}
+
+// Subclass that extends the abstract class
+public class Constructors_In_Abstract_Class extends ParentClass {
+    public void display(String str) {
+        System.out.println("Parent Name: " + P);
+        System.out.println("Message: " + str);
+    }
+
+    // Constructor for the Main class
+    Constructors_In_Abstract_Class(String P) {
+        super(P); // Call the constructor of the abstract class
+    }
+
+    // MAIN Method Class
+    public static void main(String[] args) {
+        Constructors_In_Abstract_Class obj = new Constructors_In_Abstract_Class("Parent");
+        obj.display("Hello from the Main class!");
+    }
+}

OOP/Constructors/Copy_Constructor.java

@@ -0,0 +1,39 @@
+// -- Copy Constructor -- //
+
+// Copy Constructor to create a new object as a copy of an existing object
+class Copy_Constructor {
+    int id;
+    String name;
+
+    // Parameterized Constructor to initialize the object
+    Copy_Constructor(int id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    // Copy Constructor to create a new object as a copy of an existing object
+    Copy_Constructor(Copy_Constructor obj) {
+        this.id = obj.id;
+        this.name = obj.name;
+    }
+
+    // Method to display object details
+    void display() {
+        System.out.println("ID: " + id + " | Name: " + name);
+    }
+
+    // MAIN Method
+    public static void main(String[] args) {
+        // Original Object
+        Copy_Constructor obj1 = new Copy_Constructor(1, "Alice");
+        
+        // New Object initialized using the copy constructor
+        Copy_Constructor obj2 = new Copy_Constructor(obj1); 
+
+        System.out.println("Original Object:");
+        obj1.display();
+
+        System.out.println("Copied Object:");
+        obj2.display();
+    }
+}

OOP/Constructors/Default_Constructor.java

@@ -0,0 +1,32 @@
+// -- Default Constructor -- //
+
+// Default Constructor - initializes object with default values when no parameters are provided
+class Default_Constructor {
+    int id;
+    String name;
+
+    // Default Constructor (No-argument constructor)
+    Default_Constructor() {
+        this.id = 0;
+        this.name = "Unknown";
+        System.out.println("Default Constructor called!");
+    }
+
+    // Method to display object details
+    void display() {
+        System.out.println("ID: " + id + " | Name: " + name);
+    }
+
+    // MAIN Method
+    public static void main(String[] args) {
+        // Creating an object using the default constructor
+        Default_Constructor obj1 = new Default_Constructor();
+        Default_Constructor obj2 = new Default_Constructor();
+
+        System.out.println("\nObject 1 Details:");
+        obj1.display();
+
+        System.out.println("\nObject 2 Details:");
+        obj2.display();
+    }
+}

OOP/Constructors/Parameterized_Constructor.java

@@ -0,0 +1,27 @@
+// -- Parameterized Constructor -- //
+
+// Parameterized Constructor - initializes object with provided values when parameters are passed
+class Parameterized_Constructor {
+    int id;
+    String name;
+
+    // Constructor to initialize the object
+    Parameterized_Constructor(int i, String n) {
+        id = i;
+        name = n;
+    }
+
+    // Method to display object details
+    void display() {
+        System.out.println("ID: " + id);
+        System.out.println("Name: " + name);
+    }
+
+    // MAIN Method
+    public static void main(String[] args) {
+        Parameterized_Constructor obj1 = new Parameterized_Constructor(1, "Jack");
+        Parameterized_Constructor obj2 = new Parameterized_Constructor(2, "Jill");
+        obj1.display();
+        obj2.display();
+    }
+}

OOP/Exception Handling/Array_Out_Of_Bounds_Exception.java

@@ -0,0 +1,21 @@
+// -- Array out of bounds exception using exception handling -- //
+
+public class Array_Out_Of_Bounds_Exception {
+    public static void main(String[] args) {
+        
+        try {
+            // Define an array with 3 elements (indices 0, 1, 2)
+            int[] numbers = {10, 20, 30};
+
+            // Attempting to access index 5, which doesn't exist
+            System.out.println("Accessing element at index 5: " + numbers[5]);
+
+        } catch (ArrayIndexOutOfBoundsException e) {
+            // This block runs if the error occurs
+            System.out.println("Error: The array index you requested is out of range!");
+            System.out.println("Exception message: " + e.getMessage());
+        }
+
+        System.out.println("Program execution continues smoothly...");
+    }
+}

OOP/Exception Handling/Exception_With_Multiple_try_Statements.java

@@ -0,0 +1,44 @@
+// -- Exception handling with multiple try statements -- //
+
+class Exception_With_Multiple_try_Statements {
+    public static void main(String args[]) {
+        System.out.println("Handling Exceptions with Multiple try Statements\n");
+        
+        // 1st try block
+        try {
+            // code should raise the exception
+            int a = 10;
+            int b = 0;
+            int result = a / b;
+            System.out.println("Result: " + result);
+            // 2nd try block
+            try {
+                // the code should raise an exception
+                String str = null;
+                System.out.println(str.length());
+                // 3rd try block
+                try {
+                    String num = "abc";
+                    int number = Integer.parseInt(num);
+                    System.out.println("Number: " + number);
+                }
+
+                // Catch block for 3rd try block
+                catch (NumberFormatException e) {
+                    System.out.println("NumberFormatException: 3rd try block");
+                }
+            }
+            // Catch block for 2nd try block
+            catch (NullPointerException e) {
+                System.out.println("NullPointerException: 2nd try block");
+            }
+        }
+        // Catch block for 1st try block
+        catch (ArithmeticException e) {
+            System.out.println("ArithmeticException: 1st try block");
+        }
+
+        // Program continues after handling exceptions
+        System.out.println("Program continues after handling exceptions.");
+    }
+}

OOP/Exception Handling/Multiple_Exceptions.java

@@ -0,0 +1,53 @@
+// -- Multiple Exceptions -- //
+
+public class Multiple_Exceptions {
+    public static void main(String[] args) {
+
+        System.out.println("Handling Multiple Exceptions in Java\n");
+
+        // ArithmeticException
+        try {
+            int a = 10;
+            int b = 0;
+            int result = a / b;
+            System.out.println("Result: " + result);
+        } catch (ArithmeticException e) {
+            System.out.println("ArithmeticException: Cannot divide by zero");
+        }
+
+        // NullPointerException
+        try {
+            String str = null;
+            System.out.println(str.length());
+        } catch (NullPointerException e) {
+            System.out.println("NullPointerException: String is null");
+        }
+
+        //  NumberFormatException
+        try {
+            String num = "abc";
+            int number = Integer.parseInt(num);
+            System.out.println("Number: " + number);
+        } catch (NumberFormatException e) {
+            System.out.println("NumberFormatException: Invalid number format");
+        }
+
+        // ArrayIndexOutOfBoundsException
+        try {
+            int arr[] = {1, 2, 3};
+            System.out.println(arr[5]);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("ArrayIndexOutOfBoundsException: Invalid array index");
+        }
+
+        // StringIndexOutOfBoundsException
+        try {
+            String s = "Java";
+            System.out.println(s.charAt(10));
+        } catch (StringIndexOutOfBoundsException e) {
+            System.out.println("StringIndexOutOfBoundsException: Invalid string index");
+        }
+
+        System.out.println("Program continues after handling all exceptions.");
+    }
+}

OOP/Exception Handling/throw Keyword/Null_Pointer_Exception_using_throw.java

@@ -0,0 +1,18 @@
+// -- Null Pointer Exception using throw keyword -- //
+
+public class Null_Pointer_Exception_using_throw {
+    static void checkString(String str) {
+        if (str == null) {
+            throw new NullPointerException("Error: The string is null!");
+        } else {
+            System.out.println("The string is: " + str);
+        }
+    }
+
+    // MAIN Method Class
+    public static void main(String[] args) {
+        checkString("Hello, World!"); // This will not throw an exception
+        checkString(null); // This will throw a NullPointerException
+    }
+    
+}

OOP/Exception Handling/throw Keyword/throw_Keyword

@@ -0,0 +1,17 @@
+// -- throw keyword -- //
+
+public class throw_Keyword {
+    static void checkAge(int age) {
+        if (age < 18) {
+            throw new ArithmeticException("Access denied - You must be at least 18 years old.");
+        } else {
+            System.out.println("Access granted - You are eligible for voting.");
+        }
+    }
+
+    // MAIN Method Class
+    public static void main(String[] args) {
+        checkAge(22); // This will not throw an exception
+        checkAge(14); // This will throw an exception
+    }
+}