类、继承、多态

1.面向对象

把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。

2.类

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。类对象支持两种操作：属性引用和实例化。

class Person(object):
    name = "Maker"
    def func(self):
        print("盖房子")
        
per = Person()
print(per.name)  #Maker
per.func()       #盖房子

类有一个名为__ init()__ 的特殊方法（构造方法），该方法在类实例化时会自动调用，类定义了 init() 方法，类的实例化操作会自动调用 init() 方法。 init() 方法可以有参数，参数通过 init() 传递到类的实例化操作上。

class Complex:
    #有参
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

3.类属性与方法

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问，实例不能访问私有变量。在类内部的方法中使用时self.private_attrs。

类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定使用 self。

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods()

4.继承

子类会继承父类的属性和方法，父类必须与子类定义在一个作用域内。

#继承形式如下
class people:
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    def __init(self,name,age,weight):
        self.name = name
        self.age = age
        sef.__weight = weight
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
​
#student继承people
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构造函数
        people.__init__(self,n,a,w)
        self.grade = g
    
    #重写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
        
# 实例化
s = student("Maker",10,60,3)#name age weight grade
s.speak()

5.多继承

若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中参数位置排前父类的方法

6.多态

作用：让、具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容(功能)的函数。

特点：

1、只关心对象的实例方法是否同名，不关心对象所属的类型；

2、对象所属的类之间，继承关系可有可无；

3、多态的好处可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强；

4、多态是调用方法的技巧，不会影响到类的内部设计。

#多态
class bus(object):
    def __init__(self, name):
        self.name = name

class bus_28(bus):
    def __init__(self, name):
        super().__init__(name)

    def method(self):
        print("我是"+self.name+"，我需要缓慢行驶")

class bus_906(bus):
    def __init__(self, name):
        super().__init__(name)

    def method(self):
        print("我是"+self.name+"，我需要快速行驶")

class bus_b32(bus):
    def __init__(self, name):
        super().__init__(name)

    def method(self):
        print("我是"+self.name+"，我需要上高架桥行驶")

def drive(object):
    object.method()

bus_28 = bus_28("28路")
bus_906 = bus_906("906路")
bus_b32 = bus_b32("b32路")
#多态性的体现
drive(bus_28)
drive(bus_906)
drive(bus_b32)