本节内容
1、self关键字
2、封装
3、继承
4、静态方法
一、self关键字
作用：调用当前方法的对象
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class Foo:
#静态字段或者公有属性
country = "中国"
def __init__(self,name,count):
self.name = name
self.count = count
def bar(self):
pass
obj1 = Foo("江苏"，100000)
obj1.bar |
注意：country = "中国" 属于公有字段，它的作用是:每个对象中保存相同的东西时，可以使用静态字段
二、封装
- 类中封装了 :字段、方法
- 对象中封装了：普通字段的值
- 不仅可以封装字段，还可以封装对象
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
class F1:
def __init__(self,n):
self.N = n
print("F1")
class F2:
def __init__(self,arg1):
self.a = arg1
print("F2")
class F3:
def __init__(self,arg2):
self.b = arg2
print("F3")
o1 = F1("alex")
o2 = F2(o1)
o3 =F3(o2)
######输出alex##### o3 =F3(o2)o3 ====> o2
# o2 = F2(o1)o3.b.a# o1 = F1("alex")o1.b.a.N |
三、继承
说明：子类继承父类，对象调用方法时，先从自己的类中去找，找不到，就会去找父类中的方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
class F1:
def __init__(self):
print('F1')
def a1(self):
print("F1a1")
def a2(self):
print("F1a2")
class F2(F1):
def __init__(self):
print("F1")
def a1(self):
print("F2a1")
def a2(self):
self.a2()
print("F2a2")
class F3(F2):
def __init__(self):
print("F3")
def a2(self):
print("F3a2")
obj = F3()
obj.a1()#输出F3a2F2a1 |
上面代码访问的顺序如下：
- 先去到F3中找a1方法，没有找到
- 到F2父类去找，找到了a1方法，去执行a1方法
- 执行过程中需要调用F3中的a2方法
四、静态方法
4.1 类的组成
- 字段：1.普通字段(保存在对象中)，2静态字段(保存在类中)
- 方法：普通方法(保存在类中，用对象去调用)
|
1
2
3
4
5
6
7
|
class F1:
age = 18 #静态字段
def __init__(self,name):
self.name = name #普通字段
def a1(self): #普通方法
print('F1a1')
|
4.2 静态方法
特点：
- 保存在类中
- 调用者无需创建对象
- 可以有任意个参数
|
1
2
3
4
5
6
7
8
|
class F1:
@staticmethod #声明是静态方法
def a1(n1,n2): #无需传入对象，但是可以声明多个值
print('xiaogao')
F1.a1(1,2) #类名.方法名 方式调用
|
作用：当对象不需要传入参数时，去创建对象有些浪费，占着资源，所以还不如直接用类名直接去调用，这个类似于函数。