面向对象3
封装
封装
封装是指将数据与具体操作的实现代码放在某个对象内部，使这些代码的实现细节不被外界发现，外界只能通过接口使用该对象，而不能通过任何形式修改对象内部实现，正是由于封装机制，程序在使用某一对象时不需要关心该对象的数据结构细节及实现操作的方法。
class Demo(object):
def print_info(self):
print(d.name,d.age)
d = Demo()
d.name = 'amy'
d.age = 18
d.print_info()
继承-深度有优先机制
继承
继承是一种创建新类的方式，在Python中，新建的类可以继承一个或多个父类。
作用：
继承机制实现了代码的复用，多个类公用的代码部分可以只在一个类中，提供，而其他类只需要继承这个类即可。
class Demo: # 经典类
pass
class Demo1(object): # 新式类
pass
d = Demo()
print(d.__dir__())
d1 = Demo1()
print(len(d.__dir__()))
**python3的继承机制**
- 子类在调用某个方法或变量的时候，首先在自己内部（最深）查找，如果没有找到，则开始根据继承机制在父类里查找。
（下面代码里的super()函数可看下面的super()用处）
class GrandFather(object):
def sleep(self):
print('grandfather can sleep 6')
class Father(GrandFather): # 父类 基类
def __init__(self):
print("Father")
def eat(self):
print('father can eat')
def drink(self):
print('father can drink')
def run(self):
print('father can run')
class Son(Father): # 子类 派生类
def __init__(self):
print("Son")
def sleep(self):
print('son can sleep 10') # 到这里就override了
# super(Son,self).sleep() # super(cls,self)
super().sleep()
GrandFather.sleep(self)
def study_python(self):
print("i will study_python")
s = Son()
s.run()
s.sleep()
s.study_python()
'''
1.继承 深度优先
2.重写
防止执行父类中的方法
3.self永远是执行该方法的调用者
4.super（子类，self).父类中的方法(arg)
父类名.父类中的方法（self ,arg)
'''
继承-super()
super()函数
知道在子类中如果有与父类同名的成员，那就会覆盖掉父类里的成员。那如果你想强制调用父类的成员，就使用super()函数！
（详细代码可看上个代码）
'''
1.继承 深度优先
2.重写
防止执行父类中的方法
3.self永远是执行该方法的调用者
4.super（子类，self).父类中的方法(arg)
父类名.父类中的方法（self ,arg)
'''
私有属性及私有方法继承机制
私有方法和属性的继承
如果调用的是继承的父类中的方法，可以在这个公有方法中访问父类中的私有属性和私有方法。
但是如果在子类中实现了一个公有方法，那么这个方法是不能够调用继承的父类中的私有方法和私有属性的。
class A(object):
def __init__(self):
self.name = "amy"
self.__age = 18
def test(self):
print("A的test")
def __test1(self):
print("私有方法test1")
def test3(self):
return self.__age
class B(A):
def test2(self):
# print(self.__age) # 在B的内部也是访问不到的
# self.__test1() # 在B的内部也是访问不到的
pass
b = B()
# print(b.__age) # 私有属性没有被继承
# b.__test1() # 私有方法没有继承
b.test2()
'''
__init__方法也会继承，遵循深度优先继承规则
私有方法与私有属性继承
'''
多继承
多继承
所谓多继承，即子类有多个父类，并且具有它们的特征。
class GrandFather(object):
def sleep(self):
print("grandfather can sleep")
class Father(GrandFather):
def run(self):
print("father can run")
class Father1(GrandFather):
def run(self):
print("father1 can run")
def sleep(self):
print("father1 can sleep")
class Son(Father, Father1):
pass
s = Son()
s.run() # 左边优先 # 左边一条走到黑 grandfather can sleep
s.sleep() # 1.左边优先2.根最后执行
print(Son.__mro__)
'''
1.python支持多继承
2.1 左边优先
2.2 左边一条走到黑
2.3 左边优先 根最后执行
'''
多态
多态
多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
动态语言调用实例方法时不检查类型，只要方法存在，参数正确，就可以调用。这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看作是鸭子。
所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态。
class People(object):
def con_self(self):
print("my name is ..")
class Girl(People):
def con_self(self):
print("my name is amy")
def con_self(obj):
obj.con_self()
p = People()
# p.con_self()
con_self(p)
g = Girl()
con_self(g)
