python基础—面向对象3—继承，super关键字，多态

继承
概念：
因为不同的类可能有很多共同的特性和行为，将其具有相同的特性或行为都定义在一个类中，这些相同的特性和行为，在定义其他类时，可以被其他类所共享，这就是继承，避免了多次定义，简化操作，使系统更好维护。
被继承的称为父类（超类），继承的称为子类。
继承属于类与类之间的关系。
子类可以继承父类的公开的方法和属性。私有的方法和属性将不能被继承。

class RichMan(object):

    def __init__(self):
        self.money = 666666
        self.company = "理想"
        self.__assistant = "小豪"

    def say(self):
        print("我是富豪，有钱任性")
        
# 表示Son类继承RichMan这个类
# RichMan类中所有公开的方法和属性都被Son类继承了
class Son(RichMan):
	pass
	
if __name__ == '__main__':
    # r = RichMan()
    # print(r.company)
    # print(r.money)
    # r.say()

    s = Son()
    print(s.money)
    print(s.company)
    s.say()
    
    #print(s.__assistant)       #执行这条语句就会报错

重载与重写
方法的重载：
函数名称相同，函数参数个数，类型不同，当我们调用时，会自动的执行对应的函数。
eg：
对于C语言
public int add（int x， int y）{
return x+y }
public double add（double x，double y）{
return x+y }
public int add（int x， int y，int z）{
return x+y+z }
对于强数据类型语言，根据传的参数类型和个数不同，调用不同的函数
但
python：
def add（x，y）：
return x+y
def add（x，y，z）：
return x+y+z
对于弱数据类型语言，不管你传什么，都只会执行最后一个函数，所以python无重载。
与博客面向对象2中提到到相同，这里具体解释

方法的重写：
对于继承来的方法和属性不能满足我们的需要，此时我们就可重新再子类中定义（方法名称要一致），调用时就会执行子类中定义的，会覆盖掉父类的。
在son子类中重写say方法：

class Son(RichMan):

    def say(self):
        print("我不喜欢钱")

调用s.say（），就会显示重新写的。

多继承
python是可以多继承。Java就只能单继承（A继承B，B就不能在继承其它的的）。

class RichMan(object):

    def __init__(self):
        self.money = 666666
        self.company = "理想"
        self.__assistant = "小豪"

    def say(self):
        print("我是富豪，有钱任性")

class grandfather(object):
    def tell(self):
        print("我有别墅")

class Son(RichMan,grandfather):    #多继承
    pass

if __name__ == '__main__':

    s = Son()
    s.say()
    s.tell()

当继承的两个类，都具有相同的方法时，在调用时，会调用继承层次深的。但子类重写时，一定是子类定义的。
比如：
class grandfather(object):
def say(self):
print(“我有别墅”)
与RichMan具有相同的say方法。

super关键字
如果想在子类中调用父类的方法，
对于子类没有的，用self就可以，在子类中找不到就会在父类中找。
对于都有的就要使用super。
super只有在子类中用。

class RichMan(object):

    def __init__(self,money,company,assistant):
        self.money = money
        self.company = company
        self.__assistant = assistant
        
class Son(RichMan):

    def __init__(self,name):
        #super 指向父类
        super().__init__(2000,"公司","秘书")  #调用父类的初始化，需要三个参数，可以传参，可以直接给。
        self.__name = name

    def get_name(self):
        return self.__name
    def set_name(self, name):
        self.__name = name

    def say(self):
        print("我不喜欢钱")


if __name__ == '__main__':
 
    s = Son("timi")
    print(s.get_name())
    print(s.company)

多态（不强调）
在继承的基础上，父类引用指向子类实例的这种现象，父类可以调用子类。
解决父类调用子类。
重点：弱类型语言（不强调数据类型）天生支持多态。

Java（强数据类型）举例：
List ls = new ArrayList(); // list 是ArrayList的父类
ls的类型List，是父类的类型
ls具有ArrayList所有方法