What is Object-Oriented Programming?
Object-Oriented Programming concept refers to languages that use objects in programming. They use objects as a primary source to implement needs to happen in the code. Objects are seen by the viewer or user, performing tasks you assign. Object-oriented programming aims to implement real-world entities like inheritance, hiding, polymorphism, etc. in programming. The main aim of OOPs is to bind together the data and the functions that operate on them so that no other part of the code can access this data except that function.
Object-Oriented Programming (OOP) is a programming paradigm that uses “objects” to design applications and computer programs. It simplifies complex problems by modeling real-world entities.
Key Concepts
- Classes and Objects:
Class:
Class is a user-defined data type, which holds its own data members and member functions, which can be accessed and used by creating an instance of that class. A class is like a blueprint for an object. For eg: There are many smartphones with different names and brands having different features but they all share some common properties like they all have camera, OS, storage etc. So here, smartphones are the class and camera, storage, OS are their properties
- A Class is a user-defined data type that has data members and member functions in the class itself.
- Data members are the data variables and member functions are the functions which are used to perform the specific tasks and they define the properties and behavior of the objects in a Class.
- In the above example of class Smartphone, the data member will be camera, Storage etc and member functions can record photo/video, store documents/files, etc.
In short, classes are the blueprint which represents an object or group of objects that share the common properties and behavior.
For eg.
Class smartPhone{
public:
Int storage_amount;
Char name[20];
Int store_document(){
// code
}
}
In the above example, a class named “smartPhone” is defined which has data members defined as – “storage_amount” , ” name” and member functions defined as – “store_document()”.
- Object:
An Object is an entity which has some characteristics and behavior of its own. An Object is an instance of a Class. When a class is defined, no memory is allocated but when it is instantiated (i.e. an object is created) memory is allocated. In other words, whenever classes are instantiated, objects are created which will have the properties and behaviors defined in the class.
For eg:
Int main(){
smartPhone phone1;
}
In the above example, the class named smartPhone is instantiated. So an object named “phone1” has been created which will have the properties and behaviors which are defined in the class i.e., “storage_amount” , ” name” and “store_document()”.
Objects take up space in memory and have an associated address with them. When a program is executed, the objects interact by sending messages to one another and know how to perform certain actions and how to interact with other elements of the program. Each object contains data and code to manipulate the data. Objects can interact without having to know details of each other’s data or code, it is sufficient to know the type of message accepted and the type of response returned by the objects.
- Inheritance:
The ability of a class to derive properties and characteristics from another class is called Inheritance. Inheritance is one of the most important features of Object-Oriented Programming. It simply means that a class can inherit some or all properties and characteristics from a different class called a parent class.
- Sub Class: The class that inherits properties from another class is called Subclass or Derived Class.
- Super Class: The class whose properties are inherited by a subclass is called Base Class or Superclass or Parent Class.
- Reusability: Inheritance supports the concept of “reusability”, i.e. when we want to create a new class and there is already a class that includes some of the code that we want, we can derive our new class from the existing class. By doing this, we are reusing the fields and methods of the existing class.
For eg. consider a class B.Tech., where there are different departments or subjects like Computer Science, IT, electronics, mechanical etc. So, if we have some properties which are already defined in the B.Tech. class for eg. ID, Roll No etc. which we want in the other classes as well, then there is no need to define those properties in each class separately. We can simply inherit those properties from the B.Tech. class into the other class.
- Polymorphism:
The word polymorphism means having many forms. In simple words, we can define polymorphism as the ability of a message to be displayed in more than one form. Consider a real life example, where a person at the same time can have different characteristics. A man at the same time can be a student as well as an employee. So the same person possesses different behavior in different situations. This is called polymorphism. An operation may exhibit different behaviors in different instances. The behavior depends upon the types of data used in the operation.
Polymorphism is achieved through 2 methods knows as Operator Overloading and Function Overloading (in C++) and method overloading and method overriding (in java).
- Operator Overloading: The process of making an operator exhibit different behaviors in different instances is known as operator overloading.
- Function Overloading: Function overloading is using a single function name to perform different types of tasks. Polymorphism is extensively used in implementing inheritance.
- Method Overloading: Method overloading refers to defining multiple methods with the same name but different parameters within the same class.
- Method Overriding: Method overloading refers to creating a method in the child class that has the same name, parameters, and return type as a method in the parent class.
- Encapsulation:
Encapsulation is defined as binding together the data and the functions that manipulate them in a single unit. Consider a real-life example of encapsulation, in a college, there are different departments like the Computer Science department, Electronics department, Mechanical department, etc. Now there may arise a situation when for some reason a professor from the Computer Science department needs all the data about Electronics department students. In this case, he is not allowed to directly access the data of the Electronics department. He will first have to contact some other officer in the Electronics department and then request him to give the particular data. This is where encapsulation is used. Here the data of the Electronics department and the students that can manipulate them are wrapped under a single name “Electronics department”.
Encapsulation also leads to data abstraction or data hiding. Using encapsulation data is hidden and not accessible by everyone. In the above example, the data of any of the departments like Computer Science, Electronics, or Mechanical are hidden from the other departments.
- Abstraction:
Data abstraction is one of the important features of object-oriented programming. Abstraction means displaying only essential information and hiding the details. Data abstraction refers to providing only essential information about the data to the outside world, hiding the execution,background details or implementation. For example, when you click on the Power Button of a smartphone, it starts the phone. You only know that pressing the Power Button will start the phone but you do not know how on pressing the Power Button, the phone gets started. This is what abstraction is.
Abstraction can be achieved in two ways:
- Through Classes
- Through Header Files
Benefits of OOP
- Offers Security – Many developers use OOP because it ensures minimal exposure using encapsulation
- Improves Collaboration – it allows developers to divide a complex software system into small, manageable objects. Each object is responsible for a specific function. They can develop, test, and maintain these self-contained units independently.
- Allows Reuse of Code – The concept of inheritance allows OOP to promote the reuse of code. A developer can create new classes based on existing ones. It reduces code duplication and saves development time significantly.
- Make Changes Seamlessly – The abstraction of complex systems into simplified models is one of the pivotal benefits of object-oriented programming.
- Fixing and Debugging – The developers can isolate and test each object, which helps to identify and isolate problems.
- Ensures Flexibility – Polymorphism allows a developer to treat different types of objects as objects of a common superclass. It minimizes the need to duplicate code.
- Improves Productivity – It allows developers to mount big projects without any hiccups. Moreover, it helps programmers improve software quality at an affordable cost.
- Maintains Code Consistency – The code is more readable and maintainable under OOP because it models real-world objects. It is convenient to maintain and update code.
- Encourages Scalability – The effort to scale software systems when they grow in complexity is smooth in OOP. Several of its features make adding new code hassle-free. In fact, the systems are also scalable due to the inherent flexibility in code.
- Reduces Development Cost – Code reusability helps in the reduction of development costs.
Disadvantages of OOP
- We can not apply OOP everywhere as it is not a universal language. It is applied only when it is required. It is not suitable for all types of problems.
- The length of the programmes developed using OOP language is much larger than the procedural approach. Since the programme becomes larger in size, it requires more time to be executed that leads to slower execution of the programme.
- OOPs take time to get used to it. Programmers need to have proper designing skills and programming skills. The thought process involved in object-oriented programming may not be natural for some people as OOPS is a bit tricky.
Conclusion
Understanding OOP is essential for modern software development. Mastering these concepts allows you to write more modular, reusable, and easier-to-maintain code.
