Object-oriented programming for beginners: a simple explanation with examples

Welcome to the fascinating world of programming! Today we will talk about object-oriented programming (OOP) — an approach to writing code that helps create powerful and flexible programs. Don't worry if it sounds complicated! Now let's break it down, and you'll see that OOP is not as scary as it seems. 😊

What is object-oriented programming?

Object-oriented programming is a way of organizing code that uses objects and classes. Imagine that the program is like a constructor that consists of many small blocks. These blocks are called objects.

• Object is a specific element with data and behavior. For example, a car, a cat, or a book are all objects. Each object has its own unique properties and actions that it can perform.

• Class is a template from which objects are created. We can say that the class is a recipe, and the object is a ready-made dish. The class describes what characteristics and behavior the object will have.

For example, imagine the "Cat" class. It can have properties such as "color" and "weight", and actions such as "meow" and "jump". When you create a specific cat, for example, black and weighing 4 kg, you create an object of this class.

Why do we need OOP?

The OOP makes the code logical and easy to understand. Instead of writing a long list of commands, you can divide them into small blocks — objects. This makes it easier to work with the code, allows you to reuse it and simplify making changes. 🙌

Here are some examples of when OOP becomes indispensable:

• Creating complex programs: when a project is too large, dividing it into objects makes it easier to manage. Imagine a LEGO constructor — it is much easier to work with small blocks than with one huge piece.

• Code reuse: you can create classes and use them many times without rewriting everything from scratch. For example, if you have a "Car" class, you can create many cars with different characteristics, but with a common logic of operation.

• Ease of understanding: instead of a bunch of unrelated functions, you will have objects, each of which is responsible for its part of the work. This makes the program more readable and easier to understand by other developers.

In addition, OOP avoids code duplication. You can create one class and use it in different parts of the project, which makes your code cleaner and more maintainable.

Basic principles of the OOP

In order to better understand the OOP, it is important to know about the four main principles:

1. Encapsulation This is a way to hide the details of the object implementation. Imagine you have a TV. You can turn it on using the remote control, but you don't see exactly how it works inside. The same is true in programming: objects hide their complex internal logic and offer only easy-to-use methods. This protects data from incorrect use and makes working with objects easier.

   For example, in the "Car" class, the internal engine start mechanisms can be hidden, and the user can simply call the start_engine() method.

2. Inheritance Inheritance allows you to create new classes based on existing ones. For example, if we have an "Animal" class, we can create a "Dog" class that will inherit the properties of the animal, but will add its own features, such as "barking". 🐕

   This is very convenient, since you can reuse the code and add only those characteristics that distinguish the new class from the base one. For example, all animals can move, but only dogs can bark, and this functionality can be added separately.

3. Polymorphism This is the ability to use the same code to work with different objects. For example, we have a "Vehicle" class, and we can create methods that will work equally well for both a car and a bicycle. Polymorphism allows you to use a common interface for different types of objects.

   Imagine that you have a move() method that is called for objects of the "Vehicle" class. This method can be implemented differently for a bicycle and for a car, but the method call will be the same.

4. Abstraction Abstraction is the selection of only the most important characteristics of an object, hiding unnecessary details. For example, when describing a car, we will talk about its color, speed and type of engine, but we will not mention what the steering wheel is made of.

   Abstraction helps you focus on key characteristics without bothering with details that are not important for the current task. This simplifies the design and understanding of objects.

A simple example of OOP in Python

Let's write a small code example to make it even clearer:

class Car:
    def __init__(self, brand, model, color):
        self.brand = brand  # Machine brand
        self.model = model  # Model
        self.color = color  # Color

    def start_engine(self):
        print(f"{self.brand} {self.model} starts the engine! 🚗💨")

    def stop_engine(self):
        print(f"{self.brand} {self.model} is choking the engine.")

# Create a Car class object
my_car = Car("Toyota", "Camry", "Blue")

# Using object methods
my_car.start_engine()
my_car.stop_engine()

In this example:

• We have created class Car with characteristics brand, model and color.

• We use the start_engine() and stop_engine() methods to make the car "start the engine" or "stop the engine".

• Created by object my_car, and this car has specific properties ("Toyota", "Camry", "blue").

This example shows how easy it is to create objects and work with them using methods to control their behavior.

Examples of OOP in JavaScript

Let's look at an example of OOP in JavaScript:

class Animal {
  constructor(name, sound) {
    this.name = name;  // Animal name
    this.sound = sound;  // The sound it makes
  }

  makeSound() {
    console.log(`${this.name} makes a sound: ${this.sound}`);
  }
}

// Create an Animal class object
const cat = new Animal("Cat", "meow");

// We use the object method
cat.makeSound();  // The cat makes a sound: meow

In this example:

• We have created class Animal with characteristics name and sound.

• We use the makeSound() method to make the animal make a sound.

• Created by object cat with the name "Cat" and the sound "meow".

Example of OOP in PHP

Now let's see how it might look in PHP:

<?php
class Person {
    public $name;
    public $age;

    public function __construct($name, $age) {
        $this->name = $name;  // Person's name
        $this->age = $age;  // Age of the person
    }

    public function introduce() {
        echo "Hi, my name is {$this->name}, and I am {$this->age} years old.";
    }
}

// Create a Person class object
$person = new Person("Alexey", 25);

// We use the object method
$person->introduce();  // Hi, my name is Alexey, and I am 25 years old.
?>

In this example:

• We have created class Person with characteristics name and age.

• We use the introduce() method to make a person introduce himself.

• Created by object $person with the name "Alexey" and the age of 25.

What do you need to start working with the OOP?

To start working with the OOP, you need:

1. Basic knowledge of the programming language - for example, Python, JavaScript or PHP. You need to understand how variables are declared, what functions are and how to work with them.

2. Understanding how to create classes and objects — we just looked at that! Try to create a couple of classes yourself to consolidate your knowledge.

3. Practice, practice, and practice again! Write a few small programs using classes and objects to consolidate the material. For example, try creating classes to describe animals or vehicles.

Practice is a key aspect of learning programming. The more you experiment with creating classes and objects, the better you will understand how everything works.

Why study the MEP?

If you are just getting started with programming, you may find that OOP is something complex and unnecessary. But it's not! OOP is an important concept that helps you think about programming in a more structured way and solve more complex problems.

When you learn to use OOP, it will be easier for you to write complex programs, understand someone else's code and develop as a programmer. In the future, after studying OOP, you will be able to work on large projects, such as games, applications or even entire websites. 😎

OOP also facilitates teamwork. When code is organized into classes and objects, it is easier to understand and modify. If one developer creates a class, others can easily use it in their parts of the program without going into the details of the implementation.

In addition, knowledge of OOP opens the door to learning other popular programming languages, such as Java, C++, C#, and helps you become a more sought-after specialist in the labor market. Companies are often looking for developers who can write clean and supported code, and OOP is one of the keys to this.

Conclusion

That's it! We got acquainted with the basics of object-oriented programming, learned why it is needed, and considered a simple example of code. OOP is a great tool that helps you write clear, structured and easy-to-maintain code.

Don't be afraid to practice and try new approaches! The more you experiment, the more you will understand how everything works, and the more confident you will feel in programming. 💪

If you are interested in this topic, write to us and we will mini-course on working with Docker in the simplest and clearest language possible. 💬🚀