初学C++的时候，一直混淆多态与继承这两个概念，今天笔者就自己的理解对这两个概念进行一些简单的总结。 

1.继承：继承通常介绍的是父对象与子对象之间的关系。子类通过继承父类的特征和行为，使得子类具有父类的特征，方法以及函数接口等等。通常的用法是通过继承抽象类的一般方法，再在此基础上进行具体特殊化。 

2.多态：顾名思义，指的是多种状态或者多种实现方式。针对同一接口，可以有多种实现，这就是多态的一个重要应用：接口重写。通常的用法是针对父类的虚函数了，子对象根据具体的要求重写该函数。

python多态与继承
一、继承
1、概念
2、单继承
1）单父类与子类的继承
2）子类、父类、爷爷类的关系
3）方法的重写
（1）方法重写：覆盖
（2）方法重写：拓展——super()方法
4）父类的私有属性与私有方法
3、多继承
父类有相同的方法名时
二、多态
案例
三、类属性和类方法
1、实例
2、类对象
3、类属性
4、类方法
5、静态方法
四、案例
1、需求


面向对象三大特性：


封装：根据职责将属性和方法封装到一个抽象的类中
继承：实现代码的重用，相同代码不需要重复的编写
多态：不同的对象调用相同的方法，产生不同的结果，增加代码的灵活度

一、继承
1、概念

继承的概念：

1、子类拥有父类的所有方法和属性

2、不包括私有属性和私有方法

继承的优点：

1、实现代码重用

2、简化代码的结构

3、便于代码的维护和管理

4、但是不能够提升代码的运行速度



每个对象都有相同的方法，代码大量重复。


2、单继承
1）单父类与子类的继承
class 类名(父类名):
	pass

子类继承父类，可以直接享受父类中已经封装好的方法，不需要再次开发；子类中应该根据职责封装子类特有的属性和方法。
class Animal:
    def __init__(self):
        self.name = "动物"
        self.age = 2

    def eat(self):
        print("%s 都爱吃" % self.name)

# 单继承
class Cat(Animal):
    def catch(self):
        print("猫抓老鼠")

animal = Animal()
print(animal.name)
print(animal.age)
animal.eat()
# 父类对象不能调用子类的方法，也不能访问子类的属性

print("*" * 50)
# 子类对象调用父类的方法和属性
cat = Cat()
print(cat.name)
print(cat.age)
cat.eat()
cat.catch()


2）子类、父类、爷爷类的关系
class Animal:
    def __init__(self):
        self.name = "动物"
        self.age = 2

    def eat(self):
        print("%s 都爱吃" % self.name)

# 单继承
class Cat(Animal):
    def catch(self):
        print("猫抓老鼠")

class Bosicat(Cat):
    def sing(self):
        print("波斯猫会唱歌")

animal = Animal()
print(animal.name)
print(animal.age)
animal.eat()

print("*" * 50)
# 子类对象调用父类的方法和属性
cat = Cat()
print(cat.name)
print(cat.age)
cat.eat()
cat.catch()

print("*" * 50)
# 子类对象调用父类以及爷爷类的方法和属性
bsm = Bosicat()
print(bsm.name)
print(bsm.age)
bsm.eat()
bsm.catch()
bsm.sing()


3）方法的重写

重写的概念：

子类中有与父类相同的方法名，

重写的原因：

当父类的函数无法满足子类的需求，则需要方法的重写

前提：

两者要有继承的关系

重写的两种方式：

1、覆盖父类的方法：子类重写的方法与父类完全不同

2、对父类方法进行拓展：子类重写的方法是在父类方法的基础上进行功能拓展

（1）方法重写：覆盖
class Animal:
    def __init__(self):
        self.name = "动物"
        self.age = 2

    def eat(self):
        print("%s 都爱吃" % self.name)

# 单继承
class Cat(Animal):
    def catch(self):
        print("猫抓老鼠")

class Bosicat(Cat):
    # 重写父类的功能
    def catch(self):
        print("波斯猫抓鱼")
    def sing(self):
        print("波斯猫会唱歌")

bsm = Bosicat()
bsm.catch()


（2）方法重写：拓展——super()方法



class Animal:
    def __init__(self):
        self.name = "动物"
        self.age = 2
    def eat(self):
        print("%s 都爱吃" % self.name)

