python面向对象三 继承，多态、类方法

这次内容主要介绍了，继承，多态等相关知识点总结和代码示例。通过对继承的简介，方法重写，supper()，多重继承，多态，属性和方法。加深对面向对象的了解。
面向对象的三大特征是，封装、继承，多态。

1.继承简介

• 继承是面向对象三大特征之一
• 通过继承我们可以使一个获取到其他类中的属性和方法
• 在定义类时，可以在类名后面的括号中指定当前类的父类（超类，基类）
• 继承提高了类的复用性。让类与类之间产生了关系。 （有了这个关系，才有了多态的特征）

class Person():
    name='lizhe'
    age=20
    def hoby(self):
        print('我的爱好是篮球')
a=Person()
a.hoby()
print('-'*50)
class A(Person):   #继承   可以获取其他类中的方法
    pass
c=A()
c.hoby()

#在创建类时，如果省略了父类 ，则默认父类为object
#object是
class Person(object):
    pass
#所有的对象都是object的实例
print(issubclass(int,object))  #检查一个类是否是另一个类的子类

2.重写方法

• 如果在子类中有和父类同名的方法，则通过子类实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点我们称之为方法的重写（覆盖）
• 当我们调用一个对象的方法时：
  1.会优先去当前对象中寻找是否有该方法，如果有则会直接调用
  2.如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法
  3.如果没有，则去父类中的父类寻找，一次类推，直到找到 object ，如果还没找到就报错。

class Fruit():
    def apple(self):
        print('苹果')
    def banana(self):
        print('我喜欢吃香蕉')
class Vegetable(Fruit):
    def eat(self):
        print('我喜欢吃绿色蔬菜')
    def banana(self):
        print('我喜欢吃香蕉,我在蔬菜类中了')
class Meat(Vegetable):
    def beef(self):
        print('我喜欢吃牛肉')

a=Meat()
a.eat()
a.banana()   #会先找父类中的内容  没有在找父类中的父类中的内容
a.beef()
a.apple()    #在父类中的父类中找到的内容
c=Vegetable()
c.banana()

3.super()

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

class Animal():
    def __init__(self,name):
        self._name=name
    def run(self):
        print('走了。。。')
    def sleep(self):
        print('睡觉...')
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self,name):
        self._name=name
#父类中的所有方法都会被子类继承
class Dog(Animal):
    def __init__(self,name,age):
        #希望可以直接调用父类的__init__
        #希望有一种动态的方式来获取的父类
        super().__init__(name)  #通过super可以直接 获取父类
        #Animal.__init__(self,name)
        self._name=name
        self._age=age
    def run(self):
        print('dog走了。。。')
    def sleep(self):
        print('dog睡觉...')
    @property
    def age(self):
        return self._age
    @age.setter
    def age(self,age):
        self._age = age
d=Dog('小黄狗','3')  #不添加会报错
d.name='德牧'
print(d.name)
print(d.age)

4.多重继承

• 在python中支持多重继承。可以为一个类同时制定多个父类。
• 可以在类名的()后面添加多个类，来实现多重继承
• 多重继承会使子类同时有多个父类，并且会获取到所有父类中的方法
• 在开发中没有特殊情况，尽量避免使用多重继承。多重继承会让代码更加复杂
• 如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二个，第三个…前面会覆盖后面的

class A(object):
    def test(self):
        print('a....')
class B(object):
    def test(self):
        print('b中的....')
    def test2(self):
        print('b....')
class C(A,B):
    def test3(self):
        print('c....')

print(C.__bases__)   # __bases__ 方法获取当前所有的父类
print(B.__bases__)
c=C()
c.test()
c.test2()
c.test3()
b=B()
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):
        return 500
    @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()
def speak(obj):
    print('你好%s'%obj.name)
def speak2(obj):    #这个函数 只要对象函数中含有name属性，他就可以作为参数传递
    if isinstance(obj,A):   #检查实例
         print('你好%s'%obj.name)  
speak(a)
speak(b)
print(len(b))

6.属性和方法

• 属性
  类属性，直接在类中定义的属性是类属性
  类属性可以通过类或实例访问到。但是类属性只能通过类对象来修改，无法通过实例对象修改
  实例属性 通过实例对象添加的属性属于实例属性
  实例属性只能通过实例对象来访问和修改，类对象无法访问修改
• 方法
  在类中定义，以self为第一个参数的方法都是实例方法
  实例方法调用时，python会将调用对象以self传入
  实例方法可以通过实例和类去调用
  当通过实例调用时，会自动将当前调用对象以self传入
  当调用类调用时，不会自动传递self，我们必须手动传递self
  类方法 在类的内容以@classmethod来修饰的方法属性类方法
  类方法第一个参数时cls也会自动被传递。cls就是当前的类对象
  类方法和实例方法的区别，实例方法的第一个参数是self，类方法的第一个参数是cls
  类方法可以通过类去调用，也可以通过实例调用
• 静态方法
  在类中用@staticmethod来修饰的方法属于静态方法
  静态方法不需要指定任何的默认参数，静态方法可以通过类和实例调用
  静态方法，基本上是一个和当前类无关的方法，它只是一个保存到当前类中的函数
  静态方法一般都是一些工具方法，和当前类无关。

#创建一个类
class Afn(object):
    num=20
    def __init__(self):
        self.name='小明'

    def fn(self):
        print('这是fn函数方法',self)   #打印一下self

    @classmethod   #类方法
    def fn1(cls):
        print('这是一个类方法',cls)
    @staticmethod   #静态方法
    def fn2():
        print('这是一个静态方法')
a=Afn()  #定义实例方法

a.num=100
print(a.num)  #可以在实例中修改
Afn.num=200
print(Afn.num)
a.name='python'
Afn.name='java'
print(a.name)   #可以修改
print(Afn.name) #可以修改
print('-'*50)
#Afn.fn()  #类方法无法访问
a.fn()     #可以访问
print('-'*50)
Afn.fn1()  #可以访问了
a.fn1()    #也可以访问了
print('-'*50)
Afn.fn2() 
a.fn2()    

• 面向对象三大特征：
  封装 确保独享中数据的安全
  继承 保证了对象的扩展性
  多态 保证了程序的灵活性