Concepts Behind Abstract & Inheritance in Object Oriented Programming

Hi guys,

In this post I’ll decide to cover two basic concepts behind OOP. Object oriented programing concepts memorizing or hard coding is impractical, because OOP is the pure conceptual thing. If you need to geek of this area you should try to understand this concept rather than memorizing. I’ll go through the OOP design pattern based on Abstract & Inheritance concepts. Following a practical approach will be lead to better understanding of above two concepts. Today's post I’ll organize in two different approaches, first I’ll explain the OOP concepts with an aid of in real world scenarios and then I’ll implement explained concept using JAVA technical aspect. Ok, let’s start our OO journey with JAVA. 

Real world scenario - 

When we depict above diagram, every human being in the world owns above 4 properties which is listed under person. But when we want to categorize every human being in the whole world under person category it will be a disaster, because 7 billion humans in the world can be put into person category. In order to introduce well organized approach as well as a resource utilization approach, we can categorize persons into two major categories. Female & Male, now see above approach how to lead to well-organized resource utilization approach. I’m highlighting in the beginning of this paragraph, every human beings own 4 properties in their life. These four properties didn’t depend on the gender. In order to maintain well-organized approach we divide persons into two categories, but still we listed above properties under person category. We reuse listed properties rather than duplicating. We divide the whole world into two categories, but still we listed common features under person category. Now we can put the whole world into female & male category, but still we maintain person category for listed common features of females & males.

Technical approach – 

Now I’m instructing to how to implement the technical approach of the above real world scenario using JAVA, This three category implementing as three different Classes, But in order to implement this scenario, according to OO concepts, we will use Inheritance for avoiding duplicating resources also maintain the well-organized approach. Let’s see how we utilize resources, I’ll implement person class and include all common properties in the person class. Additionally, I’ll implement female & male classes for maintaining well-organized approach. 

public class person {
  
    private String name;
    private int age;
    private genderType gender;
    private Date birthDay;

    public person(String name, int age, genderType gender, Date birthDay) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.birthDay = birthDay;
    }
}

public class female extends person{

    public female(String name, int age, genderType gender, Date birthDay) {
        super(name, age, gender, birthDay);
    }
}

public class male extends person{

  
    public male(String name, int age, genderType gender, Date birthDay) {
        super(name, age, gender, birthDay);
    }
}

enum – If you want to implement user defined data type like ‘genderType’, you can easily add an enum and define data within curly brackets and using when we want. But you can’t assign user defined data type data just like a standard data type. You should assign values like this,

<Defined Data type>.< Data> 

Ex: genderType.female

enum genderType{
      
        Female,
        Male
    }

Real world scenario –

Now we will listed what are the specified features and common features of female and male lives. Following table explain about that. You can see the study level of each person didn’t depend on the gender, but when we consider marital status of each person it will be depend on gender. 

Technical approach – 

When illustrate the real world scenario, you can see a ‘Marital Status’ is depend on the gender type, I mean marital status, we can categorize as a common feature of both male & female. But when we using that usually both married an unmarried male as a “Mr.” and married female as a “Mrs.” & Unmarried female as “Miss.” So you can see these common features how to depend on gender. What I want to do is, I will define a method in person class and, method, body defined in both female and male classes according to changes.

public abstract String getMaritalStatus(boolean status); 

public String getMaritalStatus(boolean status)
    {
        if(status)
            return "Miss";
        else
            return "Mrs.";
    }

public String getMaritalStatus(boolean status)
    {
        return "Mr.";
    }

Real world scenario –

Now we will categorize 3 persons into these three categories, I’ll put the mark these real world data represented category. You can see each real world data can be put into female or male category, because of this reason person category is empty.

 

Technical approach – 

Let’s implement the JAVA technical approach, according to real world scenarios, according to above table you can see any real world data can’t categorize as person, but still common features listed under person class. What I am going to change is, I’ll change person class as the Abstract class, my target maintains person class as a super class and as well as a method of resource utilization but never create any of the object of it.

public abstract class person{ //rest of the class }

Method overriding – This is another important feature in OO programing, But here I’ll not go into that much detail about this. I will just quickly go through it, when we implement any of the class we can see by default methods automatically generated for us, in the class. ToString (), compareTo (), Equals () are the common method which we can see when we disassemble the code using Java. We can override those methods according to our requirements. Following example, I’ll override auto generated method inside the person class. Additionally, when we want to override compareTo () method we need to implant comparable interface inside the class. You can simply implement needed interfaces after the class name as you wish.      

Another thing is, when we want to compare different properties we can’t override the same comparator () method in the same class. We can use separate class and implement the comparator interface in JAVA and simply override the compare () method according to our requirements.

public abstract class person implements Comparable<person>
{ 
//rest of the class
@Override
    public int compareTo(person t) {
       
        if(t.name.compareTo(name) == 1)
        {
            return -1;
        }else
        {
            if(t.name.compareTo(name) == -1)
            {
                return 1;
            }else
            {
                return 0;
            }
        }
    } 
}

@Override
    public String toString() {
        return "person{" + "name=" + name + ", age=" + age + ", gender=" + gender + ", birthDay=" + birthDay + '}';
    }

@Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final person other = (person) obj;
        if (!Objects.equals(this.name, other.name)) {
            return false;
        }
        return true;
    }

import java.util.Comparator;
public class compareByAge implements Comparator<person>{

    @Override
    public int compare(person t, person t1) {
       
        if(t.getAge() > t1.getAge())
        {
            return 1;
        }else
        {
            if(t.getAge() < t1.getAge())
            {
                return -1;
            }else
            {
                return 0;
            }
        }
    }  
   
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class RealWorldApplication {

    public static String sortByName(List<person> personList)
    {
      Collections.sort(personList);
      return "Sort by name";
    } 
   
    public static String sortByAge(List<person> personList)
    {
      Collections.sort(personList,new compareByAge());
      return "Sort by age";
    }
   
    public static void displayPersons(List<person> personList)
    {
        for(person tempPerson : personList)
        {
            System.out.println(tempPerson);
        }
    }
   
    public static void main(String[] args) {
       
        Scanner Scan = new Scanner(System.in);
               
        List humanList = new ArrayList<person>();
       
        humanList.add( new male("Saman Ranpitiya", 25, genderType.Male, null));
        humanList.add( new male("Nuwan Kumara", 30, genderType.Male, null));
        humanList.add( new female("Kumari Silva", 20, genderType.Female, null));
       
        boolean status = true;
       
        do
        {
            System.out.println("Enter your choise >> ");
            int option = Scan.nextInt();
           
            switch(option)
            {
                case 1 : displayPersons(humanList);
                    break;
                case 2 : sortByAge(humanList);
                    break;
                case 3 : sortByName(humanList);
                    break;
                case 4 : status = false;
                   
            }
           
        }while(status);
     
    }
}

Happy Coding.....

Regards,
Denuwan Himanga.