类的继承、派生、组合、菱形的继承、多态

类的继承

继承是一种新建的类的方式，新建的类成为子类，被继承的类称为父亲

继承的特性是：子类会遗传父亲的属性

继承是类与类之间的关系

使用继承目的，可以减少代码的咒余

在python中，父类和子类只有在继承的时候才会产生

继承是为了拿到父类的所有东西

class Parent_Foo:
    def __init__(self,first_name,money,car,house)
    self.first_name = first_name
    self.car = car
    self.house =house
    self.money = money*0.5
    print('继承的财产扣掉一办')
    
    def find_wife(self):
		print(f'{self.first_name}先生找到妻子白富美‘)

              
class Son_Foo(Parent_Foo)
      pass
              
sf= Son_FOO（'二'，'1000','tesla','上海汤臣一品'）
print(sf.first_name)
print(sf.money)
print(sf.car)
sf.find_wife()
#二
#500.0
#tesla
#上海汤臣一品1栋
#二先生找到妻子白富美              

class Animal():
	def __init__(self,height,weight)
    	self.height = height
        self.weight =weight
    def jiao(self):
        print(self.__class__.__name__,'叫')
        
        
class Xingxing():
    def sleep(self):
        print('睡觉')
        
class People(Animal,Xingxing):
	def read(self):
		print('read')
    
    def jiao(self)
    	print('jiao')
        
        
aobama = People(170,140)
aobama = jiao()
#jiao
aobama = sleep()
#睡觉
meixi = People(168,140)
meixi.jiao()
#jiao


class Dog(Animal):
    def eat_shi(self):
        print('eat_shi')
        
shinubi = Dog(40,50)
shinubi.jiao()
# Dog 叫

==# 不推荐使用继承,当你继承多个的时候，功能与功能之间会混乱，顶多继承一
个
# 继承后查找顺序：先自己，在类，在父类，在父类，在父类的父类==

class Foo:
    def f1(self)
    	print('Foo.f1')
        
    def f2(self)			# self =b
    	print('Foo.f2')
        self.f1()			#b.f1()
        
        
class Bar(Foo):
    def f1(self)
    	print('Bar.f1')
        
        
        
b = Bar()
#{}
print(b.__dict__)
# Foo.f2
b.f2()
# Bar.f1

类的派生

• 派生：子类中新定义的属性的这个过程叫做派生，并且需要记住子类在使用派生的属性始终是以自己的为准
• 指明道姓访问某一个类的函数：该方式与继承无关

#派生方法一：
class OldboyPeople:
    '''由于学生和老师都是人，因此人都有姓名，年龄，性别'''
    school ='oldboy'
    
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age 
        self.gender =gender
        
class OldboyStudent(OldboyPeople):
    """由于学生类没有独立的__init__()方法，因此不需要声明继承父类的__init__方法，会自动生成"""
    def chooser_course(self):
        print('%s is choosing course' %self.name)
        
class OldboyTeacher(OldboyPeople):
    """由于老师类有独自的__init__()方法，因此需要声明继承父类的__init__()"""
    def __init__(self,name,age,gender,level):
		OldboyPeople.__init__(self,name,age,gender)
        self.level=level
        
    def score(self,stu_obj,num)
    	print('% is scoring'% self.name)
        stu_obj.score = num
        

stu1 = OldboyStudent('tank',18,'male')
tea1 = OldboyTeacher('nick','18','male',10)

print(stu1.__dict__)
#{'name': 'tank', 'age': 18, 'gender': 'male'}


print(tea1.__dict__)
{'name': 'nick', 'age': 18, 'gender': 'male', 'level': 10

• 严格以来继承属性查找关系
• super()会得到一个特殊的对象，该对象就是专门用来访问父类中的属性的（按照继承关系来的）
• super().init（不用为self传值）
• super 的完整用法就是super(自己的类名，self)，在python2中需要写完整，在python3中口蹄疫简写为super()

#派生方法二：
class OldboyPeolpe:
    school ='oldboy'
    
    def __init__(self,name,age,aex)
    	self.name =name
        self.age = age
        self.sex = sex
        
class OldboyStudent(OldBboyPeople):
    def __init__(self,name,age,sex,stu_id):
        super().__init__(name,age,sex)
        self.stu_id = stu_id
        
    def choose_course(self):
        print('%s is choosing course'% self.name)
        
stu1 = OldboyStudent('tank',19,'male',1)

print(stu1.__dict__)

#{'name': 'tank', 'age': 19, 'sex': 'male', 'stu_id': 1}

类的组合

• 组合就是一个类的对象具备爱某一个属性，该属性的值是指向另一个类的对象
• 组合是用来解决类与类之间代码咒余的问题
• 组合可以理解成多个人去造一个机器人，有的人造头，有的人造身体，手，大家完工后，最后机器人造出来了

#简单的选课系统
class People：
	def __init__(self,name,gender):
        self.name = name
        self.gender = gender
        
    def eat(self):
        print(f'{self.name}开始吃了')
        
class Student(People):
    def __init__(self,student_id,name,gender):
        self.student_id = student_id
        super(Student,self).__init__(name,gender)
        
    def choose_course(self,course):
        self.course = course
        print(f'{self.name}选课{course.name}成功)
              
              
def Teacher(People):
    def __init__(self,level,name,gender):
         self.level = level
         super(Teacher,self).__init__(name,gender)
         
    def scored(self,student,course,score):
        print(f'老师{self.name}给{student.name}课程{course.name}打分{score})
              
              
def Course:
     def __init__(self,name,price):
          delf.name =name
          delf.price =price
              
              
def Admin(People):
      def create_course(self,name,price):
          course = Course(name,price)
          print(f'管理员{self.name}创建了课程{name}')
          return course
              
#课程
#python = Course('Python','888')
#linux = Course('Linux','666')
              
#学生
zhubajie  =Student('01','zhubajie','male')
sunwukong = Student('02','sunwukong','male')
              
# 老师
nick = Teacher('1','nick','male')
tank =Teacher('2','tank','male')

              
#管理员
egon  =Admin('egon','male')
              
              
              
# 业务逻辑
*1创建课程
python = egon.create_course('python','8888')
print(python.__dict__)              
==管理员egon创建了课程python
{'name': 'python', 'price': '8888'}
              
              
linux = egon.create_course('linux','6666')
print(linux.__dict__)              
==管理员egon创建了课程linux
{'name': 'linux', 'price': '6666'}            
              
*2学生选择课程
zhubajie.choose_corse(python)
              
==zhubajie选课python成功              
              
*3老师给学生打分
nick.scored(zhubajie,python,'0')              
              
==老师nick给zhubajie课程python打分0             

菱形的继承

经典类 和新式类

在python3 当中 会默认继承object类

在python2 当中 不会默认继承object类，必须得自己手动添加

新式类：只要继承了object类的就是新式类，在python3当中所有的类都是新式类

经典类：没有继承object类的就是经典类，只要python2当中有经典类

当继承为菱形继承的时候，经典类和新式类的搜索某一个属性的循序会不一样的

• 经典类下：深度优先
• 新式类下：广度优先
• 经典类：一条路走到黑，深度优先

类的多态与多态性

多态指的是一类事物有多种形态

• 序列数据类型有多种形态：字符串，列表，元祖
• 动物有多种形态：人，狗，猪

#动物有多种形态：人类，猪，狗
def Animal:
    def run(self):          #子类约定俗成的必须实现这个方法
        raise AttributeError	（'子类必须实现这个方法'）
        
        
class People(Animal):
    def run(self):
        print('人在走')
        
class Pig(Animal):
    def run(self):
        print('Pig is walking')

class Dog(Animal):
    def run(self):
        print('dog is running')
        
peo1 =People()
pig1 =Pig()
d1 = Dog()


peo1.run()
#人在走
pig1.run()
#pig is walking
d1.run()
#dog is runing

import abc

class Animal(metaclass=abc.ABCMeta):  # 同一类事物:动物
    @abc.abstractmethod  # 上述代码子类是约定俗称的实现这个方法，加上@abc.abstractmethod装饰器后严格控制子类必须实现这个方法
    def talk(self):
        raise AttributeError('子类必须实现这个方法')


class People(Animal):  # 动物的形态之一:人
    def talk(self):
        print('say hello')


class Dog(Animal):  # 动物的形态之二:狗
    def talk(self):
        print('say wangwang')


class Pig(Animal):  # 动物的形态之三:猪
    def talk(self):
        print('say aoao')


peo2 = People()
pig2 = Pig()
d2 = Dog()

peo2.talk()
#say hello
pig2.talk()
#say aoao
d2.talk()
# wangwang

多态性

注意：多态与多态性非等同

多态性是指具有不停功能得函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象的方法中一般是这样表述多态性：向不同的对象发送同一条信息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去相应共同的消息，所谓消息，就是调用函数，不同的行为就是指不同的时间，即执行不同的函数

多态性的好处

• 1，增加了程序的灵活性：以不变应万变，不论对象千遍万遍，使用者都是同一种形式调用，如 func
• 2，增加了程序额的可扩展性：通过集成Animal类创建了一个新的类，使用者无法更新自己的代码，还是用func（animal）去调用