With the help of object-oriented programming, we can better model the complex needs that exist in the real world. In this post, I will explain the basics of object oriented programming. First, I will review the concepts and components, then its 4 principles with real examples.
Object Oriented Programming (OOP) is a programming method that is modeled on our real world. If you look around you, everything is an object! With the help of this method, we model all the execution of the program as objects and then use them.
In the first programming languages, we wrote the entire program in consecutive codes. After that, procedural methods came into use, where we divide the code into different pieces, each of which performs a specific operation. Then we call a programming function wherever we need to execute them.
If we want to do a project according to real world requirements, we will have very long codes. Let me continue my explanation with a simple example.
Suppose we want to implement a university management system. Students, professors and university employees will be part of this system. You probably agree that these three data types are all human, but each has different characteristics or access to the system.
In procedural mode we probably define three data types that are completely separate from each other. Now if we want to apply a small change in one of these common features, we have to repeat this change 3 times!
Next, you'll see how much easier it is to implement and apply system changes (maintainability) with object-oriented programming.
OOP Concepts
Four concepts or words are frequently used in object-oriented programming. So it is better to agree on these 4 at the beginning. These concepts are:
In very simple terms, a class is a general template (map) for our data type in the system. Each class has properties and behaviors that can be defined for all data of that type. Whenever we create a data from this pattern and determine its characteristics, we have an object of that class.
The operation of creating an object from a class is called instantiation (Create instance).
Class, method and property in programming
In the example of the university system, we have a very comprehensive data type called "human". Imagine the human concept in the real world. This entity has a general structure made up of a set of properties and behaviors. for example:
Whenever we define certain properties according to the "human" (class) model, an object is made from it. All the objects of this class have similar behaviors but will differ greatly from each other due to the difference in their properties.
Can you model an animal type (eg cat) as a class? Try to do this and if you have any questions, ask in the comments section of the post.
So far, we got acquainted with the concepts, or rather, the components of a program based on object-oriented programming. I will give more examples to help you fully understand these definitions.
Object-oriented programming has certain principles. That is, in addition to defining all the entities of the program based on classes, it is necessary to observe certain principles.
Of course, if we don't follow these principles or don't use them correctly, our program will still be an object-oriented program, but it won't have the necessary quality. These principles are used a lot in writing programs and understanding them will help you a lot.
Abstract means to limit the details to address the main process. Let me start with two examples from everyday life:
We end up expecting what we want to be done right and we have no control over how it is done! This is the meaning of abstraction. As consumers of a device, we don't need to know what interactions take place after a click is pressed to get the result. For us, only the result is important.
When defining behaviors (methods) and properties in object-oriented programming, we must pay attention to what level of abstraction the consumer of this class needs. What parts of the algorithm should we hide from the consumer?
Note that we use abstraction to achieve simplicity of use. That is, our goal is to make it easier to work with classes and methods.
Of course, every program is made up of different objects. Encapsulation principle tells us that everything should protect its properties. That is, it is better that other objects don't have direct access to the properties of other objects.
Suppose we want to implement an object-oriented chess game. The game of chess consists of pieces, each of which has different properties and behaviors. that's mean:
In a very simple implementation, we specify the location of the piece with a variable (property in the class) of type number. Also, because all pieces have the same behaviors and properties, we consider a main class for game pieces.
You might say that not all beads have the same behavior. Because the movement of the horse on the game board is very different from the movement of the rook. With the help of the next 2 principles in object-oriented programming, we can implement these minor differences.
For now, we focus on the fact that all beads have a position attribute (eg position) and a move behavior called move(). If the players (which are themselves another object) have direct access to the position value, we can't have any restrictions on how the pieces move.
For example, the user changes the position of his bead from x to y. Maybe this move is not allowed according to our game rules. So we should not allow players to directly access the position of the piece. In this case, the user calls the move() method and declares the desired position, if the position of the desired house is according to the rules, the piece moves.
Encapsulation can be defined for properties, methods, and even classes.
With the help of Inheritance, we can extend classes and add new features and behaviors to it. In the following 2 examples, I have illustrated a very simple example of inheritance in the real world:
If you look carefully, all cars have color and wheel features. But gas cars have a gas capsule and gas system in addition to other cars. The same is true for animals.
In object-oriented programming, when many properties and methods are shared between two (or more) classes, there is usually a larger class that contains the shared items and the classes inherit the subset from it.
Similar to the real world where every child inherits almost all the characteristics of its parents, it is the same in programming. Some inherited characteristics in a child may be strengthened or weakened, and a child also has non-shared characteristics with its parents. This case is also established in the inheritance of object-oriented programming.
Consider the example of an object-oriented university management program. In this program, the professor, student, and employee are all of the human class, but they have differences in their characteristics and behaviors; For example:
In this case, in object-oriented programming, we create a generic human-type class that has common methods and properties; That is, it walks, talks and has a name, national code and date of birth. Then teacher and student classes inherit from this class to implement their special abilities.
Depending on the system requirements, the professor is probably some kind of employee in the university. To better understand the concept of inheritance in programming, try to find examples of it in your daily life and generalize them.
Polymorphism allows us to have different implementations of the method. We have two types of polymorphism in object oriented programming. which we will get to know briefly in this section.
Polymorphism with Method Overriding: Suppose we have a class for geometric shapes that has a draw() method. The rectangle, pentagon, and circle classes inherit from this class and because their drawing methods are different, they rewrite this method.
Polymorphism with Method Overloading: In this case, there is no inheritance in object-oriented programming. Also, the name of the method and its output type (signature) do not change. We just have a few similar methods with different arguments (input parameters).
Suppose we want to implement the circle class in such a way that if draw() is called, it will draw a circle with a random radius, and if the size is specified in the input (draw(x)), it will draw a circle with the desired radius. Our pseudocode looks something like this:
public class Circle(){
// attribute
// some codes
public void draw(){
// draw with default radius
}
public void draw(int r){
// draw with radius = r
}
}
Object-oriented programming is very broad and sometimes confusing! But because its modeling is similar to the real world, understanding the concepts of object orientation becomes simple.
In this post, we learned the basics of object-oriented programming in a simple language. We have understood the concept of class, object, attribute and method and examined it with 4 basic principles.
I hope this post helped you understand the concepts better.