来源：麦叔编程

作者：麦叔

面向对象是所有高级语言（Python，Java，C++等）的基石，是重中之重。

这个文章系列的目的是通过简单易懂的例子，深入浅出，让Python学习者牢固地掌握Python面向对象的概念和方法。

本系列包括：

• 面向对象(1) - 属性，构造方法，self关键词。
• 面向对象(2) - 实例方法 (本文)
• 面向对象(3) - 类属性和类方法
• 面向对象(4) - 继承和多态，以及一个综合小游戏案例

类的继承，父类，子类

看这张图：

1. 上面有一条小狗，代表了普通的狗。
2. 下面有警犬，牧羊犬和宠物犬，他们都是狗。
3. 但他们又有独特的特点，具有额外的属性或者技能。
4. 警犬有侦探功能，所以有detect()方法，有额外的属性ability，表示它的侦探能力等级。
5. 牧羊犬有保护养的功能，所以有protect()方法，有额外的num_of_sheeps表示它可以保护几只羊。
6. 宠物犬有唱歌的功能，所以有sing()方法，有额外的属性price表示价格。

动物界具有天然的继承关系，人类也是，我们一代代继承下来。继承了前辈们的属性和能力，又发展了自己独特的属性和能力。

在图中的例子，我们如何在程序中表示普通的狗，牧羊犬，警犬等呢？

我们可以把detect(), protect()等函数和属性直接加在Dog里面，但这并不合理，因为并不是所有的狗可以侦查，并不是所有的狗都可以保护养。

正确的做法是创建新的类，这些新的类继承Dog类：

• SheepDog 表示牧羊犬
• PoliceDog 表示警犬
• PetDog 表示宠物犬

在这里Dog被称为父类，SheepDog等被称为子类。

子类会自动拥有父类的属性和方法，自己也可以添加自己的独特属性和方法。

子类的定义

现在来定义SheepDog。先看看我们原来的Dog类：

#类是一个模板
class Dog:
    num_of_dogs = 0  # 类属性
    police_height = 60

    #构造方法 - 添加实例属性，做其他的初始化工作
    def __init__(self, name, height, power):
        self.name = name
        self.height = height
        self.power = power
        self.blood = 10
        print(f"{self.name}出生了，汪汪！")
        Dog.num_of_dogs += 1
    
    #狗叫
    def bark(self):
        print(f'我是{self.name}，汪汪汪！')

定义子类SheepDog

class SheepDog(Dog):
    '''牧羊犬，包括名字，高度，攻击力和能看护的养的个数'''
    def __init__(self, name, height, power, num_of_sheeps):
        super().__init__(name, height, power)
        self.num_of_sheeps = num_of_sheeps

仔细阅读上面的代码，观察它的特点：

声明继承关系

SheepDog(Dog) 这种写法：括号中的Dog表示Dog是SheepDog的父类。

我们定义Dog的时候没有括号，表示它没有父类（实际上它默认继承了Object类）。

构造函数和super()方法

1. 子类也有构造函数init方法，传入各项必要的属性。
2. 构造函数的第一行调用父类的构造函数，因为牧羊犬首先也是一个Dog，所以要先构造一个Dog出来。
3. 其中super()代表父类。我们用self表示自己，用super()表示父类。注意self是一个关键词，是没有括号的，super()是一个函数，是有括号的。值得注意的是，使用self可以访问父类的属性和方法，因为父类的就是自己的。在构造函数中我们使用super()来调用父类的构造函数是因为子类和父类都有__init__方法，如果不适用super()就会调用自己的__init__方法，这种情况下需要用super)()来明确指定要访问父类的方法。
4. 第二行添加了牧羊犬的独特属性num_of_sheeps。这样牧羊犬有4个属性，其中3个属性是继承自父类的，一个是自己独有的。

使用子类

子类的使用和父类是一样的：

1. 调用构造函数创建实例。
2. 通过变量名访问属性。
3. 通过变量名调用方法。注意bark()是父类的函数，子类可以直接使用。

sd1 = SheepDog('大黄', 67, 88, 10)
print(f'名字：{sd1.name}')
print(f'血量：{sd1.blood}')
print(f'高度：{sd1.power}')
sd1.bark()

给子类添加新的方法

我们给SheepDog添加它的独特方法protect():

class SheepDog(Dog):
    '''牧羊犬，包括名字，高度，攻击力和能看护的养的个数'''
    def __init__(self, name, height, power, num_of_sheeps):
        super().__init__(name, height, power)
        self.num_of_sheeps = num_of_sheeps

    def protect(self):
        print('我开始保护小羊啦！')

