文章目录

• 一、 封装
• 二、 继承
  • 2.1 单继承
  • 2.2 多继承
  • 2.3 重写父类方法和调用父类方法
• 三、 多态

一、 封装

封装是指将数据与具体操作的实现代码放在某个对象内部，使这些代码的实现细节不被外界发现，外界只能通过接口使用该对象，而不能通过任何形式修改对象内部实现，正是由于封装机制，程序在使用某一对象时不需要关心该对象的数据结构细节及实现操作的方法。使用封装能隐藏对象实现细节，使代码更易维护，同时因为不能直接调用、修改对象内部的私有信息，在一定程度上保证了系统安全性。类通过将函数和变量封装在内部，实现了比函数更高一级的封装。

class Student:
    classroom = '101'
    address = 'beijing' 
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def print_age(self):
        print('%s: %s' % (self.name, self.age))
# 以下是错误的用法
# 类将它内部的变量和方法封装起来，阻止外部的直接访问
print(classroom)
print(adress)
print_age()

二、 继承

继承来源于现实世界，一个最简单的例子就是孩子会具有父母的一些特征，即每个孩子都会继承父亲或者母亲的某些特征，当然这只是最基本的继承关系，现实世界中还存在着更复杂的继承。

在程序中，继承描述的是事物之间的所属关系，例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物；同理，波斯猫和巴厘猫都继承自猫，而沙皮狗和斑点狗都继承自狗，如下所示：

在 OOP 程序设计中，当我们定义一个新类的时候，新的类称为子类（Subclass），而被继承的类称为基类、父类或超类（Base class、Super class）。继承机制实现了代码的复用，多个类公用的代码部分可以只在一个类中提供，而其他类只需要继承这个类即可。继承最大的好处是子类获得了父类的全部变量和方法的同时，又可以根据需要进行修改、拓展。其语法结构如下：

class Foo(superA, superB,superC....):
class DerivedClassName(modname.BaseClassName): ## 当父类定义在另外的模块时

Python 支持多父类的继承机制，所以需要注意圆括号中基类的顺序，若是基类中有相同的方法名，并且在子类使用时未指定，Python 会从左至右搜索基类中是否包含该方法。一旦查找到则直接调用，后面不再继续查找。

2.1 单继承

我们来看一个例子：

总结：

• 虽然子类（Bosi）中没有定义__init__方法，但是他的父类（Cat）有，所以在子类继承父类的时候这个方法就被继承了。创建 Bosi 对象 bs 时，就默认执行了父类（Cat）中的__init__方法
• 父类的属性、方法，会被继承给子类

另一个例子：

总结：

• 私有的属性，不能通过对象直接访问，但是可以通过类方法来访问
• 私有的方法，不能通过对象直接访问
• 私有的属性和方法，不会被子类继承，也不能被子类访问
• 一般情况下，私有的属性和方法都是不对外公布的，往往用来做内部的事情，起到安全的作用。

2.2 多继承

多继承，是指子类有多个父类，并且具有他们的特征。

实例：

总结：

• 所有父类中的方法和属性，都会被子类继承

再看一个例子：

2.3 重写父类方法和调用父类方法

所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法。

例如：

调用父类方法

从上面的例子中我们知道，在子类中如果有与父类同名的成员，那就会覆盖掉父类里的成员。那如果你想强制调用父类的成员呢？使用 super()函数！这是一个非常重要的函数，最常见的就是通过 super 调用父类的实例化方法__init__！

语法：super(子类名, self).方法名()，需要传入的是子类名和 self，调用的是父类里的方法，按父类的方法需要传入参数。

class A:
    def __init__(self, name):
        self.name = name
        print("父类的__init__方法被执行了！")
    def show(self):
        print("父类的 show 方法被执行了！")
class B(A):
    def __init__(self, name, age):
        super(B, self).__init__(name=name)
        self.age = age
    def show(self):
        super(B, self).show()
obj = B("jack", 18)
obj.show()

三、 多态

先看下面的代码：

class Animal:
    def kind(self):
        print("i am animal")
class Dog(Animal):
    def kind(self):
        print("i am a dog")
class Cat(Animal):
    def kind(self):
        print("i am a cat")
class Cow(Animal):
    def kind(self):
        print("i am a cow")
# 这个函数接收一个 animal 参数，并调用它的 kind 方法
   def show_kind(animal):
        animal.kind()
d = Dog()
c = Cat()
w = Cow()
show_kind(d)
show_kind(c)
show_kind(w)
------------------
打印结果：
i am a dog
i am a cat
i am a cow

狗、猫、牛都继承了动物类，并各自重写了 kind 方法。show_kind()函数接收一个animal 参数，并调用它的 kind 方法。可以看出，无论我们给 animal 传递的是狗、猫还是牛，都能正确的调用相应的方法，打印对应的信息。这就是多态。

实际上，由于 Python 的动态语言特性，传递给函数 show_kind()的参数 animal 可以是任何的类型，只要它有一个 kind()的方法即可。动态语言调用实例方法时不检查类型，只要方法存在，参数正确，就可以调用。这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。

class Job:
    def kind(self):
        print("i am not animal, i am a job")
j = Job()
show_kind(j)