Ludovic Frank - Freelance developer

Object-oriented programming, having fun with attributes, methods and classes...

ionicons-v5-k Ludovic Frank May 12, 2023
97 reads Level: intermediate

Hello, hello?

Have you ever watched a child playing with "Legos"? Stacked one on top of the other, they create complex structures that are both unique and fundamentally similar, because they all share the same basic elements...

What if I told you that playing with Legos is a bit like our topic for today...

Welcome to the concept of object-oriented programming (OOP)! It may sound like an obscure concept, a maze of jargon designed to confuse, but fear not, it will!

We're about to embark on an exciting journey that will illuminate this topic and take you from novice to OOP ninja (well ... maybe not! but still?). The future doesn't wait, and every second that passes sees the creation of countless new "classes", new "attributes" and new "methods" in the world.

Are you ready to decode the mysteries of OOP? Let's get started! Let's get started!

Software development

So, what is programming or software development?

Imagine you're a puppeteer, but instead of pulling the strings of a little wooden Pinocchio, you're controlling your computer. You ask it to perform specific tasks, such as displaying a web page, calculating an equation or even running a video game. It feels like you're wielding power over your machine, doesn't it?

Basically, programming is a way of telling a computer what to do. But here's the rub: computers, unlike us smart, genius humans (what the hell??), don't understand human languages. They speak their own language, binary (a series of 1s and 0s), and it's not very user-friendly.

So, to communicate with computers, we have to use a programming language.

The many "flavors" of programming

Programming languages are like ice cream. There are tons of flavors (or types), and while some prefer the simplicity of vanilla (like Python), others prefer something a little more complex with lots of toppings (like C++).

There are generally three main types of programming:

  • Procedural programming: This is like a recipe for your favorite dish. You have a list of ingredients (data) and a set of instructions (procedures) which you follow in a specific order to create the dish. Procedural programming involves writing procedures or methods that perform operations on the data, like making a sandwich or a cake. It's about doing things in order, one step at a time, just like following a recipe.
  • Functional programming : Suppose you've become a cook who no longer needs to follow recipes. You now create dishes based on functions (mixing, cooking, etc.) and ingredients. In functional programming, the output depends solely on the input. As in cooking, you put in ingredients (input) and get a dish (output). This style avoids state changes and mutable data (modifying data directly without going through the function), so these functions are called "pure" functions. In my opinion, functional programming is the most difficult to understand, which is just as well, since it's not today's topic?
  • Object-oriented programming (OOP): Remember the Lego analogy? This is where it comes in. OOP involves creating objects (like Lego blocks) that have certain properties and behaviors. These objects interact with each other to make the whole program work. It's like creating a Lego city with different types of blocks, each with its own characteristics, working together to create an animated Lego metropolis.

Each type of programming has its advantages and disadvantages, and the one you choose to use often depends on the task in hand, just as you wouldn't use a hammer to cut a piece of wood...

