python面向对象—封装、继承、多态

封装

① 把现实世界中的主体中的属性和方法书写到类的里面的操作即为封装

② 封装可以为属性和方法添加为私有权限，不能直接被外部访问

在面向对象代码中，我们可以把属性和方法分为两大类：公有（属性、方法）、私有（属性、方法）Python：公有（属性、方法），私有（属性、方法）

公有属性和公有方法：无论在类的内部还是在类的外部我们都可以对属性和方法进行操作。

但是有些情况下，我们不希望在类的外部对类内部的属性和方法进行操作。我们就可以把这个属性或方法封装成私有形式。

设置私有属性和私有方法的方式非常简单：在属性名和方法名 前面 加上两个下划线 __ 即可。

当定义为私有成员变量时，引用或者打印都不可行。

私有成员对于类对象没有办法直接使用，但是我们类中其他成员却是可以访问这些私有成员的。

封装总结：

私有成员的定义我们已经了但是有什么实际的意义吗？

继承

我们接下来来聊聊Python代码中的“继承”：类是用来描述现实世界中同一组事务的共有特性的抽象模型，但是类也有上下级和范围之分，比如：生物 => 动物 => 哺乳动物 => 灵长型动物 => 人类 => 黄种人

从哲学上说，就是共性与个性之间的关系，比如：白马和马！所以，我们在OOP代码中，也一样要体现出类与类之间的共性与个性关系，这里就需要通过类的继承来体现。简单来说，如果一个类A使用了另一个类B的成员（属性和方法），我们就可以说A类继承了B类，同时这也体现了OOP中==代码重用的特性==！

继承表示：将从父类哪里继承（复制）成员的变量和成员方法（不含私有）

继承：一个类从另一个已有的类获得其成员的相关特性，就叫作继承！

派生：从一个已有的类产生一个新的类，称为派生！

很显然，继承和派生其实就是从不同的方向来描述的相同的概念而已，本质上是一样的！

父类：也叫作基类，就是指已有被继承的类！

子类：也叫作派生类或扩展类

扩展：在子类中增加一些自己特有的特性，就叫作扩展，没有扩展，继承也就没有意义了！

单继承：

一个类只能继承自一个其他的类，不能继承多个类，单继承也是大多数面向对象语言的特性！

在Python继承中，如A类继承了B类，B类又继承了C类。则根据继承的传递性，则A类也会自动继承C类中所有属性和方法（公共）

多继承：

一个类同时继承了多个父类， （C++、Python等语言都支持多继承）

子类扩展：重写父类属性和方法

扩展特性：继承让子类继承父类的所有公共属性和方法，但是如果仅仅是为了继承公共属性和方法，继承就没有实际的意义了，应该是在继承以后，子类应该有一些自己的属性和方法。

什么是重写？

重写也叫作==覆盖==，就是当子类成员与父类成员名字相同的时候，从父类继承下来的成员会重新定义！

此时，通过子类实例化出来的对象访问相关成员的时候，真正其作用的是子类中定义的成员！

class Animal(object):
    def eat(self):
        print('i can eat')
    
    def call(self):
        print('i can call')
        
class Dog(Animal):
    pass
 
class Cat(Animal):
    pass
 
wangcai = Dog()
wangcai.eat()
wangcai.call()
 
miaomiao = Cat()
miaomiao.eat()
miaomiao.call()

class Animal(object):
    def eat(self):
        print('i can eat')
    # 公共方法
    def call(self):
        print('i can call')
 
 
class Dog(Animal):
    # 重写父类的call方法
    def call(self):
        print('i can wang wang wang')
 
 
class Cat(Animal):
    # 重写父类的call方法
    def call(self):
        print('i can miao miao miao')
 
 
wangcai = Dog()
wangcai.eat()
wangcai.call()
 
miaomiao = Cat()
miaomiao.eat()
miaomiao.call()

继承总结：

多态

同样的行为，但是使用不同的对象，获得不同的运行状态

态指的是一类事物有多种形态。

定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果。

==不同对象 => 使用相同方法 => 产生不同的执行结果。==

① 多态依赖继承（不是必须的）

② 子类方法必须要重写父类方法

首先定义一个父类，其可能拥有多个子类对象。当我们调用一个公共方法（接口）时，传递的对象不同，则返回的结果不同。

'''
首先定义一个父类，其可能拥有多个子类对象。当我们调用一个公共方法（接口）时，传递的对象不同，则返回的结果不同。
'''
class Fruit(object):
    def makejuice(self):
        print('i can make juice')
 
class Apple(Fruit):
    # 重写父类方法
    def makejuice(self):
        print('i can make apple juice')
 
class Banana(Fruit):
    # 重写父类方法
    def makejuice(self):
        print('i can make banana juice')
 
class Orange(Fruit):
    # 重写父类方法
    def makejuice(self):
        print('i can make orange juice')
 
# 定义一个公共接口（专门用于实现榨汁操作）
def service(obj):
    # obj要求是一个实例化对象，可以传入苹果对象/香蕉对象
    obj.makejuice()
 
# 调用公共方法
service(Orange())

多态总结：

参考链接：python面向对象的三大特性:封装，继承，多态_python的继承性-CSDN博客