面向對象編程中的Python對象：封裝和抽象

一、封裝

封裝是一種將對象的屬性和方法綁定在一起的機制，使得他們在類的外部不可被訪問。這種機制在Python中很容易實現，通過在方法和屬性名前面加上雙下劃線 “__”，可以將它們變為私有的。

通過封裝，我們可以將類的實現細節隱藏起來，只暴露出一些必要的介面，使得外部的代碼不易受到內部實現的變化產生的影響。

class Student:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
 
    def show(self):
        print("Name: {}, Age: {}".format(self.__name, self.__age))
 
s = Student("Alice", 18)
s.show()
#輸出：Name: Alice, Age: 18
 
s.__name = "Bob"
#此處是錯誤的，因為__name是私有屬性
 
s.show()
#輸出：Name: Alice, Age: 18

二、抽象

抽象是面向對象編程中一個非常重要的概念。它可以將某個類抽象成一個抽象類，簡單的說就是只定義介面，不實現具體的功能。這樣，子類可以繼承這個抽象類，並且必須實現它定義的介面。

抽象的好處是提高了代碼的可維護性，使得程序的代碼結構更加清晰，更加易於擴展。

from abc import ABCMeta, abstractmethod
 
class Shape:
    __metaclass__ = ABCMeta
 
    @abstractmethod
    def area(self):
        pass
 
    @abstractmethod
    def perimeter(self):
        pass
 
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
 
    def area(self):
        return self.width * self.height
 
    def perimeter(self):
        return 2 * (self.width + self.height)
 
r = Rectangle(3, 4)
print(r.area())
#輸出：12
 
print(r.perimeter())
#輸出：14

三、屬性和方法的訪問控制

Python提供給了我們一些機制，用於控制屬性和方法的訪問。在類中，我們通常分為三個級別：公共、保護和私有。

• 公共：任何地方都可以訪問
• 保護：只有子類和當前類可以訪問
• 私有：只有當前類可以訪問

class Person:
    def __init__(self, name, age):
        self.name = name
        self._age = age #保護屬性
        self.__weight = 50 #私有屬性
 
    def say(self):
        print("{} says: I'm {} years old.".format(self.name, self._age))
 
    def __myself(self):
        print("{} is {} kg.".format(self.name, self.__weight))
 
p = Person("Tom", 25)
print(p.name)
#輸出：Tom
 
print(p._age)
#輸出：25
 
print(p.__weight)
#此處是錯誤的，因為__weight是私有屬性
 
p.say()
#輸出：Tom says: I'm 25 years old.
 
p.__myself()
#此處是錯誤的，因為__myself是私有方法

四、多重繼承

Python允許多重繼承，即一個類可以繼承多個類。這種繼承方式可以使代碼的復用性更高，但同時帶來了更加複雜的代碼邏輯。

多重繼承的好處是可以在不同的類中實現不同的功能，並且可以從多個類中繼承屬性和方法。但是它也加劇了代碼的不可控性和不確定性。

class A:
    def functionA(self):
        print("Function A")
 
class B:
    def functionB(self):
        print("Function B")
 
class C(A, B):
    def functionC(self):
        print("Function C")
 
c = C()
c.functionA()
#輸出：Function A
 
c.functionB()
#輸出：Function B
 
c.functionC()
#輸出：Function C

五、類的屬性和方法

在Python中，除了實例屬性和方法之外，還有類屬性和方法。類屬性和方法與類相關聯，而不是與實例相關聯。類屬性和方法可以通過類本身來調用。

class MyClass:
    name = "MyClass"
 
    @classmethod
    def method(cls):
        print("Calling Class Method...")
 
    @staticmethod
    def stMethod():
        print("Calling Static Method...")
 
m = MyClass()
 
print(m.name)
#輸出：MyClass
 
m.method()
#輸出：Calling Class Method...
 
m.stMethod()
#輸出：Calling Static Method...
 
MyClass.method()
#輸出：Calling Class Method...
 
MyClass.stMethod()
#輸出：Calling Static Method...