Tackling Object Oriented Programming

For newbies, learning object-oriented programming might be a challenge. Encapsulation, inheritance, and polymorphism are three of the most common ways that new programmers are introduced to OOP. The trouble is that once you understand the origins of these notions, they become quite easy to grasp. Where are the roots?

In object-oriented programming, your program will be split into several small, manageable, reusable programs. Each small program has it’s own identity, data, logic and how it’s going to communicate with the rest of the other small programs.

So what is an object? How about a class?

Objects

When you think about objects, you should consider real-life scenarios. Object-Orientation was created to bring it closer to reality, making it simpler and more realistic.

What are the Objects? Well, Objects could be:

• Something visible for you, like the car, phone, apple, duck, lamp.
• Something that you can’t touch, like the Time, Event, Account.

Each object has its own set of attributes and behaviors. Objects are distinct from each other. They have their own existence and identity, which is independent from that of other things.

What exactly do we mean when we say “attributes”?

It refers to the features or attributes of an object, such as the weight and color of a duck. They describe an object’s present state. One object’s status is unrelated to the state of another. Perhaps one of your ducks will be white and the other black.

What exactly do we mean when we say “behavior”?

Behavior refers to the things that an object can do, such as fly in the instance of a duck. Another example is accounts, where we may deposit or take money from any account. Again, each account is completely separate from the others. We may put money into one account and withdraw money from another.

Before we leave the Objects section, it’s important to remember that objects are nouns, not behaviors or properties. It’s important to understand the difference between an object and a behavior or a property.

The challenge now is: how do we build these objects in our program?

They don’t appear in our program by themselves, and in order to do so, we’ll need to look at another term that goes hand in hand with the object: Class.

Class

What exactly is a class?
A class is the location where you can identify an Object’s behaviors and properties. As a result, an Object’s properties and behavior will be specified inside a class.

Encapsulation

We start reducing our software into little reusable, manageable bits rather to having a procedural, large program. Encapsulation refers to the notion of splitting our program down into separate mini-programs called classes, each with a set of related traits and actions.

Encapsulation also involves withholding a Class’s content until it’s absolutely required to disclose it. We need to limit access to our class as much as possible, so that we can only change the attributes and behaviors from inside it.

Inheritance

Abstraction means that instead of creating multiple classes, we can create a single generic class that contains all of the common and essential properties and behaviors of those classes, whereas inheritance means that we can inherit these common properties and behaviors so that we can create a new class that is based on an existing class rather than writing it from scratch.

Overriding In Inheritance

When the Super class is a Concrete class, overriding its methods is not a good case practice. As a result, programmers prefer to utilize Interfaces.

Polymorphism

Polymorphism is the property of an item that allows it to take on many distinct shapes, allowing us to do the correct thing at the appropriate moment.

That was quite a task, but we completed it! We began laying the groundwork for becoming fantastic object-oriented programmers. The most significant aspect of learning OOP is practicing it, although my experience is limited at the moment, I still have a long way to go.