# 单继承
class Cat(Animal):
    def catch(self):
        print("猫抓老鼠")

class Bosicat(Cat):
    # 对父类方法实现功能拓展
    def catch(self):
        # ①super().重写的方法名
        # super()在子类中调用父类重写的方法
        super().catch()
        # 在父类的方法上进行了拓展

	    # ② 父类名.方法名(self) 
	    # 此方法不推荐，因为父类名修改后，在调用的地方也需要修改
		
        print("波斯猫抓鱼")

bsm = Bosicat()
bsm.catch()


4）父类的私有属性与私有方法
class Father:
    """父类"""
    def __init__(self):
        # 共有属性
        self.name = "老林"
        # 私有属性，带有前置双下划线的属性
        self.__pwd = 111111

    def eat(self):
        """吃方法"""
        print("%s 爱吃东西,使用密码 %d 来买东西" % (self.name,self.__pwd))
    
    # 私有方法，前置双下划线的方法
    def __secret(self):
        """私有方法"""
        print("%s 的卡密码是%d" % (self.name,self.__pwd))

class Son(Father):
    """子类"""
    def run(self):
        print("小林跑")

lin = Son()
print(lin.name)
# 在类外无法访问私有属性，在类内可以访问
lin.eat()

print(dir(lin))



给父类设置接口，用来调用父类的私有属性和私有方法
class Father:
    """父类"""
    def __init__(self):
        # 共有属性
        self.name = "老林"
        # 私有属性，带有前置双下划线的属性
        self.__pwd = 111111

    def eat(self):
        """吃方法"""
        print("%s 爱吃东西,使用密码 %d 来买东西" % (self.name,self.__pwd))
    
    # 私有方法，前置双下划线的方法
    def __secret(self):
        """私有方法"""
        print("%s 的卡密码是%d" % (self.name,self.__pwd))

    # 在类的内部提供对外访问私有属性的接口
    def get_pwd(self):
        """获取私有属性"""
        return self.__pwd
    
    def set_pwd(self,new_pwd):
        """设置私有属性"""
        self.__pwd = new_pwd

    def func_secret(self):
        """调用私有方法"""
        self.__secret()

class Son(Father):
    """子类"""
    def run(self):
        print("小林跑")

lin = Son()
print(lin.name)
# 在类外无法访问私有属性，在类内可以访问
lin.eat()


print(lin.get_pwd())

lin.set_pwd(123456)

print(lin.get_pwd())

lin.func_secret()




3、多继承

多继承的概念：

子类可以拥有多个父类，并具有所有父类的属性和方法


class Ma:
    """马类"""
    def __init__(self):
        self.name = "马"
    def run(self):
        print("马跑得快")

class Lv:
    """驴类"""
    def walk(self):
        print("驴走得远")

class Luozi(Ma,Lv):
    """骡子类"""
    pass

luo = Luozi()
print(luo.name)
luo.run()
luo.walk()


父类有相同的方法名时




其中object类时python为所有对象提供的基类，提供有一些内置的属性和方法


class Ma:
    """马类"""
    def run(self):
        print("马跑得快")
    
    def walk(self):
        print("马走不远")

class Lv:
    """驴类"""
    def walk(self):
        print("驴走得远")
    def run(self):
        print("驴跑不快")

class Luozi(Ma,Lv):
    """骡子类"""
    pass

luo = Luozi()
luo.run()
luo.walk()

# 方法解析顺序
print(Luozi.__mro__)


二、多态
多态是不同的对象调用相同的方法，产生不同的结果状态

多态可以增加代码的灵活度

以继承和重写父类方法为前提

是调用方法的技巧，不会影响到类的内部设计

案例

class Dog:
    """普通狗类"""
    def __init__(self,name):
        self.name = name
    
    def game(self):
        print("%s在地上玩耍" % self.name)

class XiaoTianQuan(Dog):
    """哮天犬类"""
    def __init__(self,name):
        self.name = name
    
    def game(self):
        print("%s 在天上玩耍" % self.name)

class Person:
    """人类"""
    def __init__(self, name):
        self.name = name
    
    def play_with_dog(self,dog):
        """和狗玩的方法"""
        print("人 %s 和狗 %s 一起玩" % (self.name,dog.name))
        dog.game()

peanut = Dog("花生") 

