Python基础——面向对象（三）

1.继承

• 继承是⾯向对象三⼤特性之⼀
• 通过继承我们可以使⼀个类获取到其他类中的属性和⽅法
• 在定义类时，可以在类名后⾯的括号中指定当前类的⽗类(超类、基类)
• 继承提⾼了类的复⽤性。让类与类之间产⽣了关系。有了这个关系，才有了多态的特性

# object是所有类的父类
class Animal(object):

    def run(self):
        print('奔跑')

    def shout(self):
        print('叫')


class Dog(Animal):
    pass


d = Dog()
d.run()   # 子类调用父类方法
r = isinstance(d, Dog)
p = isinstance(d, Animal)  # 检查d是否是Animal的实例对象
i = issubclass(Dog, Animal)  # 检查Dog是否是Animal的子类
print(r, p, i)
# 输出结果：
# 奔跑
# True  True True

2.方法重写

• 在⼦类中有和⽗类同名的⽅法，通过⼦类实例去调⽤⽅法时，会调⽤⼦类的⽅法⽽不是⽗类的⽅法，这个特点我们称之为⽅法的重写(覆盖)
• 当我们调⽤⼀个对象的⽅法时：
  • 会优先去当前对象中寻找是否具有该⽅法，如果有则直接调⽤
  • 如果当前对象中没有该方法，则去当前对象的⽗类中寻找，如果⽗类中有则直接调⽤⽗类中的⽅法
  • 如果父类中也没有，则去父类的父类中寻找，依此类推，直到找到object，如果依然找不到，程序就报错

class Animal(object):

    def run(self):
        print('奔跑')


class Dog(Animal):

    def run(self):
        print('狗奔跑')


d = Dog()
d.run()
# 输出结果：狗奔跑

3.super()

• super()可以获取当前类的父类的初始化属性
• 通过super()返回对象，调用父类初始化属性时，不需要传递self

class Animal(object):

    def __init__(self, name):

        self._name = name

    @property
    def name(self):

        return self._name

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


class Dog(Animal):

    def __init__(self, name, age):
        # 调用父类的初始化属性Animal().__init__(self, name)    使用super(),比用传递self参数
        super().__init__(name)
        self._age = age

    @property
    def age(self):

        return self._age

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


d = Dog('二哈', 3)
print(d.name)
print(d.age)

4.多重继承

• Python⽀持多重继承。即⼀个类制定多个⽗类
• 类名的()后边添加多个类，来实现多重继承
• 多重继承，会使⼦类同时拥有多个⽗类，并且会获取到所有⽗类中的⽅法
• 在开发中没有特殊情况，应该尽量避免使⽤多重继承。因为多重继承会让我们的代码更加复杂
• 如果多个⽗类中有同名的⽅法，则会先在第⼀个⽗类中寻找，然后找第⼆个，找第三个…前⾯会覆盖后⾯的

class A(object):

    def test(self):
        print('A类的方法')


class B(object):

    def test(self):
        print('B类的方法')


class C(A, B):
    pass


print(C.__bases__)   # 获取当前类所有的父类
c = C()
c.test()
# 输出结果：
# (<class '__main__.A'>, <class '__main__.B'>)
# A类的方法(如果这样写class C(B, A),则输出：B类的方法)

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

    @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):   # 这个函数不考虑对象的类型。只要有name属性就能执行

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


speak(a)   # 输出：你好闪电侠
speak(b)   # 输出：你好绿箭侠
speak(c)   # ttributeError: 'C' object has no attribute 'name'

# len() 获取长度，这个对象中有__len__这个特殊方法
# 只要对象中有__len__这个特殊方法，就可以通过len()获取长度
lst = [1, 2, 3, 4]
p = 'Python'
print(len(lst))
print(len(p)) 

6.属性和方法

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