面向对象的概念

面向对象是将编程当成一个事物（实例化），而编程就是设置事物能够做什么事。
在面向对象编程过程中，有两个重要的组成部分：类和对象。

类

类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念。

  • 特征即是属性（变量）；
  • 行为即是方法（功能函数）。

类是用来创建对象的，先有类，再有对象。

对象

对象是由类创建出来的真实存在的事物。

面向对象的实现方法

定义类

Python2中，类分为：经典类和新式类。

  1. class 类名():
  2.     代码
  3.     ...
  4.     ...
  6. 其中：
  7.     类名要满足标识符命名规则，同时要遵循大驼峰命名习惯。

创建对象

对象又叫实例。

  1. 对象名 = 类名()

self

self指的是调用该类时的对象。

  • **self**存储的是由该类创建的对象的内存地址；
  • 同一个类可以创建多个对象，每个对象有自己的内存空间。 ```python

    创建类

    class Washer(): def wash(self):
    1.   print("能洗衣服。")
    2.   print(self)        # 等价于print(haier)

创建对象

haier = Washer()

使用对象——实例方法/对象方法

haier.wash()

  1. <a name="GRBuP"></a>
  2. # 添加和获取对象属性
  3. 对象属性既可以**在类外部添加和获取**，也能**在类里面添加和获取**。
  4. <a name="VsaAV"></a>
  5. ## 类外部添加对象属性
  6. ```python
  7. 对象名.属性名 = 值
  9. 如：
  10.     haier.width = 500

类外部获取对象属性

  1. 对象名.属性名
  3. 如：
  4.     print(f"haier洗衣机的宽度是{haier.width}")

类内部添加对象属性

  1. self.属性名 = 值

类内部获取对象属性

  1. self.属性名

魔法方法

在Python中，**__xx__()**的函数叫作魔法方法，指的是具有特殊功能的函数。

__init__()

用于初始化对象，主要用于对象属性的初始化。

  • __init__()方法，在创建对象时，默认会被调用，不需要手动调用；

  • __init__(self)中的**self**参数，不需要开发者传参，编译器会自动把当前的对象引用传递过去。 ```python

    定义类

    class Washer(): def init(self): # 初始化对象属性

    1.   self.width = 10
    2.   self.height = 20

    def printInfo(self):

    1.   print(f"洗衣机的宽度是{self.width},高度是{self.height}")

实例化对象

haier = Washer() haier.printInfo() # 洗衣机的宽度是10,高度是20

  1. <a name="l6gGI"></a>
  2. ### 带参数的`__init__()`
  3. ```python
  4. class Washer():
  5.     def __init__(self, width, height):    # 带形参
  6.         self.width = width
  7.         self.height = height
  9.     def printInfo(self):
  10.         print(f"洗衣机的宽度是{self.width},高度是{self.height}")
  13. # 实例化对象
  14. haier = Washer(19, 20)
  15. haier.printInfo()  # 洗衣机的宽度是19,高度是20

__str__()

当使用print输出对象时，默认打印对象的内存地址。如果类定义了**__str__()**方法，print输出对象时就会打印该方法中return的数据。

  1. class Washer():
  2.     def __init__(self, width, height):
  3.         self.width = width
  4.         self.height = height
  6.     def printInfo(self):
  7.         print(f"洗衣机的宽度是{self.width},高度是{self.height}")
  9.     def __str__(self):
  10.         return "这是洗衣机啊"
  13. # 实例化对象
  14. haier = Washer(19, 20)
  15. print(haier)  # 这是洗衣机啊

__del__()

当删除对象时，Python解释器默认调用**__del__()**方法。

  1. class Washer():
  2.     def __init__(self, width, height):
  3.         self.width = width
  4.         self.height = height
  6.     def printInfo(self):
  7.         print(f"洗衣机的宽度是{self.width},高度是{self.height}")
  9.     def __str__(self):
  10.         return "这是洗衣机啊"
  12.     def __del__(self):
  13.         print("对象已被删除！")
  16. # 实例化对象
  17. haier = Washer(19, 20)
  18. del haier  # 对象已被删除！

面向对象示例1——烤地瓜

  1. """
  2. 1.地瓜被烤的时间和对应的地瓜状态：
  3.     0-3分钟：生的
  4.     3-5分钟：半生半熟
  5.     5-8分钟：熟的
  6.     超过8分钟：烤焦了
  7. 2.用户可以按自己的需求添加调料
  8. """
  9. # 创建地瓜的类
  10. class Digua():
  11.     # 定义初始化属性
  12.     def __init__(self):
  13.         # 被烤时间
  14.         self.cookTime = 0
  15.         # 烤的状态
  16.         self.cookStatus = "生的"
  17.         # 调料列表
  18.         self.condiments = []
  20.     # 定义烤地瓜的方法
  21.     def cook(self, time):
  22.         """
  23.         烤地瓜的方法函数
  24.         :param time: 烤的时间
  25.         :return:
  26.         """
  27.         self.cookTime += time
  28.         if (self.cookTime >= 0) and (self.cookTime < 3):
  29.             self.cookStatus = "生的"
  30.         if (self.cookTime >= 3) and (self.cookTime < 5):
  31.             self.cookStatus = "半生半熟"
  32.         if (self.cookTime >= 5) and (self.cookTime < 8):
  33.             self.cookStatus = "熟了"
  34.         if self.cookTime >= 8:
  35.             self.cookStatus = "烤焦了"
  37.     # 定义添加调料的方法
  38.     def add_condiments(self, condiments):
  39.         """
  40.         添加调料方法
  41.         :param condiments: 添加的调料
  42.         :return:
  43.         """
  44.         self.condiments.append(condiments)
  46.     # 输出对象状态
  47.     def __str__(self):
  48.         return f"这个地瓜烤了{self.cookTime}分钟，状态是{self.cookStatus}，添加的调料是{self.condiments}。"
  51. # 创建对象
  52. digua1 = Digua()
  53. # print(digua1)
  54. digua1.cook(int(input("请输入你烤的时间：")))
  55. digua1.add_condiments(input("请输入你要添加的调料："))
  56. print(digua1)

面向对象示例2——搬家具

  1. # 将小于房子剩余面积的家具摆放在房子中
  2. class Furniture():
  3.     def __init__(self, name, area):
  4.         self.name = name
  5.         self.area = area
  8. class House():
  9.     def __init__(self, addr, area):
  10.         self.addr = addr
  11.         self.area = area
  12.         self.freeArea = area
  13.         self.furniture = []
  15.     def addFurniture(self, Object):
  16.         """
  17.         容纳家具方法函数
  18.         :param item: 家具的面积
  19.         :return:
  20.         """
  21.         if self.freeArea >= Object.area:
  22.             self.furniture.append(Object.name)
  23.             self.freeArea -= Object.area
  24.         else:
  25.             print("家具太大，剩余面积不足！")
  27.     def __str__(self):
  28.         return f"房子的地址是{self.addr}，占地面积是{self.area}，剩余面积是{self.freeArea}，家具有{self.furniture}。"
  31. # 创建家具对象
  32. bed = Furniture("双人床", 8)
  33. sofa = Furniture("沙发", 5)
  35. # 创建房子对象
  36. House1 = House("广州", 86)
  37. # 调用对象方法
  38. House1.addFurniture(bed)
  39. House1.addFurniture(sofa)
  40. print(House1)    # 房子的地址是广州，占地面积是86，剩余面积是73，家具有['双人床', '沙发']。