When objected-oriented programming first appeared in the 1980s, it was a radical leap from traditional top-down programming. It introduced new software development methods with features like Inheritance, Encapsulation, Abstraction, Polymorphism, etc. In simple words: It helped us organize code and thinking for large-scale software development.
OOPS binds together the data and the methods in form of an object and selectively exposes data to other objects. The idea revolves around classes and their definition, instantiation, relationship, communication, etc. On the other hand, the building block of procedural programming is procedures or methods that perform operations on data.
OOPS allows us to combine methods and data into a specific group called classes. This idea brings data and methods together in a code and, most importantly, makes the code reusable. It allows us to represent the real-world entities through data and animate that representation through methods.
Why the idea of "class" is essential in OOPS? Here is an analogy to understand: The world around us has a lot more complex structure than just numbers, strings, etc. So we need a mechanism to group values in a meaningful fashion to define and use such structure. In other words, if we're going to solve real-world problems using software, we'd like to mimic the real world's structure with attributes and methods that exhibit the characteristics of that structure. So the idea of classes in oops helps us define structures similar to the real world and build scalable software.
An object is an instance of a class created with specific data, whereas a class is an abstract blueprint used to create specific, concrete objects. So each object contains data and methods working on that data.
This approach allows us to access class variables to the methods of the class while at the same time they aren’t global. It gives us a lot of control of which parts of the program can access what, which could help in improving code clarity.
When working with object-oriented programming languages, we know exactly where to look when something goes wrong. In other words, we don’t have to go line-by-line through all our code. That’s the beauty of encapsulation! Encapsulation helps us expose relevant details to the outside world and lets us change the implementation of the code without affecting any other code.
Objects are self-contained, and each functionality does its own thing while leaving the other alone. This modularity allows an IT team to work on multiple objects simultaneously while minimizing the chance that one person might duplicate someone else’s functionality. In other words, we often need to take care of the accessibility of our data in software projects. To achieve this, we use the concept of encapsulation!
On large-scale software projects that involve millions of code lines, we often need to reuse existing code or extend functionalities according to requirements. To achieve this, we use the concept of Inheritance. It is a process in which one class acquires all the properties and behaviors of its parent class.
In Inheritance, we create one parent class and define subclasses to inherit the parent class traits. Each subclass could implement separate methods for itself, and at the same time, it can reuse the parent class's existing methods. Even if we change our parent class, all sub-classes will inherit the new code.
OOPS allows us to have many methods, all with the same name, doing a similar job on different data or data types. Suppose we need a few methods with similar traits in each subclass, but the parameters are different. This is where polymorphism comes into play.
We define a single method inside the parent class, and based on need, we separately define this common method for all other sub-classes.
Polymorphism via Function Overloading
Function overloading allows us to have more than one function having the same name but a different parameter list or type. For example, the parameters list of a function myfun(int a, int b) is (int, float) which is different from the function myfun(float a, int b) parameter list (float, int).
The main advantage of function overloading is to improve code readability and allow code reusability. In the code below, we can see how we are able to have more than one function for the same task(addition) with different parameters. This allows us to add two integer numbers and three integer numbers, and if we want, we could have some more functions with the same name and four or five arguments.
Polymorphism via Operator Overloading
Operator overloading means that the operation performed by the operator depends on the type of operands provided to the operator method. It is similar to function overloading, where we have many versions of the same function differentiated by their parameter lists.
OOPS lets us extend operator overloading to user-defined types (classes) i.e., a programmer can provide their own operator to a class by overloading the built-in operator and perform some specific computation when the operator is used on objects of that class.
In an object-oriented language, abstraction is implemented through classes that define properties of an object like data and methods. It has the mechanism of using class methods through related objects without going into details about how the methods are written. So abstraction means providing only the essential or relevant information and hiding the background or technical implementation details. For example: to drive a car, one only needs to know the driving process and not the mechanics of the car engine.
Abstraction makes the modifications easier as the interface to access the method remains the same. For example, if the type and working of the car engine change, it does not change the driving process.
Enjoy learning, Enjoy OOPS!
The factory method is a creational design pattern in which we define a superclass for creating an object but let the subclasses decide which class to instantiate. Therefore, the factory method enables a class to delegate instantiation to its subclasses and eliminates the coupling of concrete products to the Client code.
Java language has a feature called method overloading, which allows multiple methods within a class to have the same name with different argument lists. It is a type of polymorphism (the process by which we can perform a single task in various ways). To be more concise, overloading is an example of static polymorphism.
An exception is an event that occurs during the execution of a program and disrupts the normal (expected) flow of the program. The word “exception” in programming refers to an “exceptional event.” As soon as the exception is thrown, the runtime system attempts to find an exception handler.
There might be some objects common to all parts of the program, and we require a single instance of it. The Singleton is a creational design pattern that ensures that a class has only one instance throughout the application. This instance is accessible from any part of the application with global access.
Encapsulation is one of the fundamental concepts in OOP that bundles data and associated methods that operate on that data into a single block called class. It is also a pathway for restricting direct access to some data and methods associated with a class (which leads to data hiding).
Subscribe to get free weekly content on data structure and algorithms, machine learning, system design, oops design and mathematics.
