The basic concept of OOP comparing to the real world entities

 

What is the basic concepts of OOP?

Article arranged programming plans to carry out genuine elements like legacy, stowing away, polymorphism, and so forth in programming. The fundamental point of OOP is to tie together the information and the capacities that work on them so no other piece of the code can get to this information with the exception of that capacity.

Item Oriented Programming is considered as a plan procedure for building non-inflexible programming. In OOPS, each rationale is composed to finish our work, however addressed in type of Objects. OOP permits us to break our concerns into little unit of work that is addressed by means of items and their capacities. We fabricate capacities around objects. 

There are principally four columns (highlights) of OOP. If these four components are introduced in programming, the writing computer programs is called amazing Object Oriented Programming. 

Reflection 

Epitome 

Legacy 

Polymorphism 

How about we consider a model clarifying every one of these columns so you can more readily comprehend Object Oriented Programming. 

Prior to that, we want to know something. 

At the point when we consider a cell phone an item, its essential usefulness for which it was created were Calling and Receiving a call and Messaging. Yet, presently a days great many new elements and models were added and the components and number of models are as yet developing. 

versatile 

Portable Brand 

In above chart, each brand (Samsung, Nokia, IPhone) have their own rundown of elements alongside fundamental usefulness of dialing, getting a call and informing. 

Articles 

Any certifiable element which can have a few attributes or which can play out certain errands is called as Object. This item is likewise called an occasion for example a duplicate of substance in programming language. If we think about the above model, a portable assembling organization can be an item. Each item can be distinctive dependent on their attributes. For instance, the following are two items. 

Portable mbl1 = new Mobile (); 

Portable mbl2 = new Mobile (); 

Class 

A class in OOP is an arrangement which portrays the item. We consider it an outline of how the article ought to be addressed. Chiefly a class would comprise of a name, characteristics, and tasks. Thinking about the above model, the Mobile can be a class, which has a few ascribes like Profile Type, IMEI Number, Processor, and some more. It can have tasks like Dial, Receive and SendMessage. 

There are some OOPS rule that should be fulfilled while making a class. This rule is called as SOLID where each letter has some determination. I will not be going into this focuses further. A solitary line of every clarification might clear you for certain focuses. 

SRP (The Single Responsibility Principle) - A class ought to have one, and just a single liability 

OCP (The Open Closed Principle) - You ought to have the option to broaden a classes conduct, without altering it. (Legacy) 

LSP (The Liskov Substitution Principle) - Derived classes should be substitutable for their base classes. (Polymorphism) 

ISP (The Interface Segregation Principle) - Make fine slashed interface rather than immense interface as customer can't be compelled to carry out an interface which they don't utilize. 

Plunge (The Dependency Inversion Principle) - Depend on reflections, not on solidifications. (Reflection) 

Assuming you need to find out about SOLID standards, look at SOLID Architectural Pattern with Real World Example. 

Presently, we should investigate our class. A common class dependent on the above conversation resembles the accompanying in Visual Studio: 

class 

In C# programming language, a class has individuals. These individuals are called properties, strategies, fields, constructors, destructors, occasions, etc. 

In code, the Mobile class resembles the accompanying: 

public class Mobile 

{ 

private string IEMICode { get; set; } 

public string SIMCard { get; set; } 

public string Processor { get; } 

public int InternalMemory { get; } 

public bool IsSingleSIM { get; set; } 

public void GetIEMICode() 

{ 

Console.WriteLine("IEMI Code - IEDF34343435235"); 

} 

public void Dial() 

{ 

Console.WriteLine("Dial a number"); 

} 

public void Receive() 

{ 

Console.WriteLine("Receive a call"); 

} 

public virtual void SendMessage() 

{ 

Console.WriteLine("Message Sent"); 

} 

} 

Deliberation 

Deliberation permits us to uncover restricted information and usefulness of items openly and conceal the real execution. It is the main column in OOPS. In our illustration of Mobile class and items like Nokia, Samsung, IPhone. 

A few components of mobiles, 

Dialing a number call some technique inside which link the numbers and shows it on screen yet the thing is it doing we don't have the foggiest idea. 

Tapping on green button genuine convey messages to calling individual's versatile however we are unconscious of how it is getting along. 

This is called deliberation. In classes, we can make strategies that can be called and utilized by the clients of the class yet clients will have no clue about what these techniques do inside. 

public void Dial() 

{ 

/Write the rationale 

Console.WriteLine("Dial a number"); 

} 

Exemplification 

Exemplification 

Exemplification is characterized as the most common way of walling one in or more subtleties from outside world through access right. It says how much access ought to be given to specific subtleties. Both Abstraction and Encapsulation works connected at the hip since Abstraction expresses what subtleties to be made apparent and Encapsulation gives the degree of access right to that noticeable subtleties. for example – It carries out the ideal degree of deliberation. 

Discussing Bluetooth which we normally have it in our versatile. At the point when we switch on a Bluetooth, I am ready to interface with another versatile or bluetooth empowered gadgets yet I'm not ready to get to the next portable elements like dialing a number, getting to inbox and so forth This is on the grounds that, Bluetooth highlight is given some degree of reflection. 

One more point is when versatile An is associated with portable B by means of Bluetooth while versatile B is now associated with portable C then An isn't permitted to interface C through B. This is a result of availability limitation. 

