Understanding OOPs and Abstraction using Real World Scenario

Object-oriented programming: As the name suggests, Object-Oriented Programming or OOPs refers to languages that use objects in programming. Object-oriented programming aims to implement real-world entities like inheritance, hiding, polymorphism etc in programming. In this article, we will discuss how this OOP’s concept is implemented in real world scenario.

Let’s consider an example of a Geek who wants to learn the Java full course online. He chooses one of the sources to know about various platforms which are offering Java Course. Let’s say he chooses Google and he searches for the course. Once Google accepts the request, it will perform various actions to carry out the request until the request has been served. The following illustration demonstrates the steps performed:

A way of viewing world with OOPs concept

Below is the implementation of the demo class which demonstrates the steps mentioned in the above image:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java Program to demonstrate
// the above steps
  
// Here, Geek is a class
class Geek {
  
    // Until no request the
    // value will be false
    boolean value = false;
  
    private String request = "";
  
    // Constructor of Geek
    Geek(String request)
    {
        // The value becomes true
        // once the constructor called
        // or when the object created
        value = true;
  
        this.request = request;
  
        System.out.println(
            "Geek Requested: "
            + request);
    }
  
    public String getRequest()
    {
        return this.request;
    }
}
  
// A google class
class Google {
  
    private String request;
  
    // Constructor of Google
    Google(String request)
    {
        this.request = request;
        System.out.println(
            "Google Searched: "
            + request);
    }
  
    // This class may also contains methods
    // through which the request passes
    // messages to further more objects
    // and also send back a response
}
  
// Demo class to understand
// A way of using abstraction
public class MainDemo2 {
  
    // Driver code
    public static void main(String[] args)
    {
        // Geek class object creation
        Geek g = new Geek("Java");
  
        // Checking whether Geek
        // has requested or not
        if (g.value) {
  
            // If the Geek requested
            // Google object created
            Google gl = new Google(g.getRequest());
  
            // Google performs some action
            // To satisfy the Geek with his
            // Desired result
        }
    }
}

chevron_right


Output:



Geek Requested: Java
Google Searched: Java

An illustrative figure of the above program:
Program

From the above example, lets understand the different terminology used in the Object-Oriented Design:

  1. Agents and Community:
    1. Agent: Every object in the community acts as an agent (i.e.) from the above example, we can say that Geek, Google, and the other extra objects are known to be agents. Every agent performs some actions and those actions are being utilized by other members of the community to solve the problem.
    2. Community: It is created by actions. In the above example, we can say that the search engine community has been formed.

    Therefore, in the above example:

    Agents: Geek, Google, and other objects
    Community: Search engine community
    
  2. Messages and Methods:
    1. Messages: Every message may be a request or response that is being passed to other members of the community.
    2. Methods Every method is used to perform an action in the community, that action will be used by other members of the community to solve various problems.
  3. Responsibilities: From the above example, we can observe that once the Geek passes a request to Google, it will accept the request and it performs various actions to give him the desired result. It means if the request accepted by an agent, it is the responsibility of the agent to carry out the request until the problem is solved.

Finally, we can conclude that we have achieved hiding of the data or Abstraction by implementing the system in such a way that when the Geek passes the request, the actions performed by Google are hidden from him to get the desired result.

Attention reader! Don’t stop learning now. Get hold of all the important Java and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.