13.面向对象

一、 类

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 对象