1. 封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：
1). 将内容封装到某处
2). 从某处调用被封装的内容
1). 通过对象直接调用被封装的内容：对象.属性名
2). 通过self间接调用被封装的内容： self.属性名
3). 通过self间接调用被封装的内容: self.方法名()

class Cat:
    def __init__(self, name, kind): 
        print('正在执行__init__构造方法')
        print('self:', self)
        # 封装: self.name将对象和name属性封装/绑定
        self.name = name
        self.kind = kind
    def eat(self):
        print('cat %s like eating fish.....' %(self.name))
# 实例化
fentiao = Cat("粉条", "美短虎斑")
print(fentiao.name)
print(fentiao.kind)
fentiao.eat()

执行结果：

正在执行__init__构造方法
self: <__main__.Cat object at 0x0000029ABA813FD0>
粉条
美短虎斑
cat 粉条 like eating fish.....

2. 继承

子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。

2.1 单继承

class Student:
    """父类Student"""
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def learning(self):
        print(f'{self.name}正在学习')
class MathStudent(Student):
    """MathStudent的父类是Student"""
    pass
# 实例化
m1 = MathStudent("博士", 8)
print(m1.name)
print(m1.age)
m1.learning()

执行结果：

博士
8
博士正在学习

2.2 多继承

class D(object):
    def helloD(self):
        print('D')
class C(D):
    def helloC(self):
        print('C')
class B(D):
    def helloB(self):
        print('B')
class A(B, C):
    def helloA(self):
        print('A')
a = A()
a.helloA()
a.helloB()
a.helloC()
a.helloD()

执行结果为：

A
B
C
D

2.3 重写父类方法

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法') 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

执行以上程序输出结果为：

调用子类方法
调用父类方法

3. 多态

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。通俗来说：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

多态的好处就是，当我们需要传入更多的子类，只需要继承父类就可以了，而方法既可以直接不重写（即使用父类的），也可以重写一个特有的。这就是多态的意思。调用方只管调用，不管细节，而当我们新增一种的子类时，只要确保新方法编写正确，而不用管原来的代码。这就是著名的“开闭”原则：

对扩展开放（Open for extension）：允许子类重写方法函数
对修改封闭（Closed for modification）：不重写，直接继承父类方法函数

【Python17】三大特性（封装、继承、多态）

文章目录