(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中的多态。