After that, some "types" are, I find, harder to get to grips with than others (I'm talking about you, the functional one).

But for now, we're going to concentrate on object-oriented programming. So, fasten your seatbelts, because we're about to get "objectified" (in a good way)!

In the next section, we'll look at the definition, history and importance of OOP. So stick around if you're interested?

Discover the world of object-oriented programming (OOP)

Now that we've delved into the world of programming, it's time to go deep: the world of object-oriented programming, or as we like to call it: OOP.

So, what is OOP?

OOP explained - It's all about objects!

Simply put, OOP is a programming paradigm (a fancy term for a style or way of programming) in which we organize our code around objects...

An object is whatever you want it to be! It can be a person, a car, a bank account or even a pixel on your screen. The essential point is that objects are like the DNA of OOP. They contain data (called attributes) and code to manipulate that data (called methods).

Imagine a "car" object. It has attributes such as color, model and current speed, as well as methods such as accelerate, brake and turn. In OOP, you create instances of these objects and make them interact with each other, much as you would with little cars.

The history of OOP

The concept of OOP didn't appear overnight. Like most brilliant things, it evolved over time. The first programming language to use OOP principles was Simula, developed in the 1960s to simulate real-world systems. However, it was the Smalltalk language, developed in the 1970s, that really brought OOP into the limelight.

Since then, many other languages have adopted OOP principles, including the very popular Java and Python.

And like a fine wine, OOP has improved over time, proving its usefulness in a variety of applications (that sjte internet, for example?).

Why is OOP important?

You may be asking, "Why should I care about OOP?". Well, OOP is as important to software development as coffee is to an all-night code session (yes, I've been there?). Here's why:

  • Modularity: OOP allows complex problems to be broken down into smaller, more manageable elements. Each object is like a mini-program, with its own data and logic. This makes debugging and maintaining your code easier than remembering your password (it's not "password", is it??).
  • Reuse: Objects can be reused from one program to the next, just like your favorite cup of coffee that keeps you going until the end of each code the end of each code session (what, am I trying to stress that developers drink a lot of coffee? Just a little ...). This saves time, reduces errors and makes the code more consistent.
  • Scalability: OOP is perfect for large, complex systems. It allows several developers to work simultaneously on different parts of a project without causing major conflict.
  • Easy to understand: OOP models real-world entities, making code easier to understand, even for a novice developer. It's like learning a new language by immersing yourself in a country where it's spoken.

In short, OOP is a game-changer (well, it has been a game-changer, because it's so widespread today). It's not just a programming style; it's a way of thinking, a paradigm that guides you to approach problem-solving as if you were building with Legos, one block (or object) at a time.

Are you still with me? Great! Because in the next section, we're going to delve into the basic concepts of object-oriented programming. We'll be talking about classes, attributes, methods and much more! So, grab a cup of coffee (or tea, if you prefer) and let's continue digging deep into object-oriented programming!

The fundamental concepts of OOP

Right, it's time to dive into the basic concepts of OOP. Don't worry, I've got my translator ready to convert developer language into human language. Fasten your seatbelts, here we go!

Objects and classes: the yin and yang of OOP

Remember the Lego analogy? In OOP, an "object" is like a simple Lego block. Each object is an instance of a "class", which defines the attributes and methods common to all objects of that type (yes, it sounds complicated, but don't worry).

Think of a class as a blueprint for creating objects. For example, suppose we have a class called "Dog". This class defines attributes common to all dogs, such as breed, age and color, as well as methods such as barking, eating and sleeping. Each dog in your program would then be an object created from this class, with its own set of attributes.

Attributes and methods: the what and the how

Attributes" are the characteristics of an object, the details that define it. For example, in our "Dog" class, breed, age and color would be attributes. They are adjectives that describe an object.

Methods", on the other hand, are the actions an object can perform. They are verbs. In our "Dog" class, barking, eating and sleeping would be methods.

Inheritance: like father, like son

In OOP, we speak of "inheritance" when a class (the child) inherits attributes and methods from another class (the parent). This allows code to be reused and organized logically and hierarchically.

Think of it as true inheritance. If your parents leave you a classic car, you "inherit" it. Similarly, if we create a class called "Poodle" that inherits from the "Dog" class, the "Poodle" class will automatically have the same attributes and methods as the "Dog" class. Poodles are little dogs, after all!

Polymorphism: One name, many forms

"Polymorphism" is a big, scary word that simply means "many forms". In OOP, it refers to the ability of an object to take on several forms.

Let's take the example of our Dog class with a method called "sound". For a Dog object, the sound could be "bark". But if we have another object of class Bird, the sound could be "chirp". The same "sound" method name behaves differently in different classes. This is polymorphism in action!

Encapsulation: Keeping secrets

"Encapsulation means hiding data. It's about protecting the attributes and methods of a class from outside interference and abuse. It's a protective bubble that shields an object's inner workings from the rest of the program.

It's like a secret padlocked diary. You (the object) can write to it (modify attributes) and read it (call methods), but nobody else can, unless you provide them with a key (access methods, often called "getter" and "setter").

Abstraction: hide the complexity, show the essentials

Finally, "abstraction" involves simplifying complex systems by modeling them in such a way as to highlight their essential features and hide the details. It's like driving a car: you don't need to know how the engine works to drive it.

In OOP, abstraction creates a simple, high-level interface for complex code, making it easier to understand and use. It's about stepping back to see the forest (the overall functionality) rather than getting lost in the trees (the details of the code).

Examples and use cases of object-oriented programming

Now that we've covered the theory of OOP, let's take a look at it in action. Because, let's be honest, "seeing is believing", and I'm sure you're eager to see these concepts "in real life".

OOP in the wild

Object-oriented programming is ubiquitous in the world of programming. From games to web development, from mobile applications to artificial intelligence, it can be found just about everywhere:

  • Games: Video games are an excellent example of object-oriented programming. Each character in a game can be an object with attributes (such as health, speed and power) and methods (such as run, jump and attack). This allows game developers to create a variety of unique characters by simply changing attributes or modifying methods.
  • Website development: Websites often use OOP for user interaction. For example, a user object may have attributes such as username and password, and methods for logging in, logging out or updating profile information, and in fact... for my CMS, the article you're reading, is an object.
  • Database systems: In a database, each table can be considered as an object with its own properties and methods. This makes it easier to manipulate and interact with the data - the same as above, in my database, and article is an object?

Let's roll up our sleeves and take a look at some real-life code examples in several popular OOP languages: Python, Java, C++ and PHP.

A few examples in various programming languages

Object-oriented programming with Python

Python, with its simple syntax and powerful capabilities, is an excellent language for demonstrating OOP. Let's take the example of our "Dog" class:

Here, we've defined a "Dog" class with "breed" and "color" attributes, and a bark() method. We then created a my_dog object from the "Dog" class and used its attributes and methods. Pretty cool, eh?

Java and the art of object-oriented programming

Java is a pillar in the world of OOP. Let's see what the Dog class would look like in Java:

Java is a little more verbose than Python, but the concepts remain the same. We've defined a Dog class with attributes and methods, and created a myDog object from it.

C++ and object-oriented programming

C++, a powerful language with complex syntax, offers solid support for OOP. The use of classes and objects is at the heart of C++. Let's see what our trusty Dog class would look like in C++ :

In this code, we do the same thing as in the other two languages, always creating, instantiating and using a class.

The syntax and structure of C++ may seem a little intimidating, especially if you come from a language like Python or PHP, but the principles of OOP remain consistent.

PHP and the object

PHP, originally designed as a scripting language for the web, also supports object-oriented programming and uses it extensively. Let's return to our Dog class in PHP:

Once again, we're doing exactly the same as before, creating, instantiating and using a class and its methods.

As you can see, the structure is quite similar to that of other object-oriented programming languages. This shows the beauty and consistency of OOP object-oriented programming across different languages. Even if the syntax varies, the underlying principles remain the same.

Note that here, attributes are displayed as "public", which is normally never done, they are accessed via methods, and the attributes remain "private".

Differences between object-oriented programming and other programming paradigms

Now that we've acquired a good grounding in OOP, it's time to put it to the test. Let's pit our new knowledge against other programming paradigms and see what happens.

Procedural programming vs. OOP: the old guard versus the new kid on the block

Remember those old black-and-white movies? Procedural programming is a bit like that: classic, straightforward and a little linear. It involves writing a list of instructions for the computer to follow, step by step. It's a bit like a recipe: do this, then this, then that.

Object-oriented programming, on the other hand, is like a modern film with multiple plots and flashbacks. It's about creating objects, defining their attributes and deciding what actions they can take. The emphasis is on the objects and their interactions, not on the sequence of actions.

Functional programming vs. OOP: the mathematician versus the realist

Functional programming is like a pure mathematician: it loves immutability, avoids edge effects and treats functions like first-class citizens. Imagine a perfectly organized library where every book is always in its place and you're not allowed to bring in your own books (or modify those already there).

Object-oriented programming, on the other hand, is like a bustling city: it thrives on interaction, change and real-world modeling. It's about encapsulating data and behavior in objects and letting them interact, just like the inhabitants of a city.

Advantages and disadvantages of loop distribution: the good, the bad and the ugly

Like all technologies in the development world, object-oriented programming (OOP) has its fans and detractors, so let's take a look at some of its advantages and disadvantages.

Advantages of OOP

  • Modularity: Object-oriented programming lets you break down your program into smaller pieces, making it easier to write, maintain and reuse code.
  • Abstraction: Object-oriented programming hides complex details and shows only essential features, making it easier to understand and use.
  • Inheritance: Object-oriented programming allows classes to inherit features from other classes, which promotes code reuse.

Disadvantages of OOP

  • Resource consumption: OOP can be more resource-intensive for the machine running the code than simple procedural code.
  • Complexity: The emphasis on abstraction and encapsulation can make code harder to debug and system architecture harder to understand.
  • Not suitable for all problems: While OOP is ideal for modeling complex systems, it's not always suited to simpler tasks or problems that don't naturally lend themselves to an object-oriented approach.
  • The "codebase" can sometimes be very large: For reasons of abstraction, you can end up with a much larger codebase containing many more files.

Ultimately, the best programming paradigm depends on the problem to be solved, the specific requirements of the project and the developer's preferences. Like a tool in a toolbox, every paradigm has its place, and OOP is no exception.

How do I get started with OOP?

Now that we've covered the subject of OOP, you may want to dive right in. Here are a few ideas to get you started:

Embarking on the OOP adventure can be very exciting, provided you have the right resources.

  • Books: If you like lecture, the book "Head First Object-Oriented Analysis and Design" is a good place to start. It uses a visually rich format to stimulate your mind and make complex subjects more accessible.
  • Online courses (paid): Websites such as Coursera, Udemy and Codecademy offer courses on OOP. These interactive courses often include videos, quizzes and practical code exercises.
  • Tutorials: Websites such as Openclassroom, W3Schools and Mozilla Developer Network (MDN) offer comprehensive OOP tutorials in various languages.

As far as tools are concerned, a good integrated development environment (IDE) will be your most important companion. Personally, I use the Jetbrains IDEs a lot, and PHPStorm most often, since I code a lot with PHP.

There are other development environments which, unlike Jetbrains, are free. The best-known is Visual Studio Code, but if you want to get into the Microsoft world (because C# is also OOP), there's Microsoft Visual Studio, which is often found in companies, and has a free version.

Advice for beginners

As an OOP beginner, here are a few tips to keep in mind:

  • Start simply: Start with the basics. Understand classes, objects, attributes and methods. Then move on to more complex concepts such as inheritance, polymorphism and abstraction.
  • Practice, practice, practice: The more you code, the more you learn. Try to implement what you learn in small projects.
  • Ask for help: Don't be afraid to ask for help. Websites like StackOverflow are full of people ready to help you.
  • Be patient: Learning OOP is like learning a new language. It takes time to master. Don't rush it, and celebrate your progress.

That's all there is to it! With these resources and tips, you're ready to embark on your OOP adventure. Remember, it's not about getting there quickly, it's about taking the time to learn. In the dev and technology professions, you'll be learning all the time anyway.


As this article draws to a close, I've tried to give you the basics on OOP and objects (instantiated classes, just to check if you've been following along...).

In the dev world, you'll find it everywhere, unless you're using Redux, in which case it's functional.

Good luck and see you next time?