Python——类、继承、多态

1.面向对象技术简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 方法：类中定义的函数。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

2.创建类

        使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾。

class ClassName:
   '类的帮助信息'   # 类文档字符串
   class_suite  # 类体

self：

        self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

__init__()方法:

        一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

注意：

        类的帮助信息可以通过ClassName.__doc__查看。

        class_suite 由类成员，方法，数据属性组成。

3.创建实例对象

        实例化类其他编程语言中一般用关键字new，但是在Python中并没有这个关键字，类的实例化类似函数调用方式。

        以下使用类的名称Employee来实例化，并通过 __init__ 方法接收参数：

"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)

4.访问属性

        可以使用点号 . 来访问对象的属性。使用如下类的名称访问类变量：

emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

5.Python内置类属性

        __dict__：类的属性（包含一个字典，由类的数据属性组成）。

        __doc__：类的文档字符串。

        __name__：类名。

        __module__：类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__等于 mymod）。

        __bases__：类的所有父类构成元素（包含了一个由所有父类组成的元组）。

6.继承

        面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。

（1）父类和子类：

        通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。

（2）单个继承语法：

class 派生类名(基类名)
    ...

        如果在子类中需要父类的构造方法就需要显式的调用父类的构造方法，或者不重写父类的构造方法。 

        在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数。

        Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

（3）继承多个类语法：

class A:        # 定义类A
.....

class B:         # 定义类B
.....

class C(A, B):   # 继承类A和B
.....

（4）检测：

检测

函数	描述	语法
issubclass()	布尔函数，判断一个类是另一个类的子类或者子孙类。	issubclass(sub,sup)
isinstance()	布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。	isinstance(obj, Class)

 7.多态

        让具有不同功能的函数可以使用相同的函数名，即用一个函数名调用不同内容（功能）的函数。

（1）特点：

        1）只关心对象的实例方法是否同名，不关心对象所属的类型；
        2）对象所属的类之间，继承关系可有可无；
        3）多态的好处可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强；
        4）多态是调用方法的技巧，不会影响到类的内部设计。

（2）应用场景：

        1）对象所属的类之间没有继承关系。

        2）对象所属的类之间有继承关系（应用更广）。

8.方法重写 

        如果父类方法的功能不能满足需求，可以在子类重写你父类的方法。

例：

# 定义父类
class Parent:
   def myMethod(self):
      print '调用父类方法'

# 定义子类
class Child(Parent):
   def myMethod(self):
      print '调用子类方法'

c = Child()  # 子类实例
c.myMethod()  # 子类调用重写方法
====================运行结果===================
调用子类方法

9.案例

（1）选择小汽车和客车为对象，使用类实现它们的属性和方法（汽车的重量属性，驾驶的方法），并打印属性。

        小汽车类：Car

# 小汽车类
class Car:
    def __init__(self, name, height):  # 常用于属性，self为已实例化的对象
        self.name = name  # 属性 名字
        self.height = height  # 重量

    # 方法
    def drive1(self):
       return "重量为"+str(self.height)+"kg的"+self.name+"在行驶"  # Python函数使用return返回值，如果不用return, 而用print输出值，这个函数默认还有一个返回值为None。

         客车类：PassengerCar

# 客车类
class PassengerCar:
    def __init__(self, name, height):  # 常用于属性，self为已实例化的对象
        self.name = name  # 属性 名字
        self.height = height  # 重量

    # 方法
    def drive1(self):
        return "重量为"+str(self.height)+"kg的"+self.name+"在行驶"

         运行：Test1

"""
1.类
要求：
    选择小汽车和客车为对象，使用类实现它们的属性和方法（汽车的重量属性，驾驶的方法），并打印属性。
"""

from Car import Car
from PassengerCar import PassengerCar

def main():
    car = Car("小汽车", 100)  # 创建小汽车类对象并传入参数
    pcar = PassengerCar("客车", 500)  # 创建客车类对象并传入参数
    print(car.height)  # 打印小汽车的重量属性
    print(pcar.height)  # 打印客车的重量属性
    print(car.drive1())  # 打印小汽车的驾驶方法
    print(pcar.drive1())  # 打印客车的驾驶方法

if __name__ == "__main__":
    main()

         运行效果：

​​​​​​100
500
重量为100kg的小汽车在行驶
重量为500kg的客车在行驶

（2）对第一个问题改写：继承客车的属性和方法，改造为公交车，输入的 名字为：“东风路28路公交车”，并打印（也包括属性和驾驶的方法）。

        运行：Test2

"""
2.继承和重写
要求：
    继承客车的属性和方法，改造为公交车，输入的名字为：“东风路28路公交车”，并打印（也包括属性和驾驶的方法）
"""

from PassengerCar import PassengerCar

# 公交车类
class Bus(PassengerCar):
    # 继承客车的属性
    def __init__(self, name, height, bname):  # 子类重写父类，调用自身的属性和方法
        super().__init__(name, height)  # 调用父类的__init__方法
        self.bname = bname

    # 重写驾驶方法
    def drive(self):
        return "重量为"+str(self.height)+"kg的"+self.bname+"在行驶"

def main():
    bname = input("请输入公交车名：")
    bus = Bus("客车", "500", bname)
    print(bus.height)  # 父类的重量属性
    print(bus.bname)  # 子类的车名属性
    print(bus.drive())  # 子类的驾驶方法

if __name__ == "__main__":
    main()

        运行效果： 

请输入公交车名：东风路28路公交车
500
东风路28路公交车
重量为500kg的东风路28路公交车在行驶

（3）使用多态实现28路、906路、B32路公交车的驾驶方法并打印。

        运行：Test3

"""
3.多态
要求：
    使用多态实现28路、906路、B32路公交车的驾驶方法并打印
"""

from PassengerCar import PassengerCar


class Bus1(PassengerCar):  # 继承父类PassengerCar
    def __init__(self, name, height): #属性
        super().__init__(name, height) #调用父类的 __init__ 方法
        self.name = name

    def drive(self):  #方法重写
        return self.name+"正在行驶"

class Bus2(PassengerCar):  # 继承父类PassengerCar
    def __init__(self, name, height):
        super().__init__(name, height)
        self.name = name

    def drive(self):  # 方法重写
        return self.name+"正在行驶"

class Bus3(PassengerCar):  # 继承父类PassengerCar
    def __init__(self, name, height):
        super().__init__(name, height)
        self.name = name

    def drive(self):  # 方法重写
        return self.name+"正在行驶"

def main():
    bus1 = Bus1("28路公交车", 500)  # 创建对象并传入参数
    print(bus1.drive())  # 输出方法中的内容
    bus2 = Bus2("906路公交车", 500)
    print(bus2.drive())
    bus3 = Bus3("B32路公交车", 500)
    print(bus3.drive())

if __name__ == "__main__":
    main()

        运行效果：

28路公交车正在行驶
906路公交车正在行驶
B32路公交车正在行驶