面向对象三大特征是：

  • 封装 (Encapsulation)
  • 继承 (Inheritance)
  • 多态 (Polymorphism)

    封装

    封装就是隐藏内部实现的细节，只保留功能接口
    需求 :::info 定义一个洗衣机类，其中包含了打开/关闭洗衣机门、设置洗衣模式、设置马达转速、开始洗衣服等方法。
    在初始化时，需要传入品牌brand和容量capacity两个参数。洗衣机门的状态is_closed、洗衣模式__mode和马达转速motor_speed都有默认值。
    调用wash()方法时，会根据门的状态和模式来执行相应的操作，最终完成洗衣任务。 ::: 步骤：
  1. 定义WashMachine类，初始化时传入品牌和容量两个参数，并设置默认值。
  2. 定义打开/关闭洗衣机门的方法，通过修改is_closed属性来实现。
  3. 定义设置洗衣模式的方法，通过修改__mode属性来实现。
  4. 定义设置马达转速的私有方法，通过修改motor_speed属性来实现。
  5. 定义开始洗衣服的方法，根据门的状态和模式来执行相应的操作，最终完成洗衣任务。
  6. 实例化WashMachine类，传入品牌和容量两个参数，得到一个洗衣机对象。
  7. 调用打开/关闭洗衣机门的方法，模拟打开/关闭洗衣机门的操作。
  8. 调用设置洗衣模式的方法，传入一个参数，设置洗衣模式。
  9. 调用开始洗衣服的方法，根据门的状态和模式来执行相应的操作，最终完成洗衣任务。

实现

  1. class WashMachine:
  2.     def __init__(self, brand, capacity):
  3.         """
  4.         初始化
  5.         :param brand: 品牌
  6.         :param capacity:  容量
  7.         """
  8.         self.brand = brand
  9.         self.capacity = capacity
  10.         # 是否关闭
  11.         self.is_closed = False
  12.         # 模式 0:未设定模式 1:轻揉模式 2:狂揉模式
  13.         self.__mode = 0
  14.         # 马达转速
  15.         self.motor_speed = 0
  17.     def open_door(self):
  18.         self.is_closed = False
  19.         print('打开洗衣机门')
  21.     def close_door(self):
  22.         self.is_closed = True
  23.         print('关闭洗衣机门')
  25.     def set_mode(self, new_mode):
  26.         """
  27.         调节模式
  28.         :param new_mode:
  29.         :return:
  30.         """
  31.         if new_mode not in [1, 2]:
  32.             print('设置模式错误')
  33.         else:
  34.             self.__mode = new_mode
  36.     def __set_motor_speed(self, speed):
  37.         """
  38.         设置马达的转速
  39.         :param speed:  1000: 轻揉模式  2000:狂揉模式
  40.         :return:
  41.         """
  42.         self.motor_speed = speed
  44.     def wash(self):
  45.         if not self.is_closed:
  46.             # 洗衣机门是否关闭 ,没有关闭  提示
  47.             print('请关闭洗衣机门,哔哔哔哔...')
  48.             return
  49.         elif self.__mode == 0:
  50.             print('请设置模式')
  51.             return
  53.         # 执行下面的操作
  54.         print('放水...')
  55.         print('放满了...')
  56.         if self.__mode == 1:
  57.             print('轻揉模式, 洗内衣')
  58.             # 调节马达转速
  59.             self.__set_motor_speed(1000)
  60.             print('马达转速:{}'.format(self.motor_speed))
  61.             print('开始洗...')
  62.         elif self.__mode == 2:
  63.             print('狂揉模式, 洗外套')
  64.             # 调节马达抓霉素
  65.             self.__set_motor_speed(2000)
  66.             print('马达转速:{}'.format(self.motor_speed))
  67.             print('开始洗...')
  69.         print('洗完了')
  72. machine = WashMachine('海尔', 10)
  73. machine.open_door()
  74. machine.close_door()
  75. machine.set_mode(2)
  76. machine.wash()

