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

Posted zhuyuanying123--

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了类的继承派生组合菱形的继承多态相关的知识,希望对你有一定的参考价值。

类的继承

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

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

继承是类与类之间的关系

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

在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)去调用

以上是关于类的继承派生组合菱形的继承多态的主要内容,如果未能解决你的问题,请参考以下文章

面向对象进阶1

C++ 继承:父子类赋值转换菱形继承虚继承继承与组合

C++ 继承:父子类赋值转换菱形继承虚继承继承与组合

bingc(继承)

bingc++(继承)

bingc++(继承)