调用一下试试看：

sd1 = SheepDog('大黄', 67, 88, 10)
sd1.protect()

覆盖父类的方法

因为继承的关系，SheepDog直接就有bark()方法，这是从父类继承过来的。

假设牧羊犬的叫声和普通叫声是不一样的，我们在子类中覆盖父类中的方法：

class SheepDog(Dog):
    '''牧羊犬，包括名字，高度，攻击力和能看护的养的个数'''
    def __init__(self, name, height, power, num_of_sheeps):
        super().__init__(name, height, power)
        self.num_of_sheeps = num_of_sheeps

    def protect(self):
        print('我开始保护小羊啦！')

    def bark(self):
        print('我是牧羊犬，我骄傲！')

这时候再调用bark()方法就会使用子类中定义的方法：

sd1 = SheepDog('大黄', 67, 88, 10)
sd1.bark()

打印的结果是：

我是牧羊犬，我骄傲！

集成和覆盖的用处举例

类的继承和对父类方法的覆盖在代码设计中很有用。假设有个程序的界面是这样的：

按钮就是一个类，比如叫做Button。

为了实现不同的皮肤，我们可以写一个类继承Button类，假设就叫做MyButton吧，子类自动拥有了父类的属性和函数，但是我们可以覆盖某些函数，让他拥有不同的皮肤，甚至不同的行为。

Dog版本的吃鸡游戏

面向对象的核心知识到这里就更新完了，最后奉上Dog版本的吃鸡游戏。这个游戏包含两个类：

• 其中dog.py定义了几个狗类
• game.py中创建100条Dog并让他们互相攻击，直到最后只有一只为止。

dog.py

#2种狗具有不同的攻击力和防御能力。攻击强的防御弱；反之亦然；
import random
class Dog:
 dogs = [] #保存所有活着的Dog
 def __init__(self, name):
  self.name = name 
  self.blood = 100
  self.attack_power = 5
  self.defense_power = 3

 #攻击!
 def attack(self, dog2):
  print(f'{self.name}攻击{dog2.name}，攻击力:{self.attack_power}，防御力:{dog2.defense_power}')
  point = self.attack_power - dog2.defense_power
  if(dog2.blood > point):
   dog2.blood -= point
   print(f'{dog2.name}受到攻击，奋力自救，血量减少为{dog2.blood}')
  else:
   dog2.blood = 0
   print(f'{dog2.name}受到攻击，失血过多，死亡！')
   Dog.dogs.remove(dog2) 
 
 #判定狗的类型
 def dog_type(self):
  if(isinstance(self, SheepDog)):
   return '牧羊犬'
  elif(isinstance(self, PoliceDog)):
   return '警犬'
  else:
   return '普通犬'


#牧羊犬
class SheepDog(Dog):
 def __init__(self, name):
  super().__init__(name)
  self.attack_power = random.randint(5, 10)
  self.defense_power = random.randint(3,5) 
  print('牧羊犬{self.name}问世！')
  self.dogs.append(self)


#警犬
class PoliceDog(Dog):
 def __init__(self, name):
  super().__init__(name)
  self.attack_power = random.randint(8, 13)
  self.defense_power = random.randint(1,3) 
  print('?♀?警犬{self.name}问世！')
  self.dogs.append(self)

game.py

#1. 首先创建100个Dog, 50个SheepDog, 50个PoliceDog
#2. 每一轮游戏，随机选出2个Dog
#3. dog1先攻击dog2，然后dog2攻击dog1
#3. 任何一方血量变为0就表明死亡！死亡的Dog退出游戏。
#4. 最后只有一个Dog了，游戏结束，胜利者可以吃鸡。
from dog import *
import random #产生随机数字
import time #时间模块

#1.创建100条狗
for i in range(100):
 if(i%2==0):
  SheepDog(i+1) #创建1个牧羊犬
 else:
  PoliceDog(i+1) #创建1个警犬

#2. 开始游戏循环
while(True):
 #判断是否只有1个Dog
 if(len(Dog.dogs) == 1):
  winner = Dog.dogs[0]
  print('')
  print('大吉大利，今晚吃鸡！')
  print(f'赢家是：{winner.dog_type()} {winner.name}')
  print('')
  break

 dog1, dog2 = random.sample(Dog.dogs, 2)
 dog1.attack(dog2)
 dog2.attack(dog1)
 time.sleep(0.02)