BASICS OOP CONCEPTS

Real-world examples of OOP concepts

Have you ever wondered about where OOP concepts are practically being used in real-world?

Object-Oriented Programming is considered as a design methodology for building non-rigid software. In OOPS, every logic is written to get our work done but represented in the form of Objects. OOP allows us to break our problems into a small unit of work that is represented via objects and their functions. We build functions around objects.

There are mainly four pillars (features) of OOP. If all of these four features are presented in programming, the programming is called perfect Object-Oriented Programming.

1. Abstraction
2. Encapsulation
3. Inheritance
4. Polymorphism

Let’s consider an example of explaining each of these pillars so you can better understand Object-Oriented Programming.

Before that, we need to know something.

When we think of a mobile phone as an object, its basic functionality for which it was invented were Calling & Receiving a call & Messaging. But nowadays thousands of new features and models were added and the features and number of models are still growing.

Objects

Any real-world entity which can have some characteristics of which can perform some tasks is called Object. This object is also called an instance i.e. a copy of an entity in a programming language. If we consider the above example, a mobile manufacturing company can be an object. Each object can be different based on their characteristics. For example, here are two objects.

1. Mobile mbl1 = new Mobile ();
2. Mobile mbl2 = new Mobile ();

Class

A class in OOP is a plan which describes the object. We call it a blueprint of how the object should be represented. Mainly a class would consist of a name, attributes, and operations. Considering the above example, Mobile can be a class, which has some attributes like Profile Type, IMEI Number, Processor, and some more. It can have operations like Dial, Receive and SendMessage.

There is some OOPS principle that needs to be satisfied while creating a class. This principle is called as SOLID where each letter has some specification. I won’t be going into these points deeper. A single line of each explanation may clear you with some points.

1. SRP (The Single Responsibility Principle) — A class should have one, and only one responsibility
2. OCP (The Open Closed Principle) — You should be able to extend a classes behaviour, without modifying it. (Inheritance)
3. LSP (The Liskov Substitution Principle) — Derived classes must be substitutable for their base classes. (Polymorphism)
4. ISP (The Interface Segregation Principle) -Make finely chopped interface instead of the huge interface as the client cannot be forced to implement an interface which they don’t use.
5. DIP (The Dependency Inversion Principle) — Depend on abstractions, not on concretions. (Abstraction)

If you want to learn more about SOLID principles, check out SOLID Architectural Pattern with Real World Example.

Now, let’s take a look at our class. A typical class based on the above discussion looks like the following in Visual Studio:

Abstraction

Abstraction allows us to expose limited data and functionality of objects publicly and hide the actual implementation. It is the most important pillar in OOPS. In our example of Mobile class and objects like Nokia, Samsung, iPhone.

Some features of mobiles,

1. Dialling a number call some method internally which concatenate the numbers and displays it on screen but what is it doing we don’t know.
2. Clicking on green button actual send signals to calling a person’s mobile but we are unaware of how it is doing.

This is called abstraction. In classes, we can create methods that can be called and used by the users of the class but users will have no idea what these methods do internally.

Encapsulation

Encapsulation is defined as the process of enclosing one or more details from the outside world through access right. It says how much access should be given to particular details. Both Abstraction & Encapsulation works hand in hand because Abstraction says what details to be made visible and Encapsulation provides the level of access right to that visible details. i.e. — It implements the desired level of abstraction.

Talking about Bluetooth which we usually have in our mobile. When we switch on a Bluetooth, I am able to connect to another mobile or Bluetooth enabled devices but I’m not able to access the other mobile features like dialling a number, accessing inbox etc. This is because the Bluetooth feature is given some level of abstraction.

Another point is when mobile A is connected with mobile B via Bluetooth whereas mobile B is already connected to mobile C then A is not allowed to connect C via B. This is because of accessibility restriction.

Polymorphism

Polymorphism can be defined as the ability to use the same name for doing different things. More precisely we say it as ‘many forms of single entity’. This play a vital role in the concept of OOPS.

Let’s say Samsung mobile has a 5MP camera available i.e. — it is having a functionality of CameraClick(). Now the same mobile is having Panorama mode available in-camera, so functionality would be the same but with mode. type is said to be Static polymorphism or Compile time polymorphism.

Compile-time polymorphism the compiler knows which overloaded method it is going to call.

The compiler checks the type and number of parameters passed to the method and decides which method to call and it will give an error if there are no methods that match the method signature of the method that is called at compile time.

Another point wherein SendMessage was intended to send message to a single person at a time but suppose Nokia had given provision for sending a message to a group at once. i.e. — Overriding the functionality to send message to a group. This type is called Dynamic polymorphism or Runtime polymorphism.

For overriding you need to set the method, which can be overridden to virtual & its new implementation should be decorated with the override keyword.

By runtime polymorphism, we can point to any derived class from the object of the base class at runtime that shows the ability of runtime binding.

Inheritance

Inheritance is the ability to extend the functionality from the base entity in new entity belonging to the same group. This will help us to reuse the functionality which is already defined before and extend into a new entity.

Considering the example, the above figure 1.1 itself shows what is inheritance. Basic Mobile functionality is to send a message, dial and receive a call. So the brands of mobile are using this basic functionality by extending the mobile class functionality and adding their own new features to their respective brand.

There are mainly 4 types of inheritance,

1. Single level inheritance
2. Multi-level inheritance
3. Hierarchical inheritance
4. Hybrid inheritance
5. Multiple inheritances

Single level inheritance

In Single level inheritance, there is a single base class & a single derived class i.e. - A base mobile features is extended by Samsung brand.

Multilevel inheritance

In Multilevel inheritance, there is more than one single level of derivation. i.e. - After base features are extended by Samsung brand. Now Samsung brand has manufactured its new model with newly added features or advanced OS like Android OS, v4.4.2 (KitKat). From generalization, getting into more specification.

Hierarchal inheritance

In this type of inheritance, multiple derived class would be extended from a base class, it's similar to single level inheritance but this time along with Samsung, Nokia is also taking part in inheritance.

Hybrid inheritance

Single, Multilevel, & hierarchal inheritance all together construct a hybrid inheritance.

Interface

Multiple inheritances where the derived class will extend from multiple base classes.

Samsung will use the function of multiple Phone (Mobile & Telephone). This would create confusion for complier to understand which function to be called when an event in mobile is triggered like Dial () where Dial is available in both the Phone i.e. — (Mobile & Telephone). To avoid this confusion C# came with the concept of the interface which is different from multiple inheritances actually.

If we take an interface it is similar to a class but without implementation & only declaration of properties, methods, delegates & events. The interface actually enforces the class to have a standard contract to provide all implementation to the interface members. Then what’s is the use of interface when they do not have any implementation? The answer is, they are helpful for having readymade contracts, only we need to implement functionality over this contract.

I mean to say, Dial would remain Dial-in case of Mobile or Telephone. It won’t be fair if we give a different name when its task is to Call the person.

The interface is defined with the keyword ‘interface’.All properties & methods within the interface should be implemented if it is been used. That’s the rule of the interface.

source: pradeep-shet