Python基础课第十四节课记录---面向对象第三讲

1. 继承

简介：

1. 提高了代码的复用性
2. 让类与类之间产生了关系，有了这个关系，才有了多态，继承是面向对象的三大特性之一

已有动物类，定义一个狗类

1. 直接修改动物类—修改起来比较麻烦，会违反ocp元组
2. 直接创建一个新的类(狗类)—新类比较麻烦，使用大量的复制粘贴，会出现大量的重复性代码
3. 直接从Animal类中继承它的属性和方法

class Animal:
    def run(self):
        print('动物跑....')
    def sleep(self):
        print('动物睡觉...')
# 在定义类时,可以在类名后面加上括号，括号内中指定的是当前类的父类(超类、基类、super)
class Dog(Animal):
    def run(self):
        print('狗跑')
d = Dog()
d.run()
d.sleep()
# 狗跑
# 动物睡觉...
r = isinstance(d, Dog)
print(r)
# True
r = isinstance(d, Animal)
print(r)
# True

如果在创建类的时候省略了父类，则默认父类是object，object是所有类的父类，所有类都继承object

issubclass()函数是检查一个类是不是另一个类的子类

2. 方法的重写

如果在子类中有和父类重名的方法，通过子类的实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点称之为方法的重写(覆盖 override)
当我们去调用一个对象的时候，会优先去当前对象寻找是否就有该方法，如果有直接调用，如果没有，则去当前对象的父类中去寻找，如果有直接调用父类中的方法，如果没有, 则去父类中的父类寻找，如果有直接调用，以此类推，指导找到object，如果依然没有就报错

class Animal:
    def run(self):
        print('动物跑....')
    def sleep(self):
        print('动物睡觉...')
class Dog(Animal):
    def run(self):
        print('狗跑')
d = Dog()
d.run()
d.sleep()
# 狗跑
# 动物睡觉...

3. super()

父类中所有的方法都会被子类继承，包括特殊方法，也可以重写特殊方法

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

    def run(self):
        print(f'{self._name}正在跑')

    def sleep(self):
        print(f'{self._name}正在睡觉')


class Dog(Animal):
    def __init__(self, name, color):
        super().__init__(name)
        self._color = color

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

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

    def run(self):
        print(f'{self._color}色的{self._name}正在跑')

    def home(self):
        print(f'{self._color}色的{self._name}会看家')


d = Dog('二哈', '黑')
d.run()
# 黑色的二哈正在跑
d.sleep()
# 二哈正在睡觉
d.home()
# 黑色的二哈会看家
print(d.name)
# 二哈
d.name = '德牧'
print(d.name)
# 德牧

4. 多重继承

类名.双下划线bases双下划线：可以用来获取当前类的所有父类
在Python中是支持多重继承的，也就是我们可以为一个类同时指定多个父类
在开发中没有特殊情况，尽量避免使用多重继承，因为多重继承会让我们代码过于复杂
如果多个父类中有同名的方法，则会在第一个父类中寻找，然后找第二个…前面会覆盖后面的

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 5

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

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


def speak(obj):
    print('你好 %s'%obj.name)

# 在speak2这个函数中做了一个类型检查，也就是只有obj是A类型的对象的时候，才可以正常使用，其他类型的对象无法使用该函数，这个函数其实就违反了多态
# 违反了多态的函数，只适用于一种类型的对象，无法处理其他类型的对象，这样导致函数的适用性非常差

def speak2(obj):
    # 类型检查
    if isinstance(obj,A):
        print('你好 %s'%obj.name)

a = A('葫芦娃')
b = B('钢铁侠')
speak2(a)
# 你好 葫芦娃
speak2(b)
# 无结果

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

6. 类中的属性和方法

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

实例属性：通过实例对象添加的属性属于实例属性，只能通过实例属性来访问和修改，类对象无法访问和修改。通过实例对象添加的属性属于实例属性。

实例方法：在类中定义，以self为第一个参数都是实例方法，实例方法在调用时，Python会将调用对象作为self传入，通过类对象调用时，不会自动传self，必须手动传self。

类方法：类方法的第一个参数是cls，也会被自动传递，cls就是当前的类对象，类方法可以通过类去调用，也可以通过实例调用。

静态方法：基本上是一个和当前类无关的方法，它只是一个保存到当前类中的函数，静态方法一般都是些工具方法，和当前类无关。

class A(object):
    count = 0 # 类属性

    def __init__(self): # 实例方法
        self.name = '葫芦娃'

    def test1(self): # 实例方法
        print('我是test1方法')

    @classmethod # 类方法
    def test2(cls):
        print('我是test2方法.........', cls)
        print(cls.count)

    @staticmethod # 静态方法
    def test3():
        print('我是test3方法........')


a = A()
print(a.count)
# 0
a.account = 5 # 实例属性
print(a.account)
# 5
a.test1()
# 我是test1方法
A.test1(a)
# 我是test1方法
a.test2()
# 我是test2方法......... <class '__main__.A'>
# 3
A.test2()
# 我是test2方法......... <class '__main__.A'>
# 3
a.test3()
# 我是test3方法........
A.test3()
# 我是test3方法........

7. 小结

通过这堂课的学习，是我对面向对象有了更加深刻的认识，也通过课后整理笔记把课上的知识点回顾了一遍。这节课过后，面向对象就全部学完了，面向对象的三大特征—封装、继承和多态，我也差不多能够掌握了。进阶班下个月就要开课了，要继续加油喔！