(09)-Python3之--类的三大特性（封装、继承、多态）

1、封装

封装，就是只能在类的内部访问，外部访问属性或方法会报异常，python中的封装很简单，只要在属性前或者方法名前加上两个下划线就可以，如self.__name，def __eat(self)这样就完成了属性和方法的私有化，也就是封装。

class hj:
    _arg = 'world'  # 封装
    __kws = 'kws'   # 封装
    def __init__(self):
        print(self._arg)   # 内部调用一个下划线的封装
        print(self.__kws)  # 内部调用两个下划线的封装

    # 提供封装访问函数让外部可以使用
    def get(self):
        print(self.__kws)

h = hj()
print(h._arg)   # 一个下划线的封装 外部是可以调用的
#print(h.__kws)  # 两个下划线的封装 外部是无法调用的(其实是可以调用的,只不过python给你做个一个重名的操作(_hj__kws))
h.get()    # 通过封装的方法来调用

2、继承

官方解释：所谓继承指提供了同一类对象共性的处理方法，子类继承父类共性的东西。 这样有利于代码的复用性，即子类拥有父类的方法。通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。

通俗讲就是：父类的是子类的，子类的还是子类的。

python中继承也非常简单，定义一个Animal类，下面有一个eat()方法，再定义一个Dog类，Dog类中什么都不写，用pass代替。然后实例化一个dog，让dog继承Animal类,dog可以使用eat()方法。

class Animal(object):
    def __init__(self,name):
        self.name = name
    def eat(self):
        print(self.name,"吃饭")

class Dog(Animal):
    pass
dog=Dog("旺财")
dog.eat()

结果：
旺财 吃饭

重写：和父类的方法名称一样。但是在子类里面，重新实现。

　　1、完全覆盖

class Animal:

    def __init__(self,name,private_v1):
        self.name = name
        self._private_v1 = private_v1
        self.__private_v2 = "private_really"　　# 私有化，不对子类开放

    def run(self):
        print("跑！！")

class Dog(Animal): # 继承父类（Animal）

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

    def eat(self):
        print("一只名叫 {} 的 {} 在啃骨头！！".format(self.name,self.kind))

    def run(self): # 重写父类的run（）方法
        print("我是一条狗，我有四条腿跑！！")

# 实例化
dog = Dog("二狗","哈士奇")
dog.run()
dog.eat()

结果：
我是一条狗，我有四条腿跑！！
一只名叫 二狗 的 哈士奇 在啃骨头！！

　　2、保留父类的做法，在它的基础上再扩展其它的内容。（扩展方式：super()）

　　　　super()的2种表达：

　　　　　　super().方法(参数列表)

　　　　　　super(子类名，self).方法(参数列表)

class Animal:

    def __init__(self, name, private_v1):
        self.name = name
        self._private_v1 = private_v1
        self.__private_v2 = "private_really" 

    def run(self):
        print("跑！！")


class Dog(Animal):  # 继承父类Animal

    def __init__(self, name, kind, private_v1):
        # 方法一
        super().__init__(name, private_v1)  # 调用父类现成的方法
        # 方法二
        # super(Dog,self).__init__(name)
        self.kind = kind  # 扩展子类自己的特性

    def eat(self):
        print("一只名叫 {} 的 {} 在啃骨头！！".format(self.name, self.kind))

    def gogo(self):  # 完全颠覆父类的做法
        super().run()   # 父类做法
        print("我是一条狗，我有四条腿跑！！") # 我的做法

# 实例化
dog = Dog("小白","二哈","private_v1")
dog.eat()
dog.gogo()

结果：
一只名叫 小白 的 二哈 在啃骨头！！
跑！！
我是一条狗，我有四条腿跑！！

多继承：

在python中是可以多继承的，继承的先后顺序是有区别的，当我们调用方法的时候，如果第一个继承的找不到，才会去第二个中找，但是只要在第一个类中找到调用的那个方法，即使参数个数不匹配也不会调用第二个父类中的，此时会报错。

class Student:
    def study(self):
        print("我是学生，我爱学习，我爱班级！")

class Employee:
    def work(self):
        print("我要赚钱，我要工作，我爱工作！！")

class People(Student,Employee): # 继承Student类,Employee类

    def do_something(self):
        self.work()
        self.study()

p = People()
p.do_something()

结果：
我要赚钱，我要工作，我爱工作！！
我是学生，我爱学习，我爱班级！

3.多态

python中本质上是没有真正多态这种思路，只是形式上有这样一个多态的思路。

class Animal(object):
    def __init__(self,color):
        self.color=color
    def eat(self):
        print("吃饭")

class Cat(Animal):
    def eat(self):
        print("猫吃鱼")

class Dog(Animal):
    def __init__(self,name,age,color):
        super(Dog,self).__init__(color)
        self.name=name
        self.age=age
    def eat(self):
        print("狗吃肉")
def feed(obj):
        obj.eat()

an=Animal("白色")#实例化Animal
cat=Cat("棕色")#实例化Cat
dog=Dog("小黄",2,"黄色")#实例化Dog

feed(an)
feed(cat)
feed(dog)

结果：
吃饭
猫吃鱼
狗吃肉

定义了一个Animal父类，两个子类Cat和Dog里面都有eat()方法，最后再定义一个feed()喂养方法，

传入一个obj对象，调用obj.eat()，然后实例化Animal，Cat和Dog，分别在feed中传入实例化对象an，cat和dog会分别打印出不同的语句，这个就是python中的多态。