一、简介
面向对象编程是一种编程方式，使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。类就是一个模板，模板里可以包含多个方法（函数），方法里实现各种各样的功能，对象则是根据模板创建的实例，通过实例，对象可以执行类中的方法，每个对象都拥有相同的方法，但各自的数据可能不同。
二、类、对象和方法
在Python中，定义类是通过class关键字，class后面紧接着是类名，类名通常是大写开头的单词，紧接着是('要继承的类名')，表示该类是从哪个类继承下来的，可以有多个父类(基类),通常如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类，也可以不写。
|
1
2
3
4
5
6
7
8
|
class
F1(
object
):
def
__init__(
self
,name,age):
self
.name
=
name
self
.age
=
age
f1
=
F1(
'python'
,
27
)
上面的这个__init__()叫做初始化方法(或构造方法)， 在类实例化时，这个方法(虽然它是函数形式，但在类中就不叫函数了,叫方法)会自动执行，<br>进行一些初始化的动作，所以我们这里写的__init__(
self
,name,age)就是要在创建一个角色时给它设置这些属性。
|
参数self有什么用呢？
1.在内存中开辟一块空间指向f1这个变量名
2.实例化F1这个类首先执行其中的__init__()方法，相当于F1.__init__(f1,'python',27),是为了把'python',27这2个值跟刚开辟的f1关联起来，因为关联起来后，你就可以直接f1.name, f1.age 这样来调用啦。所以，为实现这种关联，在调用__init__方法时，就必须把f1这个变量也传进去，否则__init__不知道要把那2个参数跟谁关联，self其实就是实例化对象f1被当作参数传递了。
3.所以这个__init__(…)构造方法里的，self.name = name , self.age = age 等等就是要把这几个值存到f1的内存空间里。
三、面向对象三大特性，封装、继承和多态。
1、封装
面向对象有3大特性，首先我们来说第一个特性，封装，封装一般是通过在类中封装数据，而通过对象或者self获取。和其他面向对象的语言类似，也是通过构造函数来进行数据封装。下面来看一下代码。
|
1
2
3
4
5
6
7
8
9
10
|
class
A:
def
__init__(
self
,name):
# 构造函数，初始化数据，
self
.name
=
name
# 封装数据
def
f1(
self
):
print
(
self
.name)
# 通过self间接获取封装的数据
a
=
A(
'json'
)
# 相当于A.__init__(a,'json')将'json'封装到a中的name属性中
print
(a.name)
# 直接调用a对象的name属性
a.f1()
# python会把a当作参数传递给a.f1(a),所以print(a.name)
|
还有一种封装的方式，使用私用的属性来封装数据，看一下具体的用法，
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class
A:
name
=
'Jason'
__age
=
18
# 私有类属性
def
__init__(
self
):
self
.__like
=
'soccer'
# 私有实例属性
self
.hobby
=
'kkkk'
def
f1(
self
):
print
(
self
.__age)
# 私有类属性,私有实例属性只能被类中的方法调用
print
(
self
.__like)
# A.__age # 外部获取不到私有类属性,数据被封装起来
a
=
A()
# soccer
a.f1()
# 18
print
(a.hobby)
|
复杂的封装（一定要搞清楚）： 将类封装进对象中
|
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
|
class
c1:
def
__init__(
self
,name,obj):
self
.name
=
name
self
.obj
=
obj
class
c2:
def
__init__(
self
,name,age):
self
.name
=
name
self
.age
=
age
def
show(
self
):
print
(
self
.name)
class
c3:
def
__init__(
self
,a1):
self
.money
=
123
self
.aaa
=
a1
c2_obj
=
c2(
'aa'
,
12
)
# 将字符串'aa',数字12封装到c2_obj.name和c2_obj.age中
c1_obj
=
c1(
'python'
,c2_obj)
# 将字符串'python'封装到c1_obj.name中，将c2_obj中的属性c2_obj.name,c2_obj.age封装到c1_obj.obj中
c3_obj
=
c3(c1_obj)
# 将c1_obj中的所有属性,包括(c2_obj的所所有方法和属性)
print
(c3_obj.aaa.obj.name)
#c3类中找到c2类中的属性
ret
=
c3_obj.aaa.obj.show()
#c3类中找到c2类中的方法执行并接收返回值
print
(ret)
|
2、继承
继承的本质是将父类中的方法全部复制一份到子类中。Python里面的继承可以多继承，通过继承，可以获得父类的功能，继承的时候，如果父类中有重复的方法，优先找自己
通过继承创建的新类称为“子类”或“派生类”。被继承的类称为“基类”、“父类”或“超类”。
(1)、Python的类可以继承多个类，Java和C#中则只能继承一个类
(2)、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先
- 当类是经典类时，多继承情况下，会按照深度优先方式查找，Python2.x分为经典类和新式类(默认是经典类，继承了object父类则为新式类)
- 当类是新式类时，多继承情况下，会按照广度优先方式查找，Python3.x 统一都是新式类
经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。
继承的执行过程例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class
A:
def
f(
self
):
print
(
'a'
)
class
B:
def
f(
self
):
print
(
'b'
)
def
f1(
self
):
print
(
'bbbb'
)
class
C(A,B):
def
f1(
self
):
print
(
'c'
)
cc
=
C()
cc.f()
# 结果为a,在C类中没有f()这个方法时,继承时A基类写在前面,所以优先找A类中的f()方法
cc.f1()
# 结果为c,在C类中有f1()方法,则优先执行自己的方法
|
下面是重点和难点，在其他源码都是这么干的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
class
A:
def
bar(
self
):
print
(
'bar'
)
self
.f1()
class
B(A):
def
f1(
self
):
print
(
'b'
)
class
C():
def
f1(
self
):
print
(
'c'
)
class
D(B):
def
f1(
self
):
print
(
'd'
)
class
E(C,D):
pass
d
=
D()
d.bar()
|
上述继承的执行过程：
- 1. 对象d是D()的实例,d.bar()首先在D()中找有没有bar()方法
- 2. 没有则到D()类继承的父类B()类中找有没有bar()方法
- 3. 没有继续向上一层找B()类继承的父类A()类中找有没有bar()方法
- 4. A()类中有bar()方法则执行了bar()方法
- 5. bar()执行了做了两件事：(1)、打印print('c') (2)、执行了self.f1()
- 6. 执行了self.f1()，记住self是d对象，回归到最初 d=D()
- 7. 则执行了D()中的f1()方法，所以结果是bar和d
(3)、除了继承方法，还可以继承父类的构造函数
|
1
2
3
4
5
6
7
8
9
10
11
12
|
# 继承构造方法
class
A:
def
__init__(
self
):
self
.name
=
'jason'
class
B(A):
def
__init__(
self
):
self
.age
=
'16'
super
(B,
self
).__init__()
# A.__init__(self) #另一种继承构造函数的方法
d
=
B()
|
(4)、强制使用父类中的方法(非常有用)使用：super(子类类名,self).父类中的方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
class
C1:
def
f1(
self
):
print
(
'c1.f1'
)
return
123
class
C2(C1):
def
f1(
self
):
# 主动执行父类的f1方法
ret
=
super
(C2,
self
).f1()
print
(
'c2.f1'
)
return
ret
# C1.f1(self) 第二种方法，主动执行父类的方法，不常用
obj
=
C2()
obj.f1()
|
三、多态
Pyhon不支持Java和C#这一类强类型语言中多态的写法，python本身就是支持多态的，所以在Python面向对象里面讨论多态并没有什么意义，其Python崇尚“鸭子类型”。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
class
F1:
pass
class
S1(F1):
def
show(
self
):
print
(
'S1.show'
)
class
S2(F1):
def
show(
self
):
print
(
'S2.show'
)
def
Func(obj):
print
(obj.show())
s1_obj
=
S1()
Func(s1_obj)
s2_obj
=
S2()
Func(s2_obj)
|
在java,c#中定义参数是需要强制定义一个参数是什么类型的参数，类似下面的代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class
A:
pass
class
B(A):
pass
class
C(A):
pass
# arg参数：必须是A类型或A的子类
def
func(A arg):
print
(arg)
# obj = B()
# obj = C()
obj
=
A()
func(obj)
|
总结
以上就是本节对于面向对象初级知识的介绍，总结如下：
- 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
- 类 是一个模板，模板中包装了多个“函数”供使用
- 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
- 面向对象三大特性：封装、继承和多态
问答专区
问题一：什么样的代码才是面向对象？
答：从简单来说，如果程序中的所有功能都是用 类 和 对象 来实现，那么就是面向对象编程了。
问题二：函数式编程 和 面向对象 如何选择？分别在什么情况下使用？
答：须知：对于 C# 和 Java 程序员来说不存在这个问题，因为该两门语言只支持面向对象编程（不支持函数式编程）。而对于 Python 和 PHP 等语言却同时支持两种编程方式，且函数式编程能完成的操作，面向对象都可以实现；而面向对象的能完成的操作，函数式编程不行（函数式编程无法实现面向对象的封装功能）。
所以，一般在Python开发中，全部使用面向对象 或 面向对象和函数式混合使用
面向对象的应用场景:
- 多函数需使用共同的值，如：数据库的增、删、改、查操作都需要连接数据库字符串、主机名、用户名和密码
|
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
|
class
SqlHelper:
def
__init__(
self
, host, user, pwd):
self
.host
=
host
self
.user
=
user
self
.pwd
=
pwd
def
增(
self
):
# 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
# do something
# 关闭数据库连接
def
删(
self
):
# 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
# do something
# 关闭数据库连接
def
改(
self
):
# 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
# do something
# 关闭数据库连接
def
查(
self
):
# 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接
# do something
# 关闭数据库连接# do something
|
- 需要创建多个事物，每个事物属性个数相同，但是值的需求
如：张三、李四、杨五，他们都有姓名、年龄、血型，但其都是不相同。即：属性个数相同，但值不相同
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
class
Person:
def
__init__(
self
, name ,age ,blood_type):
self
.name
=
name
self
.age
=
age
self
.blood_type
=
blood_type
def
detail(
self
):
temp
=
"i am %s, age %s , blood type %s "
%
(
self
.name,
self
.age,
self
.blood_type)
print
temp
zhangsan
=
Person(
'张三'
,
18
,
'A'
)
lisi
=
Person(
'李四'
,
73
,
'AB'
)
yangwu
=
Person(
'杨五'
,
84
,
'A'
)
|
问题三：类和对象在内存中是如何保存？
答：类以及类中的方法在内存中只有一份，而根据类创建的每一个对象都在内存中需要存一份，大致如下图：
如上图所示，根据类创建对象时，对象中除了封装 name 和 age 的值之外，还会保存一个类对象指针，该值指向当前对象的类。
当通过 obj1 执行 【方法一】 时，过程如下：
- 根据当前对象中的 类对象指针 找到类中的方法
- 将对象 obj1 当作参数传给 方法的第一个参数 self