diff --git a/README.md b/README.md
index 701c61e..f5bec88 100644
--- a/README.md
+++ b/README.md
@@ -47,7 +47,7 @@ import java.util.Scanner;
 <br>
 
 ### H_03_Inheritance in Java
-![Img](https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSyk64iUqsy8WjEdDJF-wW_f35s6YYJYfP8bg&s)
+<img src="https://mulesoftonlinelearning.home.blog/wp-content/uploads/2019/12/java-inheritance.png" alt="Sample Image" width="900" height="500" align="center">
 
 ## Message to Contributing
 Contributions are always welcome! Whether you want to add new problems, improve solutions, or enhance documentation, feel free to create a pull request.
diff --git a/src/A_01_Primitive_Data_Types.java b/src/A_01_Primitive_Data_Types.java
new file mode 100644
index 0000000..0e0f0e8
--- /dev/null
+++ b/src/A_01_Primitive_Data_Types.java
@@ -0,0 +1,36 @@
+public class A_01_Primitive_Data_Types {
+    public static void main(String[] args) {
+        // In front of every datatypes there must be a Variable (e.g: int x = 1, where x is the Variable)
+        // Integers
+        System.out.println("Integers");
+        byte b = 10;
+        short s = 20;
+        int i = -30;
+        long l = 1000;
+        System.out.println(b);
+        System.out.println(s);
+        System.out.println(i);
+        System.out.println(l);
+
+        // Floating Point
+        System.out.println("Floating Point");
+        float f = 10.54f;
+        double d = 20.12;
+        System.out.println(f);
+        System.out.println(d);
+        System.out.println(f+d);
+
+        // Character
+        System.out.println("Characters");
+        char ch = 'A';
+        System.out.println(ch);
+
+        // Boolean
+        System.out.println("Boolean");
+        boolean bool = true;
+        boolean flag = false;
+        System.out.println(bool);
+        System.out.println(flag);
+
+    }
+}
\ No newline at end of file
diff --git a/src/A_02_Identifiers_Variable_Rules.java b/src/A_02_Identifiers_Variable_Rules.java
new file mode 100644
index 0000000..e5ff412
--- /dev/null
+++ b/src/A_02_Identifiers_Variable_Rules.java
@@ -0,0 +1,34 @@
+public class A_02_Identifiers_Variable_Rules {
+    public static void main(String[] args) {
+        // keyboard tip: Alt + z = To view all the contents
+        // keyboard tip: Ctrl + / = Comment a line
+
+        // Rules:
+        // 1) Variable Names can contain letters, digits, underscores, and dollar signs
+        // 2) Variable Names must begin with a letter, $ or _ (doesn't matter Uppercase or Lowercase)
+        // 3) Variable Names best practice should start with lowercase letter, and cannot contain whitespace
+        // 4) Variable Names are case-sensitive (e.g: "Name" and "name" are different variables)
+        // 5) Reserved words like Java keywords (e.g: int, boolean, char) cannot be used as Variable Names.
+
+        int a_1$ = 10;
+        int A_1$ = 10;
+
+        // as you can see there is an error as it has a white spacing in between.
+//        int a_ 3$ = 10;
+
+        System.out.println(a_1$);
+        System.out.println(A_1$);
+
+        // this file will not run as there is an error
+//        System.out.println(a_ 3$);
+
+        // similarly there will be an error cause you cannot use reserved words as Variable Names.
+//        String int = 'Hello World!'
+//        int String = 10;
+
+        // however, why does it work for this? It's cause the string is not a data type keyword *String* is not string. Hence, it why Java is case sensitive.
+        int string = 10;
+        System.out.println(string);
+
+    }
+}
diff --git a/src/A_03_Type_Casting.java b/src/A_03_Type_Casting.java
new file mode 100644
index 0000000..39b33d2
--- /dev/null
+++ b/src/A_03_Type_Casting.java
@@ -0,0 +1,21 @@
+public class A_03_Type_Casting {
+    // Implicit Type Casting (automatic by compiler)
+    // byte -> short -> char -> int -> long -> float -> double
+
+    // Explicit Type Casting
+    // double -> float -> long -> int -> char -> short -> byte
+
+    public static void main(String[] args) {
+        // Implicit
+        int number1 = 10;
+        double number2 = number1;
+
+        System.out.println(number2);
+
+        // Explicit
+        double num1 = 20.44;
+        int num2 = (int)num1;
+
+        System.out.print(num2);
+    }
+}
diff --git a/src/A_04_Arithmetic_Operators.java b/src/A_04_Arithmetic_Operators.java
new file mode 100644
index 0000000..5d0d51a
--- /dev/null
+++ b/src/A_04_Arithmetic_Operators.java
@@ -0,0 +1,28 @@
+public class A_04_Arithmetic_Operators {
+    public static void main(String[] args) {
+        // using the '+' operator you can join 2 Variable string together as shown below
+        String msg1 = "Hello World!";
+        String msg2 = "My name is Ang Jianming.";
+
+        System.out.println(msg1 + " " + msg2);
+
+        // Arithmetic Operator (+, -, *, /, %)
+        int a = 10;
+        int b = 20;
+
+        int c = a + b; // Addition
+        System.out.println(c);
+
+        int d = a - b; // Subtraction
+        System.out.println(d);
+
+        int e = a * b; // Multiply
+        System.out.println(e);
+
+        int f = b / a; // Divide
+        System.out.println(f);
+
+        int g = a % b; // Modulus
+        System.out.println(g);
+    }
+}
diff --git a/src/A_05_User_Input.java b/src/A_05_User_Input.java
new file mode 100644
index 0000000..daccbc3
--- /dev/null
+++ b/src/A_05_User_Input.java
@@ -0,0 +1,51 @@
+/*
+* Author AngJianming
+*
+*/
+
+// it is a must to import java.util.Scanner; to access some external files which has the functionality to read input from the console. In Java this is the way to get certain functionalities which is not build in therefore, needing to import them.
+
+import java.util.Scanner;
+
+public class A_05_User_Input {
+    public static void main(String[] args) {
+        Scanner user_input = new Scanner(System.in);
+        System.out.print("Enter your name: ");
+
+        String name = user_input.nextLine();
+        System.out.println("My name is " + name);
+
+
+        // Example Calculator
+        Scanner scanner = new Scanner(System.in);
+
+        // Prompt the user to enter the first number
+        System.out.print("Enter the first integer: ");
+        int x = scanner.nextInt();
+
+        // Prompt the user to enter the second number
+        System.out.print("Enter the second integer: ");
+        int y = scanner.nextInt();
+
+        // Perform arithmetic operations
+        int sum = x + y;           // Addition
+        int difference = x - y;    // Subtraction
+        int product = x * y;       // Multiplication
+
+        // To handle division by zero, you can check if b == 0
+        // but for simplicity, we assume b != 0 in this example
+        double quotient = (double) x / y;      // Division
+        int modulus = x % y;       // Modulus (remainder)
+
+        // Print the results
+        System.out.println("\n--- Results ---");
+        System.out.println(x + " + " + y + " = " + sum);
+        System.out.println(x + " - " + y + " = " + difference);
+        System.out.println(x + " × " + y + " = " + product);
+        System.out.println(x + " ÷ " + y + " = " + quotient);
+        System.out.println(x + " % " + y + " = " +"R"+ modulus);
+
+        // Close the scanner
+        scanner.close();
+    }
+}
diff --git a/src/B_01_Assignment_Operators.java b/src/B_01_Assignment_Operators.java
new file mode 100644
index 0000000..a33eb7c
--- /dev/null
+++ b/src/B_01_Assignment_Operators.java
@@ -0,0 +1,24 @@
+public class B_01_Assignment_Operators {
+    public static void main(String[] args) {
+        // Assignment Operators (=, +=, -=, /=, *=)
+
+        int a = 10;
+        int b = 5;
+
+        a += b; // meaning a = a+b or a = 10+b
+        System.out.println(a);
+        // a = 15 this should be the expected result
+
+        a -= 2; // meaning a = a-2;
+        System.out.println(a);
+
+        a /= 2; // meaning a = a/2
+        System.out.println(a);
+
+        a *= 2; // meaning a = a*2
+        System.out.println(a);
+
+        a %= 5; // meaning a = a%5
+        System.out.println(a);
+    }
+}
diff --git a/src/B_02_Relational_Operators.java b/src/B_02_Relational_Operators.java
new file mode 100644
index 0000000..6cf6b6f
--- /dev/null
+++ b/src/B_02_Relational_Operators.java
@@ -0,0 +1,28 @@
+public class B_02_Relational_Operators {
+    // ture, false (boolean)
+    // Relational Operators ( ==, !=, <, >, <=, >=)
+
+    public static void main(String[] args) {
+        int a = 10;
+        int b = 15;
+
+        System.out.println(a == b); // if a is equal to b true, otherwise false
+        System.out.println(a != b); // 10 is not equal to 15 true, otherwise false
+        System.out.println(a < b); // 10 is less than 15 true, otherwise false
+        System.out.println(b > a); // 10 is more than 15 true, otherwise false
+
+        System.out.println(a <= b); // 10 is less or equal to 15 true, otherwise false
+
+        System.out.println(b >= a); // 10 is more than or equal to 15 true, otherwise false
+
+//        10 is less than, or equal to 10 true, otherwise false.
+        System.out.println(10 < 10); // is false because it cannot 10 cannot be less than 10
+        System.out.println(10 <= 10); // is true because it can be less than or EQUAL to 10 (Keyword 'equal')
+
+        System.out.println(10 > 10); // is false because it cannot 10 cannot be more than 10
+        System.out.println(10 >= 10); // is true because it can be more than or EQUAL to 10 (Keyword 'equal')
+
+
+
+    }
+}
diff --git a/src/B_03_Logical_Operators.java b/src/B_03_Logical_Operators.java
new file mode 100644
index 0000000..fc423ef
--- /dev/null
+++ b/src/B_03_Logical_Operators.java
@@ -0,0 +1,49 @@
+import java.security.spec.RSAOtherPrimeInfo;
+
+public class B_03_Logical_Operators {
+    public static void main(String[] args) {
+        // Logical Operator ( &&, ||, !)
+
+
+        // AND (&&) - is all condition is true then return true.
+//         true && true = true
+//         true && false = false
+//         false && true = false
+//         false && false = false
+        System.out.println(10>5);
+        System.out.println(20>14);
+        System.out.println((10>5) && (20>14));
+
+
+        // OR (||) - if any condition is true, then return true.
+//         true || true = true
+//         true || false = true
+//         false || true = true
+//         false || false = false
+        System.out.println((10>5) || (20<14));
+        System.out.println((10<5) || (20<14) || (10<2) || (1000<999) || (1<0));
+        // false, false, false, false, true. Hence, it's true still.
+
+        System.out.println((10<5) || (20<14) || (10<2) || (1000<999) || true);
+        // If at the end is true then all is true.
+
+        System.out.println((10<5) || (20<14) || (10<2) || (1000<999) || false);
+        // If at the end is all is false then false.
+
+
+        // NOT(!) - vice-versa
+//        true = false
+//        false = true
+
+        System.out.println(!(100>99)); // Not true. Therefore, false
+
+        System.out.println(!(100>99) && (2>0));
+        // !true AND true = false
+
+        System.out.println(!(20>20) || !(10<=20));
+        // !false OR !true = true
+
+
+
+    }
+}
diff --git a/src/B_04_Ternary_Operator.java b/src/B_04_Ternary_Operator.java
new file mode 100644
index 0000000..7bcd75a
--- /dev/null
+++ b/src/B_04_Ternary_Operator.java
@@ -0,0 +1,26 @@
+public class B_04_Ternary_Operator {
+    public static void main(String[] args) {
+        // Ternary Operator ( ?: )
+        // condition ? true : false
+
+        int n1 = 10;
+        int n2 = 20;
+
+//        if (n2 is greater than n1) then n2 is assigned to variable greaterNum.
+
+        /*
+        * So the expression (n2 > n1) ? n2 : n1 means:
+        * - If n2 > n1 is true, then use n2.
+        * - Otherwise, use n1.
+        */
+        int greaterNum = (n2 > n1) ? n2 : n1;
+        System.out.println(greaterNum);
+
+        int n3 = 100;
+        int n4 = 20;
+
+        int greaterNum2 = (n3 > n4) ? n3 : n4;
+        System.out.println(greaterNum2);
+
+    }
+}
diff --git a/src/B_05_Increment_Operator.java b/src/B_05_Increment_Operator.java
new file mode 100644
index 0000000..b92392f
--- /dev/null
+++ b/src/B_05_Increment_Operator.java
@@ -0,0 +1,28 @@
+public class B_05_Increment_Operator {
+    public static void main(String[] args) {
+        // Increment Operator (++)
+
+        int a = 10;
+//        a++; // post-increment (a = a+1)
+//        ++a; // pre-increment (a = 1+a)
+
+        System.out.println(a);
+
+        a++;
+        a++;
+        System.out.println(a++);
+
+        ++a;
+        ++a;
+        System.out.println(++a);
+
+        System.out.println(a++);
+
+        System.out.println(++a);
+        // the reason why it's 18 insted of 17 is cause a++ will print out the current value 16 first, only after that it will add up to +1. Hence, the output for ++a would be 17+1 = 18;
+
+
+
+
+    }
+}
diff --git a/src/B_06_Decrement_Operator.java b/src/B_06_Decrement_Operator.java
new file mode 100644
index 0000000..fbe5bea
--- /dev/null
+++ b/src/B_06_Decrement_Operator.java
@@ -0,0 +1,16 @@
+public class B_06_Decrement_Operator {
+    public static void main(String[] args) {
+        // Decrement Operator (--)
+
+        int a = 20;
+//        a--; // post
+//        --a; // post
+
+        a--; // 19
+        System.out.println(a--); // 19 -> 18
+        System.out.println(--a); // 17
+
+        // Similar like increment operator it has to print out which ever variable comes first for this example 'a' comes first before the '++' so it will println 19 first but will minus it number afterwards.
+
+    }
+}
diff --git a/src/C_01_for_Loop.java b/src/C_01_for_Loop.java
new file mode 100644
index 0000000..c01e835
--- /dev/null
+++ b/src/C_01_for_Loop.java
@@ -0,0 +1,23 @@
+public class C_01_for_Loop {
+    public static void main(String[] args) {
+        // for loop
+
+//        for(initial variable, condition, inc/dec from initial value) {
+//            System.out.println(initial variable)
+//        }
+
+        int i; // declare value
+        for(i=1; i<=5; i++) {
+            System.out.println(i);
+        } // {} this is a block condition
+
+        System.out.println("---After the for Loop---");
+        System.out.println(i);
+
+
+        // declared value can also be inside initial value
+        for(int b=1; b<=5; b++) {
+            System.out.println(b);
+        }
+    }
+}
diff --git a/src/C_02_while_Loop.java b/src/C_02_while_Loop.java
new file mode 100644
index 0000000..c37ece9
--- /dev/null
+++ b/src/C_02_while_Loop.java
@@ -0,0 +1,26 @@
+public class C_02_while_Loop {
+    public static void main(String[] args) {
+        //while loop
+
+//        int initial variable=0; //declare variable first
+//        while (condition) {
+//            inc/dec
+//        }
+
+        int i = 1; // declare value
+        while(i < 10) {
+            System.out.println(i);
+            i++;
+        }
+        // it will run, 1,2,3,4,5,6,7,8,9 but not 10 as we know i ≠ less than 10, as shown above
+
+        int j = 10; // declare value
+        while (j >= 1) {
+            System.out.println(j);
+            j--;
+        }
+        // it will run, 10,9,8,7,6,5,4,3,2,1 until 1 cause it's >= 1 | less than equal to 1
+        System.out.println("---j value after the Loop---");
+        System.out.println(j); // 0
+    }
+}
diff --git a/src/C_03_do_while_Loop.java b/src/C_03_do_while_Loop.java
new file mode 100644
index 0000000..582807e
--- /dev/null
+++ b/src/C_03_do_while_Loop.java
@@ -0,0 +1,39 @@
+public class C_03_do_while_Loop {
+    public static void main(String[] args) {
+        // do while loop
+
+//        initial variable
+//        do {
+//            inc/dec
+//        } while (condition);
+
+        int a = 1;
+        do {
+            System.out.println(a);
+            a++;
+        } while(a<=10);
+        // 1,2,3,4,5,6,7,8,9,10 cause it's less than and EQUAL to 10
+
+
+
+        int i = 1;
+        do {
+            System.out.println(i);
+            i = i+2;
+        } while(i<=10);
+        // 1,3,5,7,9 it starts with 1 as declared value, then move on with a +2 until <=10
+        // in order to find out whether 'i' have the value of 11 after the loop or not we can use
+        System.out.println("--after the do while Loop--");
+        System.out.println(i); // which indeed does have the value of 11 after the loop
+
+
+
+        int b = 10;
+        do {
+            System.out.println(b);
+        } while (b<5);
+        // 10<5, false cause the condition is executed before the block statement which is (b<5); in this case.
+
+
+    }
+}
diff --git a/src/C_04_break_Loop_Statement.java b/src/C_04_break_Loop_Statement.java
new file mode 100644
index 0000000..b195ddf
--- /dev/null
+++ b/src/C_04_break_Loop_Statement.java
@@ -0,0 +1,27 @@
+public class C_04_break_Loop_Statement {
+    public static void main(String[] args) {
+        // break statement
+
+        for (int i=1; i<=10; i++) {
+//            System.out.println(i); // 1,2,3,4,5,6,7
+            // go out of the block if value is greater than and equal to 6.
+            if (i > 6) {
+                break;
+            }// this {} is the block remember
+
+            System.out.println(i);
+            // if println outside of block then it will only be until 6 cause the condition is aiming for after the block not before.
+        }
+
+        System.out.println("----------");
+
+        for (int j=1; j<=10; j++) {
+            if (j == 4) {
+                break;
+                // j == 4 means the number of figures, usually '==' | '>=' is the same figure but > only is not. And there cannot be '<' cause on the very first iteration, j = 1. The condition j <= 4 is true, so the break statement is immediately executed.
+                // This causes the for loop to terminate right away, without printing anything.
+            }
+                System.out.println(3+j); // 3+1 = 4, until the condition j == 4th figure then stop. So the output will only be until 3th figure.
+        }
+    }
+}
diff --git a/src/C_05_continue_Loop_Statement.java b/src/C_05_continue_Loop_Statement.java
new file mode 100644
index 0000000..59bdf64
--- /dev/null
+++ b/src/C_05_continue_Loop_Statement.java
@@ -0,0 +1,38 @@
+public class C_05_continue_Loop_Statement {
+    public static void main(String[] args) {
+        // continue statement
+
+        for (int i=1; i<=10; i++) {
+            if(i == 4) {
+                continue; // jump out the block, run it again
+            }
+        System.out.println(i); // 1,2,3,5,6,7,8,9,10 there is no 4 because the condition is met.
+
+        } // make sure the System.out.println(i); is inside of the for loop
+
+        System.out.println("------");
+
+        for (int i=1; i<=10; i++) {
+            if(i == 4 || i == 7) // this is the same as below
+                {
+                continue;
+            }
+            System.out.println(i); // 4 and 7 will not be shown.
+
+        }
+
+        System.out.println("------");
+
+        for (int i=1; i<=10; i++) {
+            if(i == 4) // same as above either way also works but the above is better and faster.
+            {
+                continue;
+            }
+            if(i == 7) {
+                continue;
+            }
+            System.out.println(i);
+
+        }
+    } // the 'if' is based of true || false
+}
diff --git a/src/D_01_if_else_Statement.java b/src/D_01_if_else_Statement.java
new file mode 100644
index 0000000..4dd7b65
--- /dev/null
+++ b/src/D_01_if_else_Statement.java
@@ -0,0 +1,37 @@
+public class D_01_if_else_Statement {
+    public static void main(String[] args) {
+        // if else statement
+
+//        if (condition) {
+//
+//        } else {
+//
+//        }
+
+
+        int a = 10;
+        if (a > 0) { // 10 is greater than 0, then if statement will run
+            System.out.println("a is greater");
+        }
+
+        if (a > 11) { // 10 is greater than 11, then if statement will run. If it is false then it will not run.
+            System.out.println("a is less than 11");
+        }
+
+        if (true) { // 10 is greater than 11, then if statement will run. If it is false then it will not run.
+            System.out.println("a is true");
+        }
+
+        // test around with these condition with Arithmetic Operations
+        int x = 20;
+        int y = 30;
+
+        if (!(x < y)) {
+            System.out.println(x);
+        } else {
+            System.out.println(y);
+        }
+
+
+    }
+}
diff --git a/src/D_02_if_elseif_else_Statement.java b/src/D_02_if_elseif_else_Statement.java
new file mode 100644
index 0000000..929b34f
--- /dev/null
+++ b/src/D_02_if_elseif_else_Statement.java
@@ -0,0 +1,31 @@
+public class D_02_if_elseif_else_Statement {
+    public static void main(String[] args) {
+        // if elseif else statement
+
+//        if (condition) {
+//
+//        } else if (condition) {
+//
+//        } else {
+//
+//        }
+
+
+        // example on how to use if elseif else, else if can be used as many times as you need.
+        int a = 5;
+        int b = 12;
+        int c = 10;
+
+        if (a < b) {
+            System.out.println(a + " is less than " + b);
+
+        } else if (c > b) {
+            System.out.println(c + " is greater than " + b);
+
+        } else {
+            int result = a+b;
+            System.out.println("The result is: " + result);
+        }
+
+    }
+}
diff --git a/src/D_03_if_else_Ladder.java b/src/D_03_if_else_Ladder.java
new file mode 100644
index 0000000..5b40e3e
--- /dev/null
+++ b/src/D_03_if_else_Ladder.java
@@ -0,0 +1,25 @@
+public class D_03_if_else_Ladder {
+    public static void main(String[] args) {
+        // if else Ladder
+
+        int a = 10;
+
+        if (a==10) {
+            System.out.println("10 is present in a.");
+
+        } else if (a==20) {
+            System.out.println("20 is present in a.");
+
+        } else if (a==30) {
+            System.out.println("30 is present in a.");
+
+        } else if (a==40) {
+            System.out.println("40 is present in a.");
+
+        } else {
+            System.out.println("Wrong Input");
+        }
+
+
+    }
+}
diff --git a/src/D_04_Nested_if_else.java b/src/D_04_Nested_if_else.java
new file mode 100644
index 0000000..b1b733f
--- /dev/null
+++ b/src/D_04_Nested_if_else.java
@@ -0,0 +1,53 @@
+public class D_04_Nested_if_else {
+    public static void main(String[] args) {
+        // nested if else
+
+//        if (condition1) {
+//            // Code to execute when condition1 is true
+//
+//            if (condition2) {
+//                // Code to execute when condition1 is true AND condition2 is true
+//            } else {
+//                // Code to execute when condition1 is true AND condition2 is false
+//            }
+//        } else {
+//            // Code to execute when condition1 is false
+//
+//            if (condition3) {
+//                // Code to execute when condition1 is false AND condition3 is true
+//            } else {
+//                // Code to execute when condition1 is false AND condition3 is false
+//            }
+//        }
+
+
+        // Example
+        int number = 20; // test case
+        if (number > 0) {
+            System.out.println(number + " is positive.");
+
+            if (number > 10) {
+                System.out.println(number + " is also greater than 10.");
+            } else {
+                System.out.println(number + " is not greater than 10.");
+            }
+
+        } else {
+            System.out.println(number + " is not positive.");
+
+            if (number == 0) {
+                System.out.println("Actually, it's 0.");
+            } else {
+                System.out.println("And it's negative.");
+            }
+        }
+
+        //- Outer if checks if number is greater than 0.
+
+        //- If true, it prints a message and then nested if checks if number is greater than 10.
+
+        //- If false, the else part prints that the number is not positive, and another nested if-else checks whether number is exactly 0 or negative.
+
+
+    }
+}
diff --git a/src/D_05_switch_Statement.java b/src/D_05_switch_Statement.java
new file mode 100644
index 0000000..3687bbe
--- /dev/null
+++ b/src/D_05_switch_Statement.java
@@ -0,0 +1,62 @@
+public class D_05_switch_Statement {
+    public static void main(String[] args) {
+        // switch Statement
+
+//        switch (expression) {
+//            case value1:
+//                // Code block when expression == value1
+//                break; // optional, but often used to prevent "fall-through"
+//
+//            case value2:
+//                // Code block when expression == value2
+//                break;
+
+//            // You can have as many cases as needed.
+//            default:
+//                // Code block if expression doesn't match any case
+//        }
+
+//        expression: A value or variable that the switch will evaluate. This expression must result in a value of type byte, short, char, int, String, or an enum (and their corresponding wrapper classes in newer Java versions).
+
+//        case value: Each case compares the expression against a constant. If the expression matches this constant, the code for that case executes.
+
+//        break: The break statement prevents "fall-through", meaning that the program will exit the switch block once that case executes. Without a break, execution would continue to subsequent cases even if they don't match.
+
+//        default: The optional default case runs if none of the specified cases match the expression. It’s like the else in an if-else-if structure.
+
+
+        // Example
+        int day = 4;
+        String dayName;
+
+        switch (day) {
+            case 1:
+                dayName = "Monday";
+                break;
+            case 2:
+                dayName = "Tuesday";
+                break;
+            case 3:
+                dayName = "Wednesday";
+                break;
+            case 4:
+                dayName = "Thursday";
+                break;
+            case 5:
+                dayName = "Friday";
+                break;
+            case 6:
+                dayName = "Saturday";
+                break;
+            case 7:
+                dayName = "Sunday";
+                break;
+            default:
+                dayName = "Invalid day";
+                break;
+        }
+
+        System.out.println("The day is: " + dayName);
+
+    }
+}
diff --git a/src/E_01_Function_Types.java b/src/E_01_Function_Types.java
new file mode 100644
index 0000000..356fd64
--- /dev/null
+++ b/src/E_01_Function_Types.java
@@ -0,0 +1,34 @@
+public class E_01_Function_Types {
+    public static void main(String[] args) {
+        // Functions
+        // it is not possible to add a function in a main function
+//        Hence, it is added out of the main function
+
+        nameFunction(); // call the method/function
+
+        // if without 'static void' only 'void' it will have an error calling.
+
+        printSum();
+    }
+
+    // data type(return type), name
+    static void nameFunction() {
+        // write your code here
+        System.out.println("Hello World! I'm Ang Jianming");
+    }
+
+    static void printSum() {
+        int a = 10;
+        int b = 20;
+        System.out.println(a + b);
+    }
+
+
+    /* There is 4 types of Functions
+    - 1. No return type with No argument
+    - 2. Return type with No argument
+    - 3. No Return type with argument
+    - 4. Return type with argument
+     */
+}
+
diff --git a/src/E_02_Type1_No_Return_Type_with_No_Argument.java b/src/E_02_Type1_No_Return_Type_with_No_Argument.java
new file mode 100644
index 0000000..00c189f
--- /dev/null
+++ b/src/E_02_Type1_No_Return_Type_with_No_Argument.java
@@ -0,0 +1,15 @@
+public class E_02_Type1_No_Return_Type_with_No_Argument {
+    // Type 1 - No Return Type with No Argument
+
+    static void addTwoNumber(){
+        // void - null, it will return nothing
+
+        int a = 5;
+        int b = 10;
+        System.out.println(a + b);
+    }
+
+    public static void main(String[] args) {
+        addTwoNumber();
+    }
+}
diff --git a/src/E_03_Type2_Return_Type_with_No_Argument.java b/src/E_03_Type2_Return_Type_with_No_Argument.java
new file mode 100644
index 0000000..91ad66b
--- /dev/null
+++ b/src/E_03_Type2_Return_Type_with_No_Argument.java
@@ -0,0 +1,32 @@
+public class E_03_Type2_Return_Type_with_No_Argument {
+    // Type 2 - Return Type with No Argument
+
+    static int subtract(){
+        int a = 20;
+        int b = 10;
+        int result = a - b;
+
+        return result;
+    }
+
+    static String getMyName(){
+        // String name = "Ang Jianming";
+        // return name; these are same as return "something"
+
+        return "Ang Jianming";
+
+//        System.out.println() this is not need if there is a return type.
+
+    }
+
+    public static void main(String[] args) {
+        int res = subtract(); // it will return value as int
+
+        System.out.println(res); // value 10
+        // or, both is fine chose which is more simple to your preferences
+        System.out.println(subtract()); // value 10
+
+
+        System.out.println(getMyName());
+    }
+}
diff --git a/src/E_04_Type3_No_Return_Type_with_Argument.java b/src/E_04_Type3_No_Return_Type_with_Argument.java
new file mode 100644
index 0000000..da0e644
--- /dev/null
+++ b/src/E_04_Type3_No_Return_Type_with_Argument.java
@@ -0,0 +1,21 @@
+public class E_04_Type3_No_Return_Type_with_Argument {
+    // Type 3 - No Return Type with Argument
+
+    static void printName (String name) { //  (data type, variable)
+        System.out.println(name);
+    }
+
+    static void sumOfThreeNumber (int n1, int n2, int n3) {
+        int result = n1 + n2 + n3;
+        System.out.println(result);
+    }
+
+    public static void main(String[] args) {
+        printName("Ang Jianming");
+
+        // call the function
+        sumOfThreeNumber(10, 20, 30);
+
+
+    }
+}
diff --git a/src/E_05_Type4_Return_Type_with_Argument.java b/src/E_05_Type4_Return_Type_with_Argument.java
new file mode 100644
index 0000000..ec85475
--- /dev/null
+++ b/src/E_05_Type4_Return_Type_with_Argument.java
@@ -0,0 +1,22 @@
+public class E_05_Type4_Return_Type_with_Argument {
+    // Type 4 - Return Type with Argument
+
+    static int multiplicationOfTwoNumbers(int a, int b) {
+        int result = a * b;
+        return result; // return value
+    }
+
+    // it's up to the developer whether they would like to use double as a data type of other.
+    static double addFourNumbers(double n1, double n2, double n3, double n4) {
+        return (int) (n1 + n2 + n3 + n4); // return type
+    }
+
+    public static void main(String[] args) {
+        // call the func
+        System.out.println(multiplicationOfTwoNumbers(2, 5));
+
+        System.out.println(addFourNumbers(1.0, 2.0, 3.3, 4.7)); // 11.0
+
+        // this shows that the number is added at the main function not in the parent function.
+    }
+}
diff --git a/src/F_01_Arrays.java b/src/F_01_Arrays.java
new file mode 100644
index 0000000..d7e54a4
--- /dev/null
+++ b/src/F_01_Arrays.java
@@ -0,0 +1,35 @@
+public class F_01_Arrays {
+    // What is an Array & Why we use Array?
+
+    public static void main(String[] args) {
+//        the array are stored in box with how any amount of elements
+//        |40|55|63|17|22|68|89|97|89|
+
+        String[] toys = new String[5];
+
+/*        In Java, an array is like that row of cubbyholes:
+
+        - It can store many pieces of the same type of information (like a list of numbers or a list of words).
+
+        - Each spot in the array has a special number called an index that tells you its position (just like how each cubbyhole has a label).
+*/
+//        Example with toys:
+//        Think of an array like a toy box with 5 spaces:
+//        Space 0: Teddy Bear
+//        Space 1: Car
+//        Space 2: Doll
+//        Space 3: Ball
+//        Space 4: Robot
+
+        toys[0] = "Teddy Bear";
+        toys[1] = "Car";
+        toys[2] = "Doll";
+        toys[3] = "Ball";
+        toys[4] = "Robot";
+
+        System.out.println(toys[2]);
+
+
+
+    }
+}
diff --git a/src/F_02_Create_an_Array.java b/src/F_02_Create_an_Array.java
new file mode 100644
index 0000000..915d206
--- /dev/null
+++ b/src/F_02_Create_an_Array.java
@@ -0,0 +1,31 @@
+import javax.sound.midi.SysexMessage;
+
+public class F_02_Create_an_Array {
+    // Create an Array
+    public static void main(String[] args) {
+        // 1st way
+        int [] arr = new int[] {10, 20,30,40,50,60};
+        System.out.println(arr); // there will have a wrong outcome [I@7b23ec81
+        System.out.println(arr.length); // this println the number of elements in a array there is 6 here.
+        System.out.println(arr[0]); // this shows the which element you want to println.
+
+        // 2nd way
+        int[] arr2 = new int[3];
+        arr2[0] = 10;
+        arr2[1] = 20;
+        arr2[2] = 30;
+        System.out.println(arr2[0]);
+        System.out.println(arr2[1]);
+        System.out.println(arr2[2]);
+
+        // 3rd way
+        int[] arr3;
+        arr3 = new int[3];
+        arr3[0] = 100;
+        arr3[1] = 200;
+        System.out.println(arr3[0]);
+        System.out.println(arr3[1]);
+
+
+    }
+}
diff --git a/src/F_03_Print_Array_using_Loops.java b/src/F_03_Print_Array_using_Loops.java
new file mode 100644
index 0000000..72b270d
--- /dev/null
+++ b/src/F_03_Print_Array_using_Loops.java
@@ -0,0 +1,25 @@
+public class F_03_Print_Array_using_Loops {
+    //println Array using Loop
+    public static void main(String[] args) {
+        int[] arr = new int[] {10,20,30,40,50,60,70};
+        System.out.println(arr);
+
+        // for loop, or can use while loop
+        for(int i = 0; i < arr.length; i++) {
+            System.out.println(arr[i]); // 10,20,30,40,50,60,70, after will not go beyond 80 cause it's i++ the 'i' comes first before the '++'
+
+        }
+        System.out.println("------");
+        // 7-2 = 5 so only until 50
+        for(int i = 0; i < arr.length-2; i++) {
+            System.out.println(arr[i]); // 10,20,30,40,50 after will not go beyond 60 cause it's i++ the 'i' comes first before the '++'
+
+        }
+        System.out.println("------");
+        int j=0;
+        while(j<arr.length){
+            System.out.println(arr[j]);
+            j++;
+        }
+    }
+}
diff --git a/src/F_04_Print_Array_using_For_Each_Loops.java b/src/F_04_Print_Array_using_For_Each_Loops.java
new file mode 100644
index 0000000..7a7604d
--- /dev/null
+++ b/src/F_04_Print_Array_using_For_Each_Loops.java
@@ -0,0 +1,23 @@
+public class F_04_Print_Array_using_For_Each_Loops {
+    // Print Array using For Each Loop
+    public static void main(String[] args) {
+        int [] arr = new int[]{1,2,3,4,5};
+        for(int element : arr) {
+            System.out.println(element); // it will read the element one by one
+        }
+
+        System.out.println("------");
+
+        String[] fruits = new String[] {"Apple", "Banana", "Orange", "Pear"};
+        for(String ele : fruits) {
+
+            if(ele == "Banana") {
+                break;
+            }
+            // : Reads as "in" or "for each element in". It tells Java to go through each item in the array.
+            // The loop will start and only look through until the 'if' statement which in this case is Banana, hence it only print an output 'Apple' if it was Orange instead, the output will be 'Apple' and 'Banana'. And if it's Pear so on...
+
+            System.out.println(ele);
+        }
+    }
+}
diff --git a/src/F_05_2Dimensional_Arrays.java b/src/F_05_2Dimensional_Arrays.java
new file mode 100644
index 0000000..221fa19
--- /dev/null
+++ b/src/F_05_2Dimensional_Arrays.java
@@ -0,0 +1,25 @@
+public class F_05_2Dimensional_Arrays {
+    // 2-Dimensional Arrays
+    // ---
+    // ---
+
+    public static void main(String[] args) {
+        // create 2-d array
+        int[][] arr = new int[][]{
+                {10, 20, 30}, // 0
+                {70, 80, 90}, // 1
+        };
+
+        // print
+        /* Array is 2 following the x-axis or columns */
+        for(int i=0; i<arr.length; i++) {
+            /* Length is 3 following the y-axis or rows*/
+            for(int j=0; j<arr[i].length; j++) {
+                System.out.println(arr[i][j]);
+            }
+        }
+        // arr[access the num of columns][access the num of rows]
+        System.out.println("------");
+        System.out.println(arr[1][1]); // example arr[1][1] is 80, arr[1][2] is 90, arr[0][1] is 20, etc etc...
+    }
+}
diff --git a/src/G_01_String.java b/src/G_01_String.java
new file mode 100644
index 0000000..174d664
--- /dev/null
+++ b/src/G_01_String.java
@@ -0,0 +1,13 @@
+public class G_01_String {
+    // What is the String & Why we use String?
+
+    public static void main(String[] args) {
+        // 1st way
+        String str = "Ang Jianming";
+
+        // 2nd way
+        String msg = new String("Hello World!");
+        System.out.println(str);
+        System.out.println(msg);
+    }
+}
diff --git a/src/G_02_charAt_and_length_method.java b/src/G_02_charAt_and_length_method.java
new file mode 100644
index 0000000..ff38800
--- /dev/null
+++ b/src/G_02_charAt_and_length_method.java
@@ -0,0 +1,22 @@
+public class G_02_charAt_and_length_method {
+    // String charAt() and length()
+
+    public static void main(String[] args) {
+        String str = "Hello";
+
+        System.out.println(str.charAt(4)); // It should print 'o'
+        System.out.println("-----");
+
+        for(int i=0; i<str.length(); i++) {
+            System.out.println(str.charAt(i));
+        }
+        /*
+        Output:
+        H
+        e
+        l
+        l
+        o
+         */
+    }
+}
diff --git a/src/G_03_String_Concatenation.java b/src/G_03_String_Concatenation.java
new file mode 100644
index 0000000..065a722
--- /dev/null
+++ b/src/G_03_String_Concatenation.java
@@ -0,0 +1,24 @@
+public class G_03_String_Concatenation {
+    // String Concatenation
+
+    public static void main(String[] args) {
+        // 1st way using '+'
+        String str1 = "Hello";
+        String str2 = "World";
+        System.out.println(str1 + " " + str2);
+
+        // 2nd way using concat
+        String result = str1.concat(" " + str2); // for two strings
+        System.out.println(result);
+
+        // 3rd way using format
+        String first = "Hello";
+        String second = "World";
+        String combined = String.format("%s, %s!", first, second);
+        System.out.println(combined);
+
+        // 4th way using join
+        String c = String.join(", ", "Hello", "World");
+        System.out.println(c);
+    }
+}
diff --git a/src/G_04_Compare_Two_Strings.java b/src/G_04_Compare_Two_Strings.java
new file mode 100644
index 0000000..3599fc6
--- /dev/null
+++ b/src/G_04_Compare_Two_Strings.java
@@ -0,0 +1,22 @@
+public class G_04_Compare_Two_Strings {
+    // Compare Two Strings
+
+    public static void main(String[] args) {
+        String str1 = "Hello";
+        String str2 = "World";
+
+        // 1st way, the string must be same even in upper case or lower case will count as not equal.
+        if(str1 == str2){
+            System.out.println("Strings are equal");
+        } else {
+            System.out.println("Strings are not equal");
+        }
+
+        // 2nd way using the function compareTo
+        if(str1.compareTo(str2) == 0) {
+            System.out.println("Strings are equal");
+        } else {
+            System.out.println("Strings are not equal");
+        }
+    }
+}
diff --git a/src/G_05_String_substring_method.java b/src/G_05_String_substring_method.java
new file mode 100644
index 0000000..fc503ad
--- /dev/null
+++ b/src/G_05_String_substring_method.java
@@ -0,0 +1,13 @@
+public class G_05_String_substring_method {
+    public static void main(String[] args) {
+        String str1 = "Hello World!";
+
+        // begin index = include
+        // end index = exclude (n-1)
+
+        System.out.println(str1.substring(0,2)); // Output: He
+        System.out.println(str1.substring(2));
+    }
+
+
+}
diff --git a/src/G_06_String_indexOf_method.java b/src/G_06_String_indexOf_method.java
new file mode 100644
index 0000000..fbae931
--- /dev/null
+++ b/src/G_06_String_indexOf_method.java
@@ -0,0 +1,23 @@
+public class G_06_String_indexOf_method {
+    // String indexOf()
+
+    public static void main(String[] args) {
+
+        String s1 = "my name is Ang Jianming";
+
+        int index = s1.indexOf("name");
+        System.out.println(index);
+        // It will check where the "name" string will start from, the string "m","y" & " " is 0,1,2. And "n" in "name" starts at the index 3. Hence, output: 3
+
+        int index2 = s1.indexOf("e");
+        System.out.println(index2); //Output: 6 as there is only 1 letter 'e' in the entire sentence, and the 'e' is index 6
+
+        int index3 = s1.indexOf('i', 10);
+        System.out.println(index3); //Output: 16 cause we want whats the next index which is 'i' after the 10th index which will the after 's' and is the empty whitespace " ". Hence, the answer is 16 as the next 'i' in Jianming appears.
+
+        int index4 = s1.indexOf("my", 3);
+        System.out.println(index4); // Output: -1 cause it goes backwards to get to the correct index.
+
+
+    }
+}
diff --git a/src/G_07_String_replace_method.java b/src/G_07_String_replace_method.java
new file mode 100644
index 0000000..469104a
--- /dev/null
+++ b/src/G_07_String_replace_method.java
@@ -0,0 +1,14 @@
+public class G_07_String_replace_method {
+    // String replace()
+
+    public static void main(String[] args) {
+        String s1 = "Hello Hello Hello"; //H - C, Cello
+
+        // using .replace method you can change the String for single value
+        String newS1 = s1.replace('H', 'C');
+        String newS2 = newS1.replace('l', 'p');
+
+        System.out.println(newS1); // Output: Cello
+        System.out.println(newS2); // Output: Ceppo
+    }
+}
diff --git a/src/H_01_OOPS_Class.java b/src/H_01_OOPS_Class.java
new file mode 100644
index 0000000..f081cfd
--- /dev/null
+++ b/src/H_01_OOPS_Class.java
@@ -0,0 +1,26 @@
+public class H_01_OOPS_Class {
+    // What is Class & Why we use class?
+    // data, method - object
+
+    // 1000 students data - 6 marks
+    // 6000
+
+/*
+In Java, a class is like a blueprint or a template that defines the structure and behavior (data and methods) of objects. It serves as a fundamental building block in object-oriented programming (OOP).
+
+What is a Class?
+- A class defines attributes (often called fields or properties) and behaviors (methods or functions) that its objects (instances) will have.
+- It does not represent an actual object by itself, but rather describes what an object created from the class will contain and how it will behave.
+ */
+
+
+    // Attributes (fields) of the class
+    String name;
+    int age;
+
+    // Behavior (method) of the class
+    void bark() {
+        System.out.println(name + " says: Woof!");
+    }
+
+}
diff --git a/src/H_02_Create_Class.java b/src/H_02_Create_Class.java
new file mode 100644
index 0000000..3355a1b
--- /dev/null
+++ b/src/H_02_Create_Class.java
@@ -0,0 +1,27 @@
+public class H_02_Create_Class {
+    // for short cut type: psvm
+    public static void main(String[] args) {
+        // this is how we can access the class Hello{}, by using the hello object as shown below we can access the data members and member function of the class Hello{}.
+        Hello hello = new Hello(); // Access new Hello class, latest version.
+        hello.printMsg();
+
+        System.out.println(hello.a); // the '.' is used to access the methods or class or joined
+        System.out.println(hello.b);
+
+        Hello hello2 = new Hello(); // doesn't matter how many object you can make
+        hello2.printMsg();
+
+
+    }
+}
+
+    // Create Your first class
+class Hello {
+    // data members(variable), methods(function)
+    int a = 10;
+    int b = 20;
+
+    void printMsg() {
+        System.out.println("My name is Hello Class.");
+    }
+}
diff --git a/src/H_03_Inheritance.java b/src/H_03_Inheritance.java
new file mode 100644
index 0000000..1368644
--- /dev/null
+++ b/src/H_03_Inheritance.java
@@ -0,0 +1,22 @@
+// Inheritance
+
+class testA{
+    int a = 10;
+    void addSum(int n1, int n2){
+        System.out.println("Sum: " + (n1 + n2));
+    }
+}
+
+// B is child
+// A is parent
+class testB extends testA {}
+
+
+
+public class H_03_Inheritance {
+    public static void main(String[] args) {
+        testB testobjB = new testB();
+        testobjB.addSum(20,10);
+        System.out.println(testobjB.a);
+    }
+}
diff --git a/src/H_04_Single_Level_Inheritance.java b/src/H_04_Single_Level_Inheritance.java
new file mode 100644
index 0000000..576356b
--- /dev/null
+++ b/src/H_04_Single_Level_Inheritance.java
@@ -0,0 +1,66 @@
+// Single Level Inheritance
+public class H_04_Single_Level_Inheritance {
+    public static void main(String[] args) {
+        // Creating an object of the subclass Dog
+        Dog myDog = new Dog("Buddy", 3, "Golden Retriever");
+
+        // Accessing methods inherited from the superclass
+        myDog.eat(); // Output: Buddy is eating.
+
+        // Accessing method specific to the subclass
+        myDog.bark(); // Output: Buddy says: Woof! Woof!
+
+        // Displaying all information using the overridden method
+        myDog.displayInfo();
+        // Output:
+        // Name: Buddy, Age: 3
+        // Breed: Golden Retriever
+    }
+}
+
+// Superclass: Animal
+class Animal {
+    // Attributes (fields) of the superclass
+    String name;
+    int age;
+
+    // Constructor of the superclass
+    public Animal(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    // Method of the superclass
+    public void eat() {
+        System.out.println(name + " is eating.");
+    }
+
+    // Method to display animal details
+    public void displayInfo() {
+        System.out.println("Name: " + name + ", Age: " + age);
+    }
+}
+
+// Subclass: Dog
+class Dog extends Animal {
+    // Additional attribute specific to Dog
+    String breed;
+
+    // Constructor of the subclass
+    public Dog(String name, int age, String breed) {
+        // Call the constructor of the superclass (Animal)
+        super(name, age);
+        this.breed = breed;
+    }
+
+    // Additional method specific to Dog
+    public void bark() {
+        System.out.println(name + " says: Woof! Woof!");
+    }
+
+    // displayInfo method to include breed
+    public void displayInfo() {
+        super.displayInfo(); // Call the superclass method
+        System.out.println("Breed: " + breed);
+    }
+}
diff --git a/src/H_05_Multilevel_Inheritance.java b/src/H_05_Multilevel_Inheritance.java
new file mode 100644
index 0000000..2fce71a
--- /dev/null
+++ b/src/H_05_Multilevel_Inheritance.java
@@ -0,0 +1,27 @@
+// Multi Level Inheritance
+
+class A {
+    int xyz = 10;
+    void printMsg(){
+        System.out.println("Hello from class A.");
+    }
+}
+// access the properties of A inside class B
+class B extends A {
+    void subtract(int n1, int n2){
+        System.out.println(n1 - n2);
+    }
+}
+//access the properties of B inside class C
+class C extends B {
+    void multiply(int n1, int n2){}
+}
+
+public class H_05_Multilevel_Inheritance {
+    public static void main(String[] args) {
+        C objC = new C();
+        objC.subtract(20,5);
+        objC.printMsg();
+        System.out.println(objC.xyz);
+    }
+}
diff --git a/src/H_06_Hierarchical_Inheritance.java b/src/H_06_Hierarchical_Inheritance.java
new file mode 100644
index 0000000..44fd3f4
--- /dev/null
+++ b/src/H_06_Hierarchical_Inheritance.java
@@ -0,0 +1,93 @@
+// H_06_Hierarchical_Inheritance.java
+
+// Superclass: Vehicle
+class Vehicle {
+    // Common attributes for all vehicles
+    String brand;
+    String model;
+    int year;
+
+    // Constructor for Vehicle
+    public Vehicle(String brand, String model, int year) {
+        this.brand = brand;
+        this.model = model;
+        this.year = year;
+    }
+
+    // Common method for all vehicles
+    public void startEngine() {
+        System.out.println("The engine of " + brand + " " + model + " is starting.");
+    }
+
+    // Method to display vehicle details
+    public void displayInfo() {
+        System.out.println("Brand: " + brand + ", Model: " + model + ", Year: " + year);
+    }
+}
+
+// Subclass: Car
+class Car extends Vehicle {
+    // Additional attribute specific to Car
+    int numberOfDoors;
+
+    // Constructor for Car
+    public Car(String brand, String model, int year, int numberOfDoors) {
+        super(brand, model, year); // Call the constructor of Vehicle
+        this.numberOfDoors = numberOfDoors;
+    }
+
+    // Method specific to Car
+    public void openTrunk() {
+        System.out.println(brand + " " + model + ": Trunk is now open.");
+    }
+
+    // Overriding displayInfo to include number of doors
+    @Override
+    public void displayInfo() {
+        super.displayInfo(); // Call Vehicle's displayInfo
+        System.out.println("Number of Doors: " + numberOfDoors);
+    }
+}
+
+// Subclass: Bike
+class Bike extends Vehicle {
+    // Additional attribute specific to Bike
+    boolean hasCarrier;
+
+    // Constructor for Bike
+    public Bike(String brand, String model, int year, boolean hasCarrier) {
+        super(brand, model, year); // Call the constructor of Vehicle
+        this.hasCarrier = hasCarrier;
+    }
+
+    // Method specific to Bike
+    public void ringBell() {
+        System.out.println(brand + " " + model + ": Ding! Ding!");
+    }
+
+    // Overriding displayInfo to include carrier information
+    @Override
+    public void displayInfo() {
+        super.displayInfo(); // Call Vehicle's displayInfo
+        System.out.println("Has Carrier: " + (hasCarrier ? "Yes" : "No"));
+    }
+}
+
+// Main Class to Test Hierarchical Inheritance
+public class H_06_Hierarchical_Inheritance {
+    public static void main(String[] args) {
+        // Creating an object of Car
+        Car myCar = new Car("Toyota", "Camry", 2020, 4);
+        myCar.startEngine();      // Inherited method from Vehicle
+        myCar.openTrunk();        // Car-specific method
+        myCar.displayInfo();      // Overridden method
+
+        System.out.println(); // For better readability
+
+        // Creating an object of Bike
+        Bike myBike = new Bike("Yamaha", "YZF-R3", 2021, true);
+        myBike.startEngine();     // Inherited method from Vehicle
+        myBike.ringBell();        // Bike-specific method
+        myBike.displayInfo();     // Overridden method
+    }
+}
diff --git a/src/H_07_Abstract_Classes.java b/src/H_07_Abstract_Classes.java
new file mode 100644
index 0000000..bf536f8
--- /dev/null
+++ b/src/H_07_Abstract_Classes.java
@@ -0,0 +1,8 @@
+// Abstract Classes
+// the method is may or may not be having body.
+
+// basically if you look back at the file H_06_Hierarchical_Inheritance in the class Car extends Vehicle and Bike extends Vehicle has a @Overide, which give it the ability to rewrite something that has already a written. For e.g: All print functions
+
+public class H_07_Abstract_Classes {
+}
+
diff --git a/src/H_08_Interface.java b/src/H_08_Interface.java
new file mode 100644
index 0000000..b6683ad
--- /dev/null
+++ b/src/H_08_Interface.java
@@ -0,0 +1,32 @@
+// Interface
+
+interface A {
+    int a = 10;
+    int sum(int n1, int n2);
+}
+interface B {
+    int subtract(int n1, int n2);
+}
+
+class Calculator implements A {
+    @Override
+    public int sum(int n1, int n2){
+        return n1 + n2;
+    }
+
+    @Override
+    public int subtract(int n1, int n2){
+        return n1 - n2;
+    }
+
+}
+
+public class H_08_Interface {
+    public static void main(String[] args) {
+
+        Calculator calculator = new Calculator();
+        System.out.println(calculator.sum(10, 20)); // ans: 30
+        System.out.println(calculator.subtract(30, 15)); // ans: 15
+        System.out.println(calculator.a); // shown access value of 'a'
+    }
+}