xtq = XiaoTianQuan("哮天犬")

lin = Person("林")

lin.play_with_dog(peanut)
print("*"*50)
lin.play_with_dog(xtq)




三、类属性和类方法

1、实例

1、创建出来的，具有内存空间的对象就是实例对象

2、创建对象的动作叫做实例化

3、对象的属性叫做实例属性

4、对象调用的方法叫做实例方法




2、类对象



3、类属性



# 需求：统计当前类模板创建了几个实例对象？

class Person(object):
    """人类"""
    # 类属性，定义在方法的外边，类的内部
    # 作用：主要用来记录类对象的相关特征
    # 类属性
    count = 0
    print("类模板初始化一次")

    def __init__(self, name):
        self.name = name
        print("初始化方法__init__")
        # 使用类属性统计当前类模板创建了几个实例对象
        # 访问类属性需要通过类名来访问     类名.类属性
        Person.count += 1

    def eat(self):
        print("%s 爱吃美食" % self.name)

lin = Person("lin")
lin1 = Person("lin1")
lin2 = Person("lin2")

# 类外访问类属性的方式
# 1、类名.类属性名
print(Person.count)

# 2、实例对象.类属性名
print(lin.count)

# 修改类属性
# 类名.类属性 = 值
# 修改类属性不可用实例对象.类属性名的方式，因为该方式仅仅是给对象加实例属性
Person.count = 10
print(Person.count)


4、类方法
类方法是针对类对象的方法。



class Person(object):
    """人类"""
    # 类属性
    count = 0
    def __init__(self, name):
        self.name = name
    def eat(self):
        print("%s 爱吃美食" % self.name)

    # classmethod是装饰器，也叫修饰器，告诉python解释器这是一个类方法
    @classmethod
    def get_count(cls):
        """类方法"""
        print("1、类方法用于处理类属性或调用其他类方法")
        print("2、cls参数保存的是当前类对象的引用",cls)
        cls.count += 100
        return cls.count

print(Person)
# 调用类方法
# 类对象名.类方法名
print(Person.get_count())


5、静态方法




class Person(object):
    """人类"""
    # 类属性
    count = 0

    def __init__(self, name):
        self.name = name

    def eat(self):
        print("%s 爱吃美食" % self.name)

    # classmethod是装饰器，也叫修饰器，告诉python解释器这是一个类方法
    @classmethod
    def get_count(cls):
        """类方法"""
        print("1、类方法用于处理类属性或调用其他类方法")
        print("2、cls参数保存的是当前类对象的引用", cls)
        cls.count += 100
        return cls.count

    # staticmethod是装饰器
    @staticmethod
    def func_static():
        """静态方法"""
        print("1、静态方法不需要self也不需要cls参数")
        print("2、静态方法中不需要实例属性也不需要类属性")
        print("3、静态方法中不需要实例方法也不需要类方法")
        print("3、静态方法中不需要实例方法也不需要类方法")
        print("4、静态方法不能破坏类的封装性")

# 调用静态方法
# 1、类名.静态方法名
Person.func_static()
# 2、实例名.静态方法名




四、案例
1、需求

class Game:
    """游戏类"""
    # 类属性
    top_score = 0

    def __init__(self,player_name):
        self.player_name = player_name

    # 静态方法显示游戏帮助信息
    @staticmethod
    def show_help():
        print("帮助信息")

    # 类方法显示历史最高分
    @classmethod
    def show_top_score(cls):
        print("历史最高分为:",cls.top_score)

    def start_game(self):
        print("游戏开始")
        print("%s 玩家正在游戏" % self.player_name)
        # 修改历史最高分
        Game.top_score += 100

Game.show_help()
Game.show_top_score()
gamer = Game("lin")
gamer.start_game()
Game.show_top_score()

本节内容为类的多态与继承

简介

终于讲到了面向对象三大特性中的两大特性——继承与多态。通过继承与多态，我们能很好的将类的拓展性发挥到了极致。在下面的内容讲解中，我们将从各个方面对继承和多态进行刨析。

