Object-Oriented Programming

Overview

Definition

Object-Oriented Programming (OOP) is a programming paradigm that revolves around the concept of objects, which are instances of classes. Classes are user-defined data types that encapsulate data and behavior. They allow us to model real-world entities and their interactions through the use of attributes (data) and methods (functions).

Note: not all languages are built for OOP. But OOP can be injected into your code through a little creative programming

Use Cases

OOP is widely used in various domains, such as software development, game development, simulation, and more. It helps in creating modular, maintainable, and extensible code.

Pros & Cons

👍

Modularity

Code can be organized into self-contained objects, making it easier to understand and maintain.

Reusability

Classes and objects promote code reuse, reducing redundant implementations.

Encapsulation

Data hiding ensures that the internal representation of an object is hidden, and access to it is restricted to methods, promoting security and data integrity.

Inheritance

Inheritance enables the creation of hierarchies and facilitates code sharing and extension.

Polymorphism

Polymorphism allows objects of different classes to be treated as objects of a common superclass, promoting flexibility and generality.

👎

Complexity

OOP can introduce additional complexity, especially for smaller projects where simpler paradigms might suffice.

Overhead

It can lead to performance overhead due to dynamic dispatch and object creation.

Learning Curve

Understanding and mastering OOP concepts can be challenging for beginners.

class / struct Syntax

Pseudocode

CLASS Animal:
    ATTRIBUTES:
        name
        age
    METHODS:
        constructor(name, age)
        make_sound()
    END CLASS

FUNCTION main():
    animal1 = Animal("Buddy", 3)
    animal1.make_sound()
    animal2 = Animal("Charlie", 5)
    animal2.make_sound()
END FUNCTION

C++

#include <iostream>
using namespace std;

class Animal {
public:
    string name;
    int age;

    Animal(string name, int age) {
        this->name = name;
        this->age = age;
    }

    void make_sound() {
        cout << "Animal sound!" << endl;
    }
};

int main() {
    Animal animal1("Buddy", 3);
    animal1.make_sound();
    Animal animal2("Charlie", 5);
    animal2.make_sound();
    return 0;
}

Python

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def make_sound(self):
        print("Animal sound!")

def main():
    animal1 = Animal("Buddy", 3)
    animal1.make_sound()
    animal2 = Animal("Charlie", 5)
    animal2.make_sound()

if __name__ == "__main__":
    main()

Java

class Animal {
    String name;
    int age;

    Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void makeSound() {
        System.out.println("Animal sound!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Animal("Buddy", 3);
        animal1.makeSound();
        Animal animal2 = new Animal("Charlie", 5);
        animal2.makeSound();
    }
}

Rust

struct Animal {
    name: String,
    age: i32,
}

impl Animal {
    fn new(name: &str, age: i32) -> Animal {
        Animal {
            name: name.to_string(),
            age,
        }
    }

    fn make_sound(&self) {
        println!("Animal sound!");
    }
}

fn main() {
    let animal1 = Animal::new("Buddy", 3);
    animal1.make_sound();
    let animal2 = Animal::new("Charlie", 5);
    animal2.make_sound();
}

Golang

package main

import "fmt"

type Animal struct {
    name string
    age  int
}

func NewAnimal(name string, age int) *Animal {
    return &Animal{name: name, age: age}
}

func (a *Animal) makeSound() {
    fmt.Println("Animal sound!")
}

func main() {
    animal1 := NewAnimal("Buddy", 3)
    animal1.makeSound()
    animal2 := NewAnimal("Charlie", 5)
    animal2.makeSound()
}

Output

Animal sound!
Animal sound!