215 lines
11 KiB
Markdown
215 lines
11 KiB
Markdown
## 第18课：面向对象编程进阶
|
||
|
||
上一节课我们讲解了Python面向对象编程的基础知识，这一节课我们继续来讨论面向对象编程相关的内容。
|
||
|
||
### 可见性和属性装饰器
|
||
|
||
在很多面向对象编程语言中，对象的属性通常会被设置为私有（private）或受保护（protected）的成员，简单的说就是不允许直接访问这些属性；对象的方法通常都是公开的（public），因为公开的方法是对象能够接受的消息，也是对象暴露给外界的调用接口，这就是所谓的访问可见性。在Python中，可以通过给对象属性名添加前缀下划线的方式来说明属性的访问可见性，例如，可以用`__name`表示一个私有属性，`_name`表示一个受保护属性，代码如下所示。
|
||
|
||
```Python
|
||
class Student:
|
||
|
||
def __init__(self, name, age):
|
||
self.__name = name
|
||
self.__age = age
|
||
|
||
def study(self, course_name):
|
||
print(f'{self.__name}正在学习{course_name}.')
|
||
|
||
|
||
stu = Student('王大锤', 20)
|
||
stu.study('Python程序设计')
|
||
print(stu.__name)
|
||
```
|
||
|
||
上面代码的最后一行会引发`AttributeError`（属性错误）异常，异常消息为：`'Student' object has no attribute '__name'`。由此可见，以`__`开头的属性`__name`是私有的，在类的外面无法直接访问，但是类里面的`study`方法中可以通过`self.__name`访问该属性。
|
||
|
||
需要提醒大家的是，Python并没有从语法上严格保证私有属性的私密性，它只是给私有的属性和方法换了一个名字来阻挠对它们的访问，事实上如果你知道更换名字的规则仍然可以访问到它们，我们可以对上面的代码稍作修改就可以访问到私有的属性。
|
||
|
||
```Python
|
||
class Student:
|
||
|
||
def __init__(self, name, age):
|
||
self.__name = name
|
||
self.__age = age
|
||
|
||
def study(self, course_name):
|
||
print(f'{self.__name}正在学习{course_name}.')
|
||
|
||
|
||
stu = Student('王大锤', 20)
|
||
stu.study('Python程序设计')
|
||
print(stu._Student__name, stu._Student__age)
|
||
```
|
||
|
||
Python中有一句名言：“**We are all consenting adults here**”（大家都是成年人）。Python语言的设计者认为程序员要为自己的行为负责，而不是由Python语言本身来严格限制访问可见性，而大多数的程序员都认为**开放比封闭要好**，把对象的属性私有化并不是编程语言必须的东西，所以Python并没有从语法上做出最严格的限定。
|
||
|
||
Python中可以通过`property`装饰器为“私有”属性提供读取和修改的方法，之前我们提到过，装饰器通常会放在类、函数或方法的声明之前，通过一个`@`符号表示将装饰器应用于类、函数或方法。
|
||
|
||
```Python
|
||
class Student:
|
||
|
||
def __init__(self, name, age):
|
||
self.__name = name
|
||
self.__age = age
|
||
|
||
# 属性访问器(getter方法) - 获取__name属性
|
||
@property
|
||
def name(self):
|
||
return self.__name
|
||
|
||
# 属性修改器(setter方法) - 修改__name属性
|
||
@name.setter
|
||
def name(self, name):
|
||
# 如果name参数不为空就赋值给对象的__name属性
|
||
# 否则将__name属性赋值为'无名氏'，有两种写法
|
||
# self.__name = name if name else '无名氏'
|
||
self.__name = name or '无名氏'
|
||
|
||
@property
|
||
def age(self):
|
||
return self.__age
|
||
|
||
|
||
stu = Student('王大锤', 20)
|
||
print(stu.name, stu.age) # 王大锤 20
|
||
stu.name = ''
|
||
print(stu.name) # 无名氏
|
||
# stu.age = 30 # AttributeError: can't set attribute
|
||
```
|
||
|
||
在实际项目开发中，我们并不经常使用私有属性，属性装饰器的使用也比较少，所以上面的知识点大家简单了解一下就可以了。
|
||
|
||
### 动态属性
|
||
|
||
Python是一门动态语言，维基百科对动态语言的解释是：“在运行时可以改变其结构的语言，例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。动态语言非常灵活，目前流行的Python和JavaScript都是动态语言，除此之外如PHP、Ruby等也都属于动态语言，而C、C++等语言则不属于动态语言”。
|
||
|
||
在Python中，我们可以动态为对象添加属性，这是Python作为动态类型语言的一项特权，代码如下所示。需要提醒大家的是，对象的方法其实本质上也是对象的属性，如果给对象发送一个无法接收的消息，引发的异常仍然是`AttributeError`。
|
||
|
||
```Python
|
||
class Student:
|
||
|
||
def __init__(self, name, age):
|
||
self.name = name
|
||
self.age = age
|
||
|
||
|
||
stu = Student('王大锤', 20)
|
||
# 为Student对象动态添加sex属性
|
||
stu.sex = '男'
|
||
```
|
||
|
||
如果不希望在使用对象时动态的为对象添加属性，可以使用Python的`__slots__`魔法。对于`Student`类来说，可以在类中指定`__slots__ = ('name', 'age')`，这样`Student`类的对象只能有`name`和`age`属性，如果想动态添加其他属性将会引发异常，代码如下所示。
|
||
|
||
```Python
|
||
class Student:
|
||
__slots__ = ('name', 'age')
|
||
|
||
def __init__(self, name, age):
|
||
self.name = name
|
||
self.age = age
|
||
|
||
|
||
stu = Student('王大锤', 20)
|
||
# AttributeError: 'Student' object has no attribute 'sex'
|
||
stu.sex = '男'
|
||
```
|
||
|
||
### 静态方法和类方法
|
||
|
||
之前我们在类中定义的方法都是对象方法，换句话说这些方法都是对象可以接收的消息。除了对象方法之外，类中还可以有静态方法和类方法，这两类方法是发给类的消息，二者并没有实质性的区别。在面向对象的世界里，一切皆为对象，我们定义的每一个类其实也是一个对象，而静态方法和类方法就是发送给类对象的消息。那么，什么样的消息会直接发送给类对象呢？
|
||
|
||
举一个例子，定义一个三角形类，通过传入三条边的长度来构造三角形，并提供计算周长和面积的方法。计算周长和面积肯定是三角形对象的方法，这一点毫无疑问。但是在创建三角形对象时，传入的三条边长未必能构造出三角形，为此我们可以先写一个方法来验证给定的三条边长是否可以构成三角形，这种方法很显然就不是对象方法，因为在调用这个方法时三角形对象还没有创建出来。我们可以把这类方法设计为静态方法或类方法，也就是说这类方法不是发送给三角形对象的消息，而是发送给三角形类的消息，代码如下所示。
|
||
|
||
```Python
|
||
class Triangle(object):
|
||
"""三角形类"""
|
||
|
||
def __init__(self, a, b, c):
|
||
"""初始化方法"""
|
||
self.a = a
|
||
self.b = b
|
||
self.c = c
|
||
|
||
@staticmethod
|
||
def is_valid(a, b, c):
|
||
"""判断三条边长能否构成三角形(静态方法)"""
|
||
return a + b > c and b + c > a and a + c > b
|
||
|
||
# @classmethod
|
||
# def is_valid(cls, a, b, c):
|
||
# """判断三条边长能否构成三角形(类方法)"""
|
||
# return a + b > c and b + c > a and a + c > b
|
||
|
||
def perimeter(self):
|
||
"""计算周长"""
|
||
return self.a + self.b + self.c
|
||
|
||
def area(self):
|
||
"""计算面积"""
|
||
p = self.perimeter() / 2
|
||
return (p * (p - self.a) * (p - self.b) * (p - self.c)) ** 0.5
|
||
```
|
||
|
||
上面的代码使用`staticmethod`装饰器声明了`is_valid`方法是`Triangle`类的静态方法，如果要声明类方法，可以使用`classmethod`装饰器。可以直接使用`类名.方法名`的方式来调用静态方法和类方法，二者的区别在于，类方法的第一个参数是类对象本身，而静态方法则没有这个参数。简单的总结一下，**对象方法、类方法、静态方法都可以通过`类名.方法名`的方式来调用，区别在于方法的第一个参数到底是普通对象还是类对象，还是没有接受消息的对象**。静态方法通常也可以直接写成一个独立的函数，因为它并没有跟特定的对象绑定。
|
||
|
||
### 继承和多态
|
||
|
||
面向对象的编程语言支持在已有类的基础上创建新类，从而减少重复代码的编写。提供继承信息的类叫做父类（超类、基类），得到继承信息的类叫做子类（派生类、衍生类）。例如，我们定义一个学生类和一个老师类，我们会发现他们有大量的重复代码，而这些重复代码都是老师和学生作为人的公共属性和行为，所以在这种情况下，我们应该先定义人类，再通过继承，从人类派生出老师类和学生类，代码如下所示。
|
||
|
||
```Python
|
||
class Person:
|
||
"""人类"""
|
||
|
||
def __init__(self, name, age):
|
||
self.name = name
|
||
self.age = age
|
||
|
||
def eat(self):
|
||
print(f'{self.name}正在吃饭.')
|
||
|
||
def sleep(self):
|
||
print(f'{self.name}正在睡觉.')
|
||
|
||
|
||
class Student(Person):
|
||
"""学生类"""
|
||
|
||
def __init__(self, name, age):
|
||
# super(Student, self).__init__(name, age)
|
||
super().__init__(name, age)
|
||
|
||
def study(self, course_name):
|
||
print(f'{self.name}正在学习{course_name}.')
|
||
|
||
|
||
class Teacher(Person):
|
||
"""老师类"""
|
||
|
||
def __init__(self, name, age, title):
|
||
# super(Teacher, self).__init__(name, age)
|
||
super().__init__(name, age)
|
||
self.title = title
|
||
|
||
def teach(self, course_name):
|
||
print(f'{self.name}{self.title}正在讲授{course_name}.')
|
||
|
||
|
||
|
||
stu1 = Student('白元芳', 21)
|
||
stu2 = Student('狄仁杰', 22)
|
||
teacher = Teacher('武则天', 35, '副教授')
|
||
stu1.eat()
|
||
stu2.sleep()
|
||
teacher.teach('Python程序设计')
|
||
stu1.study('Python程序设计')
|
||
```
|
||
|
||
继承的语法是在定义类的时候，在类名后的圆括号中指定当前类的父类。如果定义一个类的时候没有指定它的父类是谁，那么默认的父类是`object`类。`object`类是Python中的顶级类，这也就意味着所有的类都是它的子类，要么直接继承它，要么间接继承它。Python语言允许多重继承，也就是说一个类可以有一个或多个父类，关于多重继承的问题我们在后面会有更为详细的讨论。在子类的初始化方法中，我们可以通过`super().__init__()`来调用父类初始化方法，`super`函数是Python内置函数中专门为获取当前对象的父类对象而设计的。从上面的代码可以看出，子类除了可以通过继承得到父类提供的属性和方法外，还可以定义自己特有的属性和方法，所以子类比父类拥有的更多的能力。在实际开发中，我们经常会用子类对象去替换掉一个父类对象，这是面向对象编程中一个常见的行为，也叫做“里氏替换原则”（Liskov Substitution Principle）。
|
||
|
||
子类继承父类的方法后，还可以对方法进行重写（重新实现该方法），不同的子类可以对父类的同一个方法给出不同的实现版本，这样的方法在程序运行时就会表现出多态行为（调用相同的方法，做了不同的事情）。多态是面向对象编程中最精髓的部分，当然也是对初学者来说最难以理解和灵活运用的部分，我们会在下一节课中用专门的例子来讲解多态这个知识点。
|
||
|
||
### 简单的总结
|
||
|
||
Python是动态语言，Python中的对象可以动态的添加属性。在面向对象的世界中，**一切皆为对象**，我们定义的类也是对象，所以**类也可以接收消息**，对应的方法是类方法或静态方法。通过继承，我们**可以从已有的类创建新类**，实现对已有类代码的复用。
|