封装的范围:

  1. 封装属性
  2. 封装成方法/函数
  3. 封装成类
  4. 封装模块和包

    继承

    继承指的是一个对象直接使用另一个对象的属性或方法
    继承的格式：
    class 子类名(父类名): ```python “””————————— 定义Person类 —————————“””

class Person: def init(self, name, age): self.name = name self.age = age

  1. def say_hello(self):
  2.     print('hello from ', self.name)

“””————————— 定义Student类继承Person —————————“””

class Student(Person): def init(self, name, age, height):

  1.     # 调用父类的初始化方法
  2.     super().__init__(name, age)
  3.     # 定义自己的属性
  4.     self.height = height

创建学生类

stu = Student(‘小明’, 15, ‘180’)

访问属性

print(“name: {} age: {} height: {}”.format(stu.name, stu.age, stu.height))

调用方法

stu.say_hello()

  1. `Student`类继承自`Person`类<br />可以使用`Person`类中定义的属性`name`和`age`以及方法`say_hello`
  3. <a name="EmkHb"></a>
  4. ## 多态
  5. 多态指的是一类事物有多种形态（一个类有多个子类）<br />多态的概念依赖于**继承**<br />![](https://cdn.nlark.com/yuque/0/2023/png/27903758/1684835177145-5d8d0d61-8c21-4ac4-9d08-ff213cb87e77.png#averageHue=%23f9f8f7&clientId=ue22aa816-85ad-4&from=paste&id=uda0a34e3&originHeight=240&originWidth=443&originalType=url&ratio=1&rotation=0&showTitle=false&status=done&style=none&taskId=u1eae5020-67d3-468f-9777-3085ca1060f&title=)<br />中国人、美国人、非洲人都是属于Human人类的子类<br />对于Human来说有多个子类就称为多态
  6. ```python
  7. """
  8. 多态案例
  9. """
  10. # 父类
  11. class Human:
  12.     def eat(self):
  13.         print('人类吃饭')
  15. # 中国人
  16. class ZhHuman(Human):
  17.     def eat(self):
  18.         print('中国人使用筷子吃饭')
  20. # 美国人
  21. class UsHuman(Human):
  22.     def eat(self):
  23.         print('美国人使用刀叉吃饭')
  25. # 非洲人
  26. class AfricaHuman(Human):
  27.     def eat(self):
  28.         print('非洲人直接用手吃恩希玛')
  31. # 函数
  32. def someone_eat(someone):
  33.     '''
  34.     接收一个具备吃eat功能的对象
  35.     '''
  36.     someone.eat()
  39. # 创建四个对象
  40. human = Human()
  41. zh_human = ZhHuman()
  42. us_human = UsHuman()
  43. africa_huamn = AfricaHuman()
  45. # 调用translate方法
  46. someone_eat(human)
  47. someone_eat(zh_human)
  48. someone_eat(us_human)
  49. someone_eat(africa_huamn)

someone_eat方法需要接收具备eat功能的对象,但是由于ZhHuman USHuman AfricaHuman都具备eat功能（继承了Human）。所以也可以传递到someone_eat方法中

扩展知识

鸭子类型

一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟可以被称为鸭子。这就是鸭子类型Duck Typing
对于上述多态中的的someone_eat

  1. class Dog:
  2.     def eat(self):
  3.         print('狗吃骨头')
  5. # 函数
  6. def someone_eat(someone):
  7.     '''
  8.     接收一个具备吃eat功能的对象
  9.     '''
  10.     someone.eat()
  12. dog = Dog()
  13. someone_eat(dog)

someone_eat需要传递一个具备eat方法的对象，但是Dog也具备eat功能,所以也可以传递运行
这是由于python是动态类型语言，不能像C++、Java等静态类型语言一样，限制传递的数据类型
只要运行时发现dog对象有这个功能，就可以在函数中使用

多继承

当一个类从多个父类继承属性和方法时，就称为多继承。
多继承格式:
class 子类(父类1,父类2...)

下面是一个使用多继承的示例案例，展示了一个动物类和一个能飞的特性类和游泳的特性类：

  1. class Animal:
  2.     def __init__(self, name):
  3.         self.name = name
  5.     def eat(self):
  6.         print(f"{self.name} is eating.")
  8.     def sleep(self):
  9.         print(f"{self.name} is sleeping.")
  12. class Flyable:
  13.     def fly(self):
  14.         print(f"{self.name} is flying.")
  17. class Swimmable:
  18.     def swim(self):
  19.         print(f"{self.name} is swimming.")
  22. class Duck(Animal, Flyable, Swimmable):
  23.     def __init__(self, name):
  24.         super().__init__(name)
  27. duck = Duck("Donald")
  28. duck.eat()   # 输出: Donald is eating.
  29. duck.sleep()   # 输出: Donald is sleeping.
  30. duck.fly()   # 输出: Donald is flying.
  31. duck.swim()   # 输出: Donald is swimming.

在上面的示例中，Animal是基类，Flyable和Swimmable是特性类。Duck类通过多继承从这些类继承了属性和方法。通过调用这些继承的方法，我们可以看到Duck对象具有吃、睡、飞和游泳的行为。

注意，在多继承的情况下，当多个父类中具有相同名称的方法时，解释器将按照方法解析顺序（Method Resolution Order，MRO）来确定使用哪个方法。在上述示例中，Python的默认MRO算法会按照类定义时的顺序来解析方法。在这个例子中，Duck类首先从Animal类继承方法，然后是Flyable类，最后是Swimmable类。