zoukankan      html  css  js  c++  java

  • 面向对象

    面向对象 - 继承:
        1.继承: 类与类之间的关系 什么是什么的关系  eg:人是动物 狗是动物
              功能: 解决代码重用问题, 创建新类的方式,
          类: 可继承一个或多个父类:
              父类 == 基类/超类
              类 == 派生类/子类

              类: 对象之间相似的特征
              父类: 类与类之间相似的特征

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


          
            继承相关知识:
              1.查看继承哪些类?
                  SubClass1.__bases__
              2.父类的属性 都是子类的, 数据属性和函数属性都是公用的 Garen.x is Riven.x == True  Riven.attack is Riven.attack == True
              3.属性查找的顺序:1.对象自己内部找-->2.对象所在的类里面找-->3.父类里面找
        2.派生:
            2.1.子类可以添加自己的新属性  数据属性和函数属性
            2.2.子类的属性名和父类的属性名 若相同 子类覆盖父类的属性
        3.继承的实现原理:
            3.1.python会计算出一个方法解析顺序列表(MR0),所有基类的线性顺序列表
                F.mro() == F.__mro__
                [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.X'>,
                <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
            3.2.属性查找：
                0.对象本身优先于子类
                1.子类优先于父类
                2.多个父类会根据（MRO）列表 依次查找
                3.如果对下一个类存在两个合法的选择,选择第一个父类
            3.3.python的类
                py2:
                    经典类：没有继承object的类，以及它的子类都称之为经典类 --》深度优先
                    新式类：继承object的类，以及它的子类都称之为新式类 --》广度优先
                py3:
                    新式类：一个类如果没有继承object的类，就默认继承object --》广度优先
            3.4.属性查找方式：（本质都是按列表mro顺序来的）
                1.深度优先
                2.广度优先
           

        
        4.派生出的方法 重用 父类的属性：
            4.1.指名道姓 不依赖继承
                Hero.attack(self, enemy)
                Hero.__init__(self,nickname,life_value,aggressivity)
            4.2.super() 依赖继承   super() 找的是子类的（MRO）列表中的下一个  C.mro()
                super(Garen, self).attack(enemy)    py2 写法
                super().attack(enemy)               py3 写法
                super().__init__(nickname,life_value,aggressivity)

      1 class ParentClass1:
  2     pass
  3 
  4 class ParentClass2:
  5     pass
  6 
  7 class SubClass1(ParentClass1):
  8     pass
  9 
 10 class SubClass2(ParentClass1,ParentClass2):
 11     pass
 12 
 13 # print(SubClass1.__bases__)
 14 # print(SubClass2.__bases__)
 15 
 16 class Hero:
 17     x=3
 18     def __init__(self,nickname,life_value,aggressivity):
 19         self.nickname=nickname
 20         self.life_value=life_value
 21         self.aggressivity=aggressivity
 22 
 23     def attack(self,enemy):
 24         enemy.life_value-=self.aggressivity
 25         print('父类 里的 attack')
 26 
 27 class Garen(Hero):
 28     # x=2
 29     camp='Demacia'
 30 
 31     def __init__(self,nickname,life_value,aggressivity):
 32         # Hero.__init__(self,nickname,life_value,aggressivity)
 33         # super(Garen, self).__init__(nickname,life_value,aggressivity)
 34         super().__init__(nickname,life_value,aggressivity)
 35         print('garen __init__')
 36 
 37     def attack(self,enemy):
 38         # Hero.attack(self, enemy)
 39         # super(Garen, self).attack(enemy)
 40         super().attack(enemy)
 41         print('子类 里的 attack')
 42 
 43 
 44     def func(self):
 45         print('func')
 46 
 47     def func2(self):
 48         pass
 49 
 50 class Riven(Hero):
 51     camp='Noxus'
 52     pass
 53 
 54 # g=Garen('alice1',50,30)
 55 # g2=Garen('alice2',50,30)
 56 # r=Riven('alex',80,60)
 57 # print(g.__dict__)
 58 # g.attack(r)
 59 
 60 # print(g.camp)
 61 # print(r.camp)
 62 # g.attack(r)
 63 # g.func()
 64 # r.func()
 65 # print(g.x)
 66 
 67 # print(g.__dict__)
 68 # g.x=2
 69 # print(g.x)
 70 # print(r.life_value)
 71 # g.attack(r)
 72 # print(r.life_value)
 73 # print(Garen.x is Riven.x )
 74 # print(Garen.attack)
 75 # print(Riven.attack)
 76 # print(Riven.attack is Riven.attack)
 77 # print(g.attack,id(g.attack))
 78 # print(r.attack,id(r.attack))
 79 # print(id(g))
 80 # print(g.func,id(g.func))
 81 # print(g.func2,id(g.func2))
 82 # print(g2.func,id(g2.func))
 83 # print(g2.func2,id(g2.func2))
 84 # print(g.func is g.attack)
 85 # print(g.func is g.func2)
 86 # print(id(Garen.func),id(Garen.func2))
 87 
 88 class Foo:
 89     def f1(self):
 90         print('from Foo.f1')
 91 
 92     def f2(self):
 93         print('from Foo.f2')
 94         self.f1()
 95 
 96 class Bar(Foo):
 97     d=1
 98     def f1(self):
 99         print('from Bar.f1')
100 
101 # b=Bar()
102 # b.f2()
103 
104 class A:
105     pass
106 
107 class X(A):
108     pass
109 
110 class B(X):
111     pass
112 
113 class C(A):
114     pass
115 
116 class D(B):
117     pass
118 
119 class E(C):
120     pass
121 
122 class F(D,E):
123     pass
124 
125 f=F()
126 # print(f.__dict__)
127 # print(F.mro())
128 # print(F.__mro__)
129 
130 class Foo:
131     pass
132 # class Bar(Foo):
133 #     pass
134 # print(Foo.__bases__)
135 
136 class A:
137     def f1(self):
138         print('from A')
139         super().f1()
140 
141 class B:
142     def f1(self):
143         print('from B')
144 
145 class C(A,B):
146     pass
147 
148 c=C()
149 c.f1()
150 print(C.mro())
151 print(C.__mro__)
152 # [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
    继承

    面向对象 - 组合：
        组合：什么有什么的关系  继承是：什么是什么的关系  都实现了代码重用
              对象的属性 被赋值 一个对象/一个列表，列表有多个对象 等

     1 class People:
 2     def __init__(self,name,age,sex):
 3         self.name=name
 4         self.age=age
 5         self.sex=sex
 6 
 7 class Teather(People):
 8     def __init__(self,name,age,sex,level,salary):
 9         super().__init__(name,age,sex)
10         self.level=level
11         self.salary=salary
12 
13     def teach(self):
14         print('%s is teaching'%self.name)
15 
16 class Student(People):
17     def __init__(self,name,age,sex,class_time):
18         super().__init__(name,age,sex)
19         self.class_time=class_time
20 
21     def learn(self):
22         print('%s is learning'%self.name)
23 
24 class Course:
25     def __init__(self,course_name,course_price,course_period):
26         self.course_name=course_name
27         self.course_price=course_price
28         self.course_period=course_period
29 
30     def tell_info(self):
31         print('课程名<%s> 课程价钱<%s> 课程周期<%s>'%(self.course_name,self.course_price,self.course_period))
32 
33 class Date:
34     def __init__(self,year,month,day):
35         self.year=year
36         self.month=month
37         self.day=day
38 
39     def tell_info(self):
40         print('%s-%s-%s'%(self.year,self.month,self.day))
41 
42 tea1=Teather('alex',18,'male',10,3000)
43 tea2=Teather('egon',28,'female',8,2000)
44 
45 stu1=Student('alice',12,'female','08:30:00')
46 stu2=Student('lily',16,'male','09:00:00')
47 
48 python=Course('python',2000,'3mons')
49 linux=Course('linux',3000,'4mons')
50 
51 # date=Date(1990,10,11)
52 
53 # tea1.teach()
54 # stu1.learn()
55 # python.tell_info()
56 # date.tell_info()
57 
58 # tea1.course=[python,linux]
59 # tea1.course[0].tell_info()
60 # tea1.course[1].tell_info()
61 #
62 # stu1.course=python
63 # print(stu1.course.course_name)
64 
65 # stu1.course1=python
66 # stu2.course2=linux
67 # print(stu1.course1.course_name)
68 # print(stu2.course2.course_period)
69 
70 # stu1.course=[]
71 # stu1.course.append(python)
72 # stu1.course.append(linux)
73 # stu1.course[0].tell_info()
74 # stu1.course[1].tell_info()
75 
76 # stu1.birth=Date(2000,10,11)
77 # stu1.birth.tell_info()
    组合
  • 相关阅读:
    第 45 届国际大学生程序设计竞赛（ICPC）亚洲区域赛（南京）K Co-prime Permutation
    2020 CCPC绵阳站赛后回忆+总结
    CF 1473D Program
    Educational Codeforces Round 100 (Rated for Div. 2) 补题情况
    Codeforces Round #690 (Div. 3) (补题情况)
    这个博客停用，新博客地址：www.baccano.fun
    炫酷路径（牛客）
    洛谷 P1123 取数游戏
    洛谷P2802 回家
    cf上分的失落->高兴->更失落
  • 原文地址：https://www.cnblogs.com/alice-bj/p/8544512.html
Copyright © 2011-2022 走看看