zoukankan      html  css  js  c++  java
  • python开发面向对象基础:组合&继承

    一,组合

    组合指的是,在一个类中以另外一个类的对象作为数据属性,称为类的组合      人类装备了武器类就是组合

    1.圆环,将圆类实例后传给圆环类

     1 #!/usr/bin/env python
     2 #_*_coding:utf-8_*_
     3 
     4 #circle,圆类
     5 from math import pi
     6 class Circle:
     7     def __init__(self,radius):
     8         self.radius = radius
     9     def perimeter(self):
    10         return 2 * pi * self.radius
    11     def area(self):
    12         return pi * self.radius **2
    13 
    14 # c1 = Circle(10)
    15 # print(c2.area())
    16 
    17 #圆环(不判断半径版本),就是圆的组合,利用了上面圆的类
    18 class Ring:
    19     def __init__(self,outside_radius,inside_radius):
    20         self.outside_circle = Circle(outside_radius)   #实例化一个圆形,作为self.outside_circle属性的值
    21         self.inside_circle = Circle(inside_radius)     #再实例化一个圆形
    22     def area(self):
    23         return self.outside_circle.area() - self.inside_circle.area()
    24     def perimeter(self):
    25         return self.inside_circle.perimeter() + self.outside_circle.perimeter()
    26 
    27 # r1 = Ring(20,10)     #这是傻瓜版本,没有考虑谁的半径大,谁是外圈内圈
    28 # print(r1.area())
    29 # print(r1.perimeter())
    30 
    31 #圆环(判断半径版本)
    32 class Ring:
    33     def __init__(self,outside_radius,inside_radius):
    34         outside_r = max(outside_radius,inside_radius)   #判断谁大谁是外环
    35         inside_r = min(outside_radius,inside_radius)    #
    36         self.outside_circle = Circle(outside_r)   #实例化一个圆形,作为self.outside_circle属性的值
    37         self.inside_circle = Circle(inside_r)     #再实例化一个圆形
    38     def area(self):
    39         return self.outside_circle.area() - self.inside_circle.area()
    40     def perimeter(self):
    41         return self.inside_circle.perimeter() + self.outside_circle.perimeter()
    42 
    43 # 将判断在实例化的时候判断
    44 # outer = input('外半径:')
    45 # inner = input('内半径:')
    46 # if outer.isdigit() and inner.isdigit() and int(outer) > int(inner):
    47 #     r1 = Ring(int(outer),int(inner))
    48 #     print(r1.perimeter())
    49 #     print(r1.area())
    50 
    51 # 将判断给类方法里面去判断
    52 # r1 = Ring(20,10)
    53 # print(r1.area())
    54 # print(r1.perimeter())

    二,.多组合

     1 #!/usr/bin/env python
     2 #_*_coding:utf-8_*_
     3 
     4 # 老师 课程 生日
     5 # 第一种组合,在里面组合
     6 class Teacher:
     7     def __init__(self,name,salary,friend,course_name,course_period,course_price):
     8         self.name = name
     9         self.salary = salary
    10         self.bf = friend
    11         self.course = Course(course_name,course_period,course_price)   #这里实例化Course
    12 
    13 class Course:
    14     def __init__(self,name,period,price):
    15         self.name = name
    16         self.period = period
    17         self.price = price
    18 
    19 egg = Teacher('egon',200,'yuan','python','6months',20000)  #传入老师,课程的属性
    20 print(egg.bf)
    21 print(egg.course.name)     # egg.course就是Course的实例,相当于python
    22 
    23 # 第二种组合,在外面组合将课程先实例化后传入,适用于共性一样的
    24 class Teacher:
    25     def __init__(self, name, salary, friend, python):
    26         self.name = name
    27         self.salary = salary
    28         self.bf = friend
    29         self.course = python
    30 
    31 class Course:
    32     def __init__(self, name, period, price):
    33         self.name = name
    34         self.period = period
    35         self.price = price
    36 
    37 python = Course('python', '6months', 20000)
    38 #将python课程实例写这里,那么所有教Python的老师都可以这么写
    39 egg = Teacher('egon', 200, 'yuan', python)    #Python实例化后传入,就不需要每次传入很多参数,较少内存
    40 print(egg.bf)
    41 print(egg.course.name)
    42 
    43 # 第三种组合,在外面组合,适用于每个人都有的,但是又不一样的
    44 class Teacher:
    45     def __init__(self,name,salary,friend,python):
    46         self.name = name
    47         self.salary = salary
    48         self.bf = friend
    49         self.course = python
    50 
    51 class Birth:
    52     def __init__(self,year,month,day):
    53         self.year = year
    54         self.month = month
    55         self.day = day
    56 
    57 # egg = Teacher('egon', 200, 'yuan', 'python')
    58 # egg_birth = Birth(1965,2,2)
    59 # print(egg_birth.year)
    60 # 将整个生日类的东西给了交给了egg的birth,可以调用所有属性和方法
    61 # 如果写在老师类里面,那就太多了属性,代码就不易读
    62 # 重新定个新类,然后绑定给老师
    63 # egg.birth = egg_birth
    64 # print(egg.birth.year)

    三,继承

    继承是一种创建新类的方式,在python中,新建的类可以继承一个或多个父类,父类又可称为基类或超类,新建的类称为派生类或子类

     1 #!/usr/bin/env python
     2 #_*_coding:utf-8_*_
     3 
     4 # 子类会继承父类的所有属性和方法
     5 class Animal:      #父类  基类  超类
     6     def __init__(self,name,life_value,aggr):
     7         self.name = name
     8         self.life_value = life_value
     9         self.aggr = aggr
    10 
    11 class Person(Animal):  #子类  派生类
    12     pass
    13 
    14 class Dog(Animal): #子类  派生类
    15     pass
    16 
    17 egg = Person('egon',1000,50)
    18 print(egg.name)
    19 print(egg.aggr)
    20 
    21 # class Dad:pass
    22 # class Ma:pass
    23 # class Son1(Dad,Ma):pass    多继承
    24 # class Son2(Dad):pass
    25 
    26 # print(Son1.__bases__)    __bases__查看父类
    27 # print(Son2.__bases__)
    28 # print(Dad.__bases__)     --obj是所有类的鼻祖

    3.1 继承与抽象

    先抽象,在继承

    抽象分成两个层次: 

    1.将奥巴马和梅西这俩对象比较像的部分抽取成类; 

    2.将人,猪,狗这三个类比较像的部分抽取成父类。

    抽象最主要的作用是划分类别(可以隔离关注点,降低复杂度)

    继承:是基于抽象的结果,通过编程语言去实现它,肯定是先经历抽象这个过程,才能通过继承的方式去表达出抽象的结构。

    抽象只是分析和设计的过程中,一个动作或者说一种技巧,通过抽象可以得到类

    3.2 经典类与新式类

     1 #!/usr/bin/env python
     2 #_*_coding:utf-8_*_
     3 
     4 #python2
     5 #class Dad:         #经典类  这个是不会集成obj的类
     6 #class Dag(object)  #新式类
     7 
     8 #python3
     9 #不存在经典类
    10 #class Dad  ==  class Dag(object) #新式类

    四,派生

    当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性(不会影响到父类),需要注意的是,一旦重新定义了自己的属性且与父类重名,那么调用新增的属性时,就以自己为准了。

      1 #!/usr/bin/env python
      2 #_*_coding:utf-8_*_
      3 
      4 #继承
      5 class Pet:
      6     def eat(self):
      7         pass
      8     def sleep(self):
      9         pass
     10     def drink(self):
     11         pass
     12 
     13 class Cat(Pet):            #Pet类的一个派生类,也叫子类
     14     def catch(self):pass   #Pet类的一个派生方法
     15 
     16 class Dog(Pet):
     17     def watch_door(self):pass
     18 
     19 # 中华气死猫 = Cat()
     20 # 中华气死猫.catch()
     21 # 中华气死猫.eat()
     22 
     23 #1.人狗大战继承版本
     24 class Animal:      #父类  基类  超类
     25     def __init__(self,name,life_value,aggr):
     26         self.name = name
     27         self.life_value = life_value
     28         self.aggr = aggr  #攻击力
     29     def eat(self):
     30         self.life_value += 10
     31 
     32 class Person(Animal):  #子类  派生类
     33     def attack(self,enemy):    #人的派生方法
     34         enemy.life_value -= self.aggr
     35 
     36 class Dog(Animal): #子类  派生类
     37     def bite(self,person):   #狗的派生方法
     38         person.life_value -= self.aggr
     39 
     40 # egg = Person('gon',100,10)
     41 # dahei = Dog('dahei',200,20)
     42 # print(dahei.life_value)
     43 # dahei.eat()
     44 # print(dahei.life_value)
     45 # print(egg.life_value)
     46 # dahei.bite(egg)
     47 # print(egg.life_value)
     48 
     49 
     50 #2.如果属性多,增加对象属性,又要用父类的又要用自己的
     51 class Animal:      #父类  基类  超类
     52     def __init__(self,name,life_value,aggr):
     53         self.name = name
     54         self.life_value = life_value
     55         self.aggr = aggr  #攻击力
     56     def eat(self):
     57         self.life_value += 10
     58 
     59 class Person(Animal):  #子类  派生类
     60     def __init__(self,money):
     61         self.money = money   #派生属性
     62     def attack(self,enemy):    #人的派生方法
     63         enemy.life_value -= self.aggr
     64 
     65 class Dog(Animal): #子类  派生类
     66     def __init__(self,breed):
     67         self.breed = breed
     68     def bite(self,person):   #狗的派生方法
     69         person.life_value -= self.aggr
     70 
     71 # ha2 = Dog('牛头梗',20000,100)
     72 # 报错 _ __init__() takes 2 positional arguments but 4 were given
     73 # 在继承中,如果子类有的方法就执行子类的,如果没有执行父类的
     74 # 本例中子类有自己的Init方法,需要2个参数,加上self算一个,当然这个不需要传
     75 
     76 #3.有父类的对象属性,又有子类的属性,super方法来更改__init__
     77 class Animal:      #父类  基类  超类
     78     def __init__(self,name,life_value,aggr):
     79         self.name = name
     80         self.life_value = life_value
     81         self.aggr = aggr  #攻击力
     82     def eat(self):
     83         self.life_value += 10
     84 
     85 class Person(Animal):  #子类  派生类
     86     def __init__(self,money,name,life_value,aggr):
     87         super().__init__(name,life_value,aggr)
     88         self.money = money   #派生属性
     89 
     90     def attack(self,enemy):    #人的派生方法
     91         enemy.life_value -= self.aggr
     92 
     93 class Dog(Animal): #子类  派生类
     94     def __init__(self,breed,name,life_value,aggr):
     95         # Animal.__init__(self,name,life_value,aggr)        #让子类执行父类的方法,就是父类名.方法名(参数),连self也得传(经典类的继承)
     96         super().__init__(name,life_value,aggr)          #super关键字——新式类,跟上面的经典类效果一样
     97         # super(Dog,self).__init__(name,life_value,aggr)  #super关键字关键字——新式类解释上面的写法跟经典类一样,只是简化了
     98         self.breed = breed
     99     def bite(self,person):   #狗的派生方法
    100         person.life_value -= self.aggr
    101 
    102 # dahei = Dog('狼','dahei',2000,100)
    103 # print(dahei.life_value)
    104 
    105 
    106 #4.有父类的对象属性,又有子类的属性,super方法
    107 class Animal:      #父类  基类  超类
    108     def __init__(self,name,life_value,aggr):
    109         self.name = name
    110         self.life_value = life_value
    111         self.aggr = aggr  #攻击力
    112     def eat(self):
    113         self.life_value += 10
    114 
    115 class Person(Animal):  #子类  派生类
    116     def __init__(self,money,name,life_value,aggr):
    117         super().__init__(name,life_value,aggr)   #
    118         self.money = money   #派生属性
    119 
    120     def attack(self,enemy):    #人的派生方法
    121         enemy.life_value -= self.aggr
    122 
    123 class Dog(Animal): #子类  派生类
    124     def __init__(self,breed,name,life_value,aggr):
    125         #Animal.__init__(self,name,life_value,aggr)   #让子类执行父类的方法,就是父类名.方法名(参数),连self也得传
    126         super().__init__(name,life_value,aggr)  #super关键字——新式类
    127         #super(Dog,self).__init__(name,life_value,aggr)  #super关键字关键字——新式类
    128         self.breed = breed
    129     def bite(self,person):   #狗的派生方法
    130         person.life_value -= self.aggr
    131 
    132     def eat(self):       # 父类方法的重写
    133         super().eat()     #子类执行父类的eat方法,如果没有的话,就会执行下面代码,也可以在外面引用
    134         print('dog is eating~~~ ')
    135 
    136 dahei = Dog('', 'dahei', 2000, 100)
    137 print(dahei.life_value)
    138 dahei.eat()
    139 super(Dog,dahei).eat()   #父类方法的重写,在外面引用父类的方法,dahei就是self
    140 print(dahei.life_value)
    141 
    142 # 父类方法的重写不推荐用,因为这样还不如直接改了父类
  • 相关阅读:
    利用WinCE的精准计时函数来输出pwm信号以便控制舵机
    leafletjs旋转marker
    centos7 NodeJs安装问题:Error: Cannot find module '../lib/utils/unsupported.js'
    Django 自定义存储上传文件的文件名
    后端开发不会前端之表格插件的使用
    Django项目部署之sqlite版本升级
    SQL 循环30日
    SSRS 报表 报表迁移
    SQL SERVER中求上月、本月和下月的第一天和最后一天
    SSRS 报表 日期类表达式
  • 原文地址:https://www.cnblogs.com/jokerbj/p/7352073.html
Copyright © 2011-2022 走看看