python开发面向对象基础：组合&继承

Posted 2020-10-02

一，组合

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

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 # 父类方法的重写不推荐用，因为这样还不如直接改了父类