Object-oriented Programming (OOP) Overview

Object-oriented Programming (OOP)

Object-oriented programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data fields and methods to manipulate the data. OOP allows you to create robust, reusable code by organizing it into modular units called objects. Here's an overview of some key concepts in OOP:

Polymorphism

Polymorphism is a feature of OOP that allows objects of different classes to be treated as objects of a common superclass. This means you can use methods and properties on these objects without knowing exactly which type of object it is. There are two types of polymorphism:

Subtype Polymorphism or Covariance

Subtypes inherit the behavior of their supertype. This means if you have a function that accepts Foo, then any subtype such as Bar would also work. For example:

def my_func(param):
    pass  # do something with param

## Calling this will work because Bar is a subtype of Foo
my_func(MyBar())

Parameter Polymorphism or Contravariance

Parameter polymorphism is when a parameter has multiple types and we don't know what type we will get. It can be seen at runtime, not compile time. An example of this could be:

def foo(bar):
    return bar * 2

print(foo('hello'))  # hellohello
print(foo())     # 2

Inheritance

Inheritance is one of the fundamental concepts of OOP. It refers to creating new classes from existing ones by inheriting attributes and functions. When a class inherits from another class, it gains access to all of its parent's properties and methods. Here's how it works:

class BaseClass():
    def method(self):
        print("Calling BaseClass's method")
        # other code here

class DerivedClass(BaseClass):
    def method(self):
        print("Calling DerivedClass's method instead")
        # other code here

derived = DerivedClass()
derived.method()  # Output: Calling DerivedClass's method instead

Object Relationships

Object relationships describe how objects interact and communicate with each other within your application. There are several types of object relationships:

Aggregation

Aggregation describes a relationship between two objects where one contains instances of the other. The child object can exist independently of the parent. This kind of relationship is often used for composition and association.

Association

Association represents an interaction between objects, where one object sends messages to another. However, no ownership exists in either direction.

Containment

Containment occurs when one object owns another object. Unlike aggregation, containment implies strong ownership; typically, the owned object cannot survive outside the owner.

Composition

Composition is similar to containment but more restrictive. It denotes a temporary binding of instances into a single aggregate while maintaining their individuality and independence.

OOP provides a way to model systems in terms of objects, capturing real-world structures and behaviors. By understanding concepts like polymorphism, inheritance, and object relationships, developers can create maintainable, modular software systems that adapt and grow over time.