Object-oriented programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data and code. The data is in the form of fields (often known as attributes or properties), and the code is in the form of procedures (often known as methods).

Inheritance

Inheritance is the process of creating a new class by extending an existing class. The new class inherits all the properties and methods of the base class and can also add its own properties and methods.

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

    def speak(self):
        print("")

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

dog = Dog("Rover")
cat = Cat("Whiskers")
dog.speak()   # output: Woof!
cat.speak()   # output: Meow!

Encapsulation

Encapsulation is the process of hiding the implementation details of an object from the outside world. This is achieved by making use of access modifiers such as public, private, and protected. In Python, there are no explicit access modifiers, but you can achieve encapsulation by using underscore prefixes to denote private or protected attributes.

class MyClass:
    def __init__(self):
        self._protected_var = 10
        self.__private_var = 20

obj = MyClass()
print(obj._protected_var)   # output: 10
print(obj.__private_var)    # AttributeError: 'MyClass' object has no attribute '__private_var'

Polymorphism

Polymorphism is the ability of objects to take on different forms. In Python, this is achieved by using method overriding or method overloading.

class Shape:
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

shapes = [Rectangle(4, 5), Circle(7)]
for shape in shapes:
    print(shape.area())

Keywords

• Object Oriented Programming (OOP) (物件導向程式設計): A programming paradigm that organizes code using objects and classes to model real-world entities and relationships.
• class (類別): A blueprint for creating objects that defines attributes and methods.
• object (物件): An instance of a class containing data (attributes) and behavior (methods).
• method (方法): A function defined within a class that operates on instances of that class.
• attribute (屬性): A variable that is bound to an object or class, holding data relevant to that object.
• constructor (建構子): A special method, typically __init__, that initializes a new object's state when it is created.
• destructor (解構子): A special method, typically __del__, that is called when an object is about to be destroyed, used for cleanup.
• dunder method (雙底線方法): A special method with double underscores before and after its name (e.g., __init__, __str__) that enables built-in behaviors.
• inheritance (繼承): A mechanism where a new class (child) derives attributes and methods from an existing class (parent), representing a "is-a" relationship.
• parent(base) class (父類別/基礎類別): A class whose properties and methods are inherited by another class.
• child(derived) class (子類別/衍生類別): A class that inherits from a parent class and can extend or override its behavior.
• override (覆寫): To provide a new implementation for an inherited method in a child class.
• composition (複合): A design principle where a class is composed of one or more objects of other classes, representing a "has-a" relationship.
• encapsulation (封裝): The bundling of data and methods within a class, restricting access to internal details and protecting object integrity.
• private data (私有資料): Attributes intended to be hidden from outside access, usually denoted with a leading underscore (e.g., _data).
• public data (公有資料): Attributes that are accessible from outside the class without restrictions.
• public method (公有方法): Methods that are accessible from outside the class without restrictions.
• private method (私有方法): A method intended for internal use within a class, typically indicated by a leading underscore.
• utility method (工具方法): A method that performs a supportive or common function, often independent of instance-specific data.
• class method (類別方法): A method bound to the class rather than an instance, marked with the @classmethod decorator, and takes the class as its first parameter.
• class attribute (類別屬性): An attribute that is shared among all instances of a class.
• polymorphism (多型): The ability for different classes to be treated through a common interface, often by overriding methods.
• function overloading (函數重載): Defining multiple functions with the same name but different parameters.
• operator overloading (運算子重載): Defining special methods to customize the behavior of built-in operators for user-defined classes.
• method overriding (方法覆寫): Providing a new implementation for a method inherited from a parent class, allowing the child class to customize behavior.