继承
继承事实上是一个非常好理解的语法，在C#中实现继承使用A:B，表示A类继承B类。子类（一称为派生类）继承于父类（一称为基类）就好比孩子继承了父亲的一切，但是孩子总归是有自己的个性的，而父亲也有一些不会告诉孩子的事情。如果我们从之前的访问控制符这一部分进行理解的话，你可以这样描述这个“融洽”的父子关系。
假定有以下这个例子：塞巴斯蒂安·艾奎斯（父类）是一个欧洲宫廷的贵族，67岁，他是一个子爵，并且掌握了一个惊天大秘密不能告诉任何人，只能烂在肚子里。他育有一子名叫麦克·艾奎斯，由于塞巴斯蒂安·艾奎斯年老体弱，当家里需要钱的时候，他会让自己的儿子带上银行卡前往atm机取钱。儿子的车和他的车一模一样，每次儿子让管家开车的时候都必须说清楚：“我要开我父亲的车。”，或者：“今天我开我自己的车”。如果他没有说，那么管家会默认的取出儿子的车。他家还有一个大庄园闲置可以用于开发，只要父亲同意，那么儿子可以自由开发。
对于这个例子，你需要得出的结论是：

如果塞巴斯蒂安·艾奎斯（父类）没有出生，那么麦克·艾奎斯（子类）也不存在。（子类实例化时必定先调用父类构造方法)
对于塞巴斯蒂安·艾奎斯（父类），他的名字属于大家都可以知道的（public），谁都可以轻易的得到。但是想拥有这个名字，却只能是他的家族的人才可以（继承后才能获得父类的字段）。
对于前往ATM机取钱这件事，取款密码只可能告诉他的儿子，别人是不能得到的。（protected可以被子类访问，但是其余不可访问）
塞巴斯蒂安·艾奎斯（父类）知道一个秘密，这个秘密只有他本人才知道（private），包括他的儿子也不可能知晓（子类无法获取private）
因为父子俩的车一模一样，取车需要特别说明（子类和父类函数签名一致时，父类函数默认会隐藏，除非显式的说明）
大庄园是父亲的，但是可以被儿子取改造（父类函数指定为virtual时，子类可以重写父类函数）

通过这一些刨析，我认为你应该已经清楚了七八分继承的意思了。这里需要介绍一下我们的base关键字，base关键字在子类中体现为调用父类的方法。
特别的，你需要注意的是，C#对于类与类的继承只支持单继承，如果你试图实现多继承，你可以使用接口作为媒介和桥梁。
我们现在用一段代码演示完我们的继承，我们这个教程更多的是引导你去思考，而不是让你如同一些速成培训班出来的一样，没有独立的思考能力。
class Father
{
    public Father()
    {
        Console.WriteLine("Father Method");
    }
    private string MSGSecret;
    protected string BankSecret;
    public string Name;
    public string Car;
    protected void test()
    {

    }
}
class Son:Father
{
    public Son()
    {
        Console.WriteLine("Son Method");
    }
    //隐式的生成了这三个字段
    //protected string BankSecret;
    //public string Name;
    //public string Car;
    public string Car;
    public void getCar()
    {
        base.Car;//父类
        this.Car;//子类
        base.test()//调用父类方法，如果签名不冲突，可以省略base
    }
}
Son s = new Son();//思考一下这里会输出什么？

多态

多态是一个并不困难的东西，在继承和接口中我们讲到的重写其实就是多态性的一种类型了。之前我们简单的举过一个例子来说明多态：人和鲤鱼都是动物，但是人用肺进行呼吸，而鲤鱼用鳃进行呼吸。这个例子就很好的体现了多态。利用下面这段代码来解释吧。
class Animal
{
    //通过抽象方法实现多态
    abstract void Breathing();
    //虚方法实现多态
    virtual void Eat()
    {
    }
}
class Human:Animal
{
    override void Breathing()
    {

    }
    override void Eat()
    {

    }
}
class Fish:Animal
{
    override void Breathing()
    {
        
    }
    new void Eat()
    {

    }
}
Animal ah = new Human();
Animal af = new Fish();
Fish f = new Fish();

注意看最后几行，ah和af各属于Human和Fish的对象，但是当方法调用的时候，统一调用父类中的方法，并且加载子类中的重写和实现。
ah.Eat();//调用父类的Eat()，但是以Human类中的重写方法为实现
af.Eat();
f.Eat();

