13 面向对象（三）

1. 继承的简介

• 继承是面向对象三大特性之一
• • 在定义类时，可以在类名后面的括号中指定当前类的父类(超类、基类)
• 通过继承我们可以使一个类获取到其他类中的属性和方法。这有利于重新创建的新类，不用copy彼此共有属性和方法的代码，避免代码臃肿，修改、维护麻烦的隐患，以及避免ocp原则（扩展开放，修改关闭的原则）
• 继承提高了类的复用性。让类与类之间产生了关系。有了这个关系，才有了多态的特性

• 检查一个对象是否一个类的实例，用 isinstance（对象名，类名），返回布尔值
• 在创建类时，如果省略了父类，则默认父类为object
  object是所有类的父类，所有类都继承自object
  所有的对象都是object的实例
• 检查一个类是否另一个类的子类，用 issubclass（），返回布尔值

2. 重写

• 如果在子类中有和父类同名的方法，则通过子类实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点我们称之为方法的重写(覆盖)

class Animal:

    def run(self):

        print('动物跑.....')

class Dog(Animal):

    def run(self):

        print('狗跑.....')

d = Dog()

d.run()

输出：
狗跑

• 当我们用对象去调用一个方法时
  • 首先会优先去当前对象中寻找是否具有该方法，如果有则在直接调用
  • 如果没有，则去当前对象的父类中寻找，如果父类中有则调用父类中的方法。
  • 如果父类中没有，去父类中的父类去寻找，以此类推，直到找到object
  • 如果依然没有，则报错

class A(object):
    
    def test(self):
     
        print('A....')

class B(A):
   
    pass

class C(B):
   
    pass

c = C()

c.test()

输出：
A.....

------------------------------------------

class A(object):

    def test(self):

        print('A....')

class B(A):

    def test(self):

        print('B....')

class C(B):

    pass

c = C()

c.test()

输出：
B....

----------------------------------------------------

class A(object):

    def test(self):

        print('A....')

class B(A):

    def test(self):

        print('B....')

class C(B):

    def test(self):

        print('C....')

c = C()

c.test()

输出：
C....

3. super

• super()可以获取当前类的父类
• 并且通过super()返回对象调用父类方法时，不需要传递self

class Animal:
    def __init__(self,name,age):
        self._name = name
        self._age = age

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,name):
        self._name = name

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self,age):
        self._age = age

父类中所有的方法都会被子类继承，包括特殊方法

class Dog(Animal):
    def __init__(self,name,age,hight):
        
        #Animal.__init__(self,name,age)
        因Dog的父类有可能会更换，
        所以此处希望用动态的方式获取父类，
        上述语句更换为使用super（）
        
        supper().__init__(name,age)  #无需传入self
        
        self._hight = hight

    @property
    def hight(self):
        return self._hight
    
    @hight.setter
    def hight(self,hight):
        self._hight = hight

d = Dog('bin',3,175)
print(d.name,d.age,d.hight)

输出：
bin，3,175

4. 多重继承

• 在Python中是支持多重继承的。也就是我们可以为一个类同时制定多个父类，
  方法：在类名的()后边添加多个类，来实现多重继承
• 多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法，

类名.__ bases __
可以获取当前类名的所有父类

class A(object):
	pass

class B(object):
	pass

class C(B,A):
    pass

print(C.__bases__)

输出：
(<class '__main__.B'>, <class '__main__.A'>)
输出是一个元组，因__bases__获取的是多个父类

---

• 如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二个，找第三个…前面会覆盖后面的

class A(object):

    def test(self):

        print('A....')

class B(object):
    
    def test(self):

        print('B中的test方法...')

class C(B,A):
    pass

c = C()
c.test()

输出：
B中的test方法...

• 在开发中没特殊情况，应尽量避免使用多重继承。因多重继承会让代码更加复杂

5. 多态

• 多态是面向对象的三大特性之一
• 一个对象可以以不同形态去呈现

class A:

    def __init__(self,name):

        self._name = name
    
    @property
    def name(self):
        return self._name
    
    @name.setter
    def name(self,name):
        self._name = name

class B:

    def __init__(self,name):

        self._name = name
    
    def __len__(self):   添加此语句后可以使用函数len（）
        return 100            测量字符串长度
       
    @property
    def name(self):
        return self._name
    
    @name.setter
    def name(self,name):
        self._name = name

class C:
    pass

a = A('葫芦娃')
b = B('钢铁侠')
c = C()

对应speak()这个函数来说，只要对象中函数有name属性，
它就可以作为参数传递
这个函数并不考虑对象的类型。只要有name属性就可以
def speak(obj):

    print('你好 %s'%obj.name)

speak(a)    输出：葫芦娃
speak(b)    输出：钢铁侠
speak(c)    输出：（空白）

在speak2()中设置一个类型检查，
即只有符合obj是A类型的对象时，才可以使用
其他类型的对象使用不了该函数。这个函数就违反了多态
def speak2(obj):
    检查
    if isinstance(obj,A):
        print('你好 %s' % obj.name)
speak(a)    输出：你好葫芦娃
sepak(b)    输出：(空白)
sepak(c)    输出：(空白)



lst = [1,2,3]
s = 'python'
print(len(lst))
print(len(s))
print(len(b)) # TypeError: object of type 'B' has no len()

len() 获取长度 是因为这个对象中有一个特殊方法__len__
只要对象中有__len__特殊方法，就可以通过len()这个函数获取长度
因此，在上述 class B 中添加以下语句：
def __len__(self):
    return 100
print(b)

输出：
100

• 面向对象三大特性
  • 封装 确保对象中数据的安全
  • 基础 保证了对象的扩展性
  • 多态 保证了程序的灵活性

6. 属性和方法

• 属性

• 类属性，直接在类中定义的属性是类属性
• 类属性可以通过类或类的实例访问到。但是类属性只能通过类对象来修改，无法通过实例对象修改
• 实例属性 通过实例对象添加的属性属于实例属性
• 实例属性只能通过实例对象来访问和修改，类对象无法访问修改

• 方法

• 在类中定义，以self为第一个参数的方法都是实例方法
• 实例方法在调用时,Python会将调用对象以self传入
• 实例方法可以通过类实例和类去调用
  • 当通过实例调用时，会自动将当前调用对象作为self传入
  • 当通过类调用时，不会自动传递self，我们必须手动传递self
• 类方法 在类的内容以@classmethod 来修饰的方法属性类方法
• 类方法第一个参数是cls 也会自动被传递。cls就是当前的类对象
• 类方法和实例方法的区别，实例方法的第一个参数是self，类方法的第一个参数是cls
• 类方法可以通过类去调用，也可以通过实例调用

• 静态方法

• 在类中用@staticmethod来修饰的方法属于静态方法
• 静态方法不需要指定任何的默认参数，静态方法可以通过类和实例调用
• 静态方法，基本上是一个和当前类无关的方法，它只是一个保存到当前类中的函数
• 静态方法一般都是些工具方法，和当前类无关