面向对象第三讲

面向对象第三讲

单继承下的属性查找

# 案例1
class Foo():
    def f1(self):
        print('from.f1')
    def f2(self):
        print('from .f2')
        self.f1()

class Bar(Foo):
    def f1(self):
        print('Bar.f1')

obj = Bar()
obj.f2()

======================>
from .f2
Bar.f1


# 案例2
class Foo():
    def __f1(self):           # _Foo__f1()
        print('from.f1')
    def f2(self):
        print('from .f2')
        self.__f1()

class Bar(Foo):
    def __f1(self):           # _Bar__f1()
        print('Bar.f1')

obj = Bar()
obj.f2()

======================>
from .f2
from.f1
"""
单继承下的属性查找，对象---> 类---> 父类
"""

多继承下的属性查找

菱形继承：

非菱形继承：

python3里面都是新式类

super与mro方法

super是继承下属性查找的另外一种方法，详细看我博客

class People():
    def __init__(self, name, age):
        self.name = name
        self.age = age


class Student(People):
    def __init__(self, name, age, gender):
        # super(People, self).__init__(name, age)     python2这样写
        super().__init__(name, age)
        self.gender = gender

obj = Student('lyh', 10, 'male')


mro是看这个类属性查找顺序的，得到的是一个列表

class A:
    def test(self):
        print('A---->test')
        super().aaa()
class B:
    def test(self):
        print('B---->test')

    def aaa(self):
        print('B---->aaa')

class C(A,B):
    def aaa(self):
        print('C----->aaa')

c = C()
print(C.__mro__)

=============================>
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

多态

import abc

class Animal():
    @abc.abstractmethod
    def speak(self):
        pass


class People(Animal):
    def speak(self):
        print('makbak')

class Dog(Animal):
    def speak(self):
        print('汪汪汪')

obj = People()
obj.speak()

"""
多态类中的继承：不是让子类来继承父类的属性和方法的，而是用来给子类定制标准的

多态带来的特性： 在不用考虑对象数据类型的情况下，直接调用对象的方法
"""

# 错误示范
import abc

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def speak(self):
        pass


class People(Animal):
    def speak(self):
        print('makbak')

class Dog(Animal):
    def speak(self):
        print('汪汪汪')

        
class Pig(Animal):
    pass
obj = Pig()   # TypeError: Can't instantiate abstract class Pig with abstract methods speak

# 对多态特性的应用
import abc

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def speak(self):
        pass


class People(Animal):
    def speak(self):
        print('makbak')

class Dog(Animal):
    def speak(self):
        print('汪汪汪')

class Pig(Animal):
    def speak(self):
        print('woll')

obj = Pig()
def animal(animal):
    return animal.speak()
animal(obj)
# 调用这个animal方法的时候，可以不用考虑对象是否有这个方法,因为用抽象类实例化出的方法肯定有这个类

多态性的优点：
	1.增加了程序的灵活性
    2. 增加了程序的可扩展性(比如，上面的抽象类animal，不管我们怎么去继承这个抽象类，使用者都无须关注，因为只要继承了animal肯定有speak这个方法)

鸭子类型：

鸭子类型就是只要他们有相同的属性和功能那就是一样的，即”看起来像鸭子，走路像鸭子，那他就是鸭子“

比如文件，只要都有读和写的功能，那他就是文件

案例一：
#str,list,tuple都是序列类型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6))

#我们可以在不考虑三者类型的前提下使用len
s.__len__()
l.__len__()
t.__len__()

len(s)
len(l)
len(t)

组合

"""
组合： 一个对象拥有一个属性，该属性是另外一个对象

解决类与类之间代码冗余的问题：
	1.继承：满足什么是什么的关系
	2.组合：满足什么有什么的关系
"""

"""
需求：
    定义学生，课程类
    让学生可以选择课程，课程由课程类实例化得到
"""

class Student():
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.course_list = []

    def add_course(self, course_obj):
        self.course_list.append(course_obj)


class Course():
    def __init__(self, course_name, course_period, course_price):
        self.course_name = course_name
        self.course_period = course_period
        self.course_price = course_price

python = Course('python', 6, 100000)
stu1 = Student('egon', 10)
stu1.add_course(python)
print(stu1.name, stu1.course_list[0].course_name)