这三者的区别在哪里？事实上你只需要知道，多态性就是通过父类去管理子类，让子类遵循父类的规范。当子类使用从父类继承的方法的时候，是去调用父类的方法，但是使用子类的实现。特别的，如果你在方法中使用new修饰符，那么这个方法将会和父类毫无关系，就如这个单词的意思一样，这是一个新的函数，不是父类中的函数。现在你可以试着分析上述三个函数调用的各是哪个类中的方法。
多态最大的有点就是你可以通过一个基类或者接口去管理所有继承于他们的子类的函数方法，并且同一个函数可以有多种实现方法。
如果你使用接口和抽象类去实现多态，实现的方法也是一样的，只不过是基类型无法实例化。

1、  
什么是继承，继承的特点？
子类继承父类的特征和行为，使得子类具有父类的各种属性和方法。或子类从父类继承方法，使得子类具有父类相同的行为。
特点：在继承关系中，父类更通用、子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。
在继承关系中。父类和子类需要满足is-a的关系。子类是父类。
表示父类和子类的术语：父类和子类、超类和子类、基类和派生类，他们表示的是同一个意思。
2、  
为什么需要继承？什么时候应该继承？
使用继承可以有效实现代码复用，避免重复代码的出现。
当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出来放到一个类中作为父类，其它两个类继承这个父类。
继承实现了面向对象的原则：write once,only once（编写一次、且编写一次
3、  
如何实现继承？
在Java语言中，用extends（扩展）关键字来表示一个类继承了另一个类。
在父类中只定义一些通用的属性和方法。
子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法。或子类重新定义父类的属性、重写父类的方法可以获得与父类不同的功能。
4、  
什么是方法重写？
如果在子类中定义的一个方法，其名称、返回类型及参数列表正好与父类中某个方法的名称、返回类型及参数列表相匹配，那么可以说，子类的方法重写了父类的方法。
方法重写在不同类，是实现多态的必要条件。
5、  
super关键字的用法和位置，super关键字调用父类的构造方法，super关键字调用父类的方法？
在子类的构造方法中，通过super关键字调用父类的构造方法。
如果子类中重写了父类的方法，可以通过super关键字调用父类的方法。
父类：
private String name;
private String sex;
public xinxin1(String name,String sex)
{
           this.name=name;
           this.sex=sex;
}
         public void hello(){
                   System.out.println(“嗨！我是”+name+”我是”+sex+”孩”);

         }
子类：
public xinxin2(String name,String sex)
{
           //调用父类的构造方法
           super(name,sex);
} 
public void hello(){
                   System.out.println(“我是新来的！”);

           //调用父类的方法
           super.hello();
} 
位置注意：调用父类的构造方法的语句（super语句）必须是构造方法中的第一条语句。
因为创建对象的时候，需要先创建父类对象，再创建子类对象。
注意：创建对象时，先创建父类对象，在创建子类对象。如果没有显示调用父类的构造方法，将自动调用父类的无参构造方法。
6、  
一切类的老大（祖先）Object。
所有类都直接或者间接地继承了java.lang.Object类，Object类中定义了所有的java对象都具有的相同行为，是所有类的祖先。
一个类如果没有使用extends关键字，那么这个类直接继承自Object类。
7、  
什么是多态？
多态的特征是表现出多种形态，具有多种实现方式。或者多态是具有表现多种形态的能力的特征。或者同一个实现接口，使用不同的实例而执行不同的操作。
8、  
为什么需要使用多态？多态的好处？
可以增强程序的可扩展性及可维护性，使代码更加简洁。
不但能减少编码的工作量，也能大大提高程序的可维护性及可扩展性。
9、  
如何实现多态？
一般做法是：写一个方法，它只接收父类作为参数，编写的代码只与父类打交道。调用这个方法时，实例化不同的子类对象（new
一个对象）。
更具体的说：
（1）、子类重写父类的方法。使子类具有不同的方法实现。
（2）、把父类类型作为参数类型，该父类及其子类对象作为参数转入。
（3）、运行时，根据实际创建的对象类型动态决定使用那个方法。
在运行时，java虚拟机会根据实际创建的对象类型决定使用那个方法。一般将这称为动态绑定。   
10、多态小结：多态与继承、方法重写密切相关，我们在方法中接收父类类型作为参数，在方法实现中调用父类类型的各种方法。当把子类作为参数传递给这个方法时，java虚拟机会根据实际创建的对象类型，调用子类中相应的方法（存在方法重写时）。