面向对象编程中的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...