本节内容
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()
#输出
F3a2
F2a1
|
上面代码访问的顺序如下：
- 先去到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
)
#类名.方法名 方式调用
|
作用：当对象不需要传入参数时，去创建对象有些浪费，占着资源，所以还不如直接用类名直接去调用，这个类似于函数。