十三、面向对象

一、 类

Python中 一切对象都有各自的类。

Python 中，除了内置的类之外，我们也可以自定义类。

  • 使用 class 关键字 定义一个类。

    1
    2
    3
    4
    5
    6
    7
    class BenzCar:    
        brand   = '奔驰'  # 品牌属性
        country = '德国'  # 产地属性
        
        @staticmethod
        def pressHorn(): 
            print('嘟嘟~~~~~~')

  • 类 和 变量 的 命名规则一样，类名的 首字母大写 。

  • brand 和 country 都是这个类的 属性 ，也叫 类属性

    • 类属性 的调用：

      1
      print(BenzCar.brand)

  • pressHorn 是类的方法 ，也叫 类方法

    • @staticmethod 则表示 该方法是这个类的 静态方法

    • 静态方法 的调用：

      1
      BenzCar.pressHorn()

二、 实例

1. 类和实例的关系

某种对象的类型 称为 类 ，他描述了这个类型的实例的 公共特征。

具体 的对象 称为 实例 。

  • 实例的产生（在类名后面加上 （））：

    1
    car1 = BenzCar()
    • car1 变量就对应一个 BenzCar 类型 的实例对象，具有 BenzCar 类 的一切属性和方法。

2. 实例属性

类里面的属性都是 类属性 ， 里面的方法都是 静态方法 。

  • 实例属性 ：每个实例独有的属性。

  • 实例属性 通常定义在类的 初始化方法 __init__ 里面。

    • 解释器在创建好实例后，会立即执行 __init__ 方法 。
    • 调用 __init__方法时，就将实例对象 传递给 self 参数。
    • self 参数变量 指向的 就是 实例对象 本身 。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    class BenzCar:    
        brand   = '奔驰'  
        country = '德国'  

        @staticmethod
        def pressHorn(): 
            print('嘟嘟~~~~~~')

        # 初始化方法, 注意前后各有两个下划线
        def __init__(self):
            self.color  =  'red'        # 颜色
            self.engineSN = '837873398' # 发动机编号

  • 类的静态方法在定义是，需要加上 @staticmethod 的修饰

    • 类的 实例方法 不需要任何修饰

  • 通常 类的实例方法，都是要 访问类的实例属性的。（包括：创建、修改、删除 类的实例属性）

  • 静态方法 不能访问 实例属性

  • 如果 实例属性名称 和 静态属性名称 重复了

    • 通过 类实例 访问该属性，访问的是 实例属性

    • 通过 类名 访问该属性，访问的是 类属性。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      class Car:
          brand = '奔驰'
          name = 'Car'

          def __init__(self):
              # 可以通过实例访问到类属性
              print(self.brand)

              # 定义实例属性和类属性重名
              self.name = 'benz car'

      c1 = Car()

      print(f'通过实例名访问name：{c1.name}')		# benz car
      print(f'通过类名  访问name：{Car.name}')	# Car

三、 类之间的关系

1. 继承关系

类之间可能存在 包含关系 ，当一个类 包含 在另一个类中时，我们将 包含的类 叫做 父类（基类） ，将被包含的类叫做 子类（派生类） 。

定义子类的时候必须指定他的父类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 父类
class BenzCar: 
    brand   = '奔驰'  
    country = '德国'  

    @staticmethod
    def pressHorn(): 
        print('嘟嘟~~~~~~')

    def __init__(self,color,engineSN):
        self.color  =  color  # 颜色
        self.engineSN = engineSN # 发动机编号
    
    def changeColor(self,newColor):
        self.color = newColor

# 子类
class Benz2016(BenzCar):
    price   = 580000
    model   = 'Benz2016'   


class Benz2018(BenzCar):
    price   = 880000
    model   = 'Benz2018'

子类 自动拥有 父类的一切 属性 和 方法

子类 调用 父类的 初始化方法

  • 子类初始化方法 和 父类的初始化 相同时，需要 显式的调用 父类的初始化方法，需要传入相应的参数。
1
2
3
4
5
def __init__(self,color,engineSN,weight):
    # 先调用父类的初始化方法
    BenzCar.__init__(self,color,engineSN)
    self.weight = weight 
    self.oilweight = 0
  • 调用 父类的 初始化方法，除了使用父类名称，还可以使用 super（） 函数
    • super 不仅可以调用 父类的初始化方法，也可以调用 父类的其他方法
1
2
3
4
5
def __init__(self,color,engineSN,weight):
    # 同样是调用父类的初始化方法
    super().__init__(color, engineSN)
    self.weight = weight 
    self.oilweight = 0

如果 子类 没有自己的初始化方法， 实例化子类时，解释器会自动调用 父类的初始化方法。

1
2
3
4
5
6
7
8
class Rect:
    def __init__(self):
        print('初始化 rect')

class Squre(Rect):
    pass

s = Squre()		# 初始化 rect

2. 类的组合关系

组合关系：一个类的实例属性中包含另一个类的实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 轮胎
class Tire:    
    def __init__(self,size,createDate):
        self.size  =  size  # 尺寸
        self.createDate = createDate # 出厂日期

class BenzCar:    
    brand   = '奔驰'  
    country = '德国'  

  
    def __init__(self,color,engineSN,tires):
        self.color  =  color  # 颜色
        self.engineSN = engineSN # 发动机编号
        self.tires   =  tires

# 创建4个轮胎实例对象
tires = [Tire(20,'20160808')  for i in range(4)]
car = BenzCar('red','234342342342566',tires)

奔驰汽车对象包含 4个两台对象 和 Tire 对象