In C#, a class approaches modifiers like public, private, secured, and interior. These entrance modifiers permits properties and techniques to be presented or limited to the rest of the world. 

private string IMEICode = "76567556757656"; 

Polymorphism 

Polymorphism can be characterized as the capacity of utilizing similar name for doing various things. All the more definitively we say it as 'many types of single substance'. This assume an imperative part in the idea of OOPS. 

Suppose Samsung versatile has a 5MP camera accessible for example – it is having a usefulness of CameraClick(). Presently same versatile is having Panorama mode accessible in camera, so usefulness would be same however with mode. This sort is supposed to be Static polymorphism or Compile time polymorphism. See the model underneath: 

public class Samsumg : Mobile 

{ 

public void GetWIFIConnection() 

{ 

Console.WriteLine("WIFI associated"); 

} 

/This is one mwthod which shows camera usefulness 

public void CameraClick() 

{ 

Console.WriteLine("Camera clicked"); 

} 

/This is one over-burden technique which shows camera usefulness also yet with its camera's diverse mode(panaroma) 

public void CameraClick(string CameraMode) 

{ 

Console.WriteLine("Camera clicked in " + CameraMode + " Mode"); 

} 

} 

Aggregate time polymorphism the compiler realizes which over-burden strategy it will call. 

Compiler checks the sort and number of boundaries passed to the strategy and concludes which technique to call and it will give a blunder in case there are no strategies that coordinates with the strategy mark of the strategy that is called at aggregate time. 

Another point where in SendMessage was expected to send message to single individual at a time but suppose Nokia had given arrangement for sending message to a gathering without a moment's delay. for example - Overriding the usefulness to send message to a gathering. This sort is called Dynamic polymorphism or Runtime polymorphism. 

For superseding you want to set the strategy, which can be abrogated to virtual and its new execution ought to be improved with supersede watchword. 

public class Nokia : Mobile 

{ 

public void GetBlueToothConnection() 

{ 

Console.WriteLine("Bluetooth associated"); 

} 

/New execution for this strategy which was accessible in Mobile Class 

/This is runtime polymorphism 

public supersede void SendMessage() 

{ 

Console.WriteLine("Message Sent to a gathering"); 

} 

} 

By runtime polymorphism, we can highlight any got class from the object of the base class at runtime that shows the capacity of runtime restricting. 

Legacy 

Legacy 

Legacy is the capacity to expand the usefulness from base element in new substance having a place with same gathering. This will assist us with reusing the usefulness which is as of now characterized previously and stretch out into another substance. 

Thinking about the model, the above figure 1.1 itself shows what is legacy. Essential Mobile usefulness is to communicate something specific, dial and get a call. So the brands of portable is utilizing this essential usefulness by broadening the versatile class usefulness and adding their own new provisions to their individual image. 

There are primarily 4 kinds of legacy, 

Single level legacy 

Staggered legacy 

Various leveled legacy 

Mixture legacy 

Various legacy 

Single level legacy 

In Single level legacy, there is single base class and a solitary inferred class for example - A base portable components is reached out by Samsung brand. 

Single level legacy 

Staggered legacy 

In Multilevel legacy, there is more than one single degree of induction. for example - After base elements are stretched out by Samsung brand. Presently Samsung brand has made its new model with new added includes or progressed OS like Android OS, v4.4.2 (kitkat). From speculation, getting into more determination. 

Staggered legacy 

Hierarchal legacy 

In this sort of legacy, numerous determined class would be extended.

Single, Multilevel, and hierarchal legacy all together develop a half breed legacy. 

Half breed legacy 

public class Mobile 

{ 

/Properties 

/Methods 

} 

public class Samsumg : Mobile 

{ 

/Properties 

/Methods 

} 

public class Nokia : Mobile 

{ 

/Properties 

/Methods 

} 

Interface 

Numerous legacy where gotten class will stretch out from various base classes. 

Samsung will utilize the capacity of numerous Phone (Mobile and Telephone). This would make a disarray for complier to comprehend what capacity to be called when any occasion in versatile is set off like Dial () where Dial is accessible in both the Phone for example - (Mobile and Telephone). To keep away from this disarray C# accompanied the idea of interface which is unique in relation to different legacy really. 

If we take an interface it is like a class however without execution and just statement of properties, techniques, delegates and occasions. Interface really upholds the class to have a standard agreement to give all execution to the interface individuals. Then, at that point, what's is the utilization of interface when they don't have any execution? Answer is, they are useful for having readymade contracts, just we want to carry out usefulness over this agreement. 

I intend to say, Dial would remain Dial if there should arise an occurrence of Mobile or Telephone. It will not be reasonable if we give distinctive name when its assignment is to Call the individual. 

Interface is characterized with the catchphrase 'interface' .All properties and strategies with in the interface ought to be executed in case it is been utilized. That is the standard of interface. 

Interface 

interface IMobile 

{ 

Void Dial(); 

} 

interface ITelephone 

{ 

void Dial(); 

} 

public class Mobile : IMobile, ITelephone 

{ 

public void Dial() 

{ 

Console.WriteLine("Dial a number"); 

} 

} 

End 

Following the above rule and remembering the four mainstays of OOPS will lead you foster a decent program and interfacing it with this present reality. I trust you like this article. Remember to share your remark whether it's positive or negative. Sharing is important regardless.