added abstract classes

Author: AnuragAnalog

Abstract.java

@@ -0,0 +1,38 @@
+import java.util.*;
+
+abstract class Person {
+    String name;
+    int age;
+
+    Person(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    void doesWork() {
+        System.out.println("Person does work");
+    }
+
+    public abstract void display();
+}
+
+class Student extends Person {
+    String course;
+
+    Student(String name, int age, String course) {
+        super(name, age);
+        this.course = course;
+    }
+
+    public void display() {
+        System.out.println("Name: " + name + " Age: " + age + " Course: " + course);
+    }
+}
+
+public class Abstract {
+    public static void main(String[] args) {
+        Student student = new Student("John", 20, "Computer Science");
+        student.display();
+        student.doesWork();
+    }
+}

HasA.java

@@ -0,0 +1,69 @@
+import java.util.*;
+
+class Name {
+    String name;
+
+    Name() {
+        this.name = "";
+    }
+
+    Name(String name) {
+        this.name = name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void printName() {
+        System.out.println("Name: " + this.name);
+    }
+}
+
+class Address {
+    String address;
+
+    Address() {
+        this.address = "Mountain View, CA";
+    }
+
+    Address(String address) {
+        this.address = address;
+    }
+
+    public void setAddress(String address) {
+        this.address = address;
+    }
+
+    public void printAddress() {
+        System.out.println("Address: " + this.address);
+    }
+}
+
+class Employee {
+    String company;
+    Name name;
+    Address address;
+
+    Employee(String name, String company) {
+        this.name = new Name(name);
+        this.address = new Address();
+        this.company = company;
+    }
+
+    public void printCompany() {
+        System.out.println("Name "+this.name.name+" works at "+this.company);
+        System.out.println("Address: "+ this.address.address);
+    }
+}
+
+public class HasA {
+    public static void main(String[] args) {
+        Employee emp = new Employee("John Doe", "Google");
+        emp.printCompany();
+
+        if (emp.name instanceof Name) {
+            System.out.println("'emp.name' is an instance of Name");
+        }
+    }
+}

Overloading.java

@@ -0,0 +1,64 @@
+import java.util.*;
+
+// Understanding Overloading
+// Overloading is a concept in Java where a class can have multiple methods with the same name but different parameters.
+// Method or Constructor overloading is a static/compile-time polymorphism.
+// The methods must have the same name but different parameters.
+// The return type of the methods can be different.
+
+// The methods can be overloaded in the same class or in a subclass.
+// The methods can have different access modifiers.
+// The methods can throw different exceptions.
+// The methods can have different return types.
+// The methods can have different number of parameters.
+
+class Calculation {
+    String operations;
+
+    Calculation() {
+        this.operations = "Add Sub";
+    }
+
+    Calculation(String operations) {
+        this.operations = operations;
+    }
+
+    public int addition(int a, int b) {
+        return a + b;
+    }
+
+    public int addition(int a, int b, int c) {
+        return a + b + c;
+    }
+
+    public void addition(float a, float b) {
+        System.out.println("Addition: " + (a + b));
+        return ;
+    }
+
+    public int subtraction(int a, int b) {
+        return a - b;
+    }
+
+    public int subtraction(int a, int b, int c) {
+        return a - b - c;
+    }
+
+    public float subtraction(float a, float b) {
+        return (a - b);
+    }
+}
+
+public class Overloading {
+    public static void main(String[] args) {
+        Calculation calc = new Calculation();
+
+        System.out.println("Operations: " + calc.operations);
+        System.out.println("Addition: " + calc.addition(10, 20));
+        System.out.println("Addition: " + calc.addition(10, 20, 30));
+        calc.addition(10.5f, 20.5f);
+        System.out.println("Subtraction: " + calc.subtraction(10, 20));
+        System.out.println("Subtraction: " + calc.subtraction(10, 20, 30));
+        System.out.println("Subtraction: " + calc.subtraction(10.5f, 20.5f));
+    }
+}

Overriding.java

@@ -0,0 +1,38 @@
+import java.util.*;
+
+// Understanding Overriding
+// Overriding is a concept in Java where a subclass can provide a specific implementation of a method that is already provided by its superclass.
+// Method overriding is a dynamic/runtime polymorphism.
+// The methods must have the same name, same parameters, and same return type.
+// The methods can have different access modifiers.
+// The methods can throw different exceptions.
+
+class Person {
+    public void display() {
+        System.out.println("I am in the Person Class");
+    }
+}
+
+class Student extends Person {
+    public void display() {
+        System.out.println("I am in the Student Class");
+    }
+}
+
+class Employee extends Person {
+    public void display() {
+        System.out.println("I am in the Employee Class");
+    }
+}
+
+public class Overriding {
+    public static void main(String[] args) {
+        Person person = new Person();
+        Student student = new Student();
+        Employee employee = new Employee();
+
+        person.display();
+        student.display();
+        employee.display();
+    }
+}