介绍：
今天学习的主要是 面向对象编程的初级概念了解。2016年12月28日
目录：
-
面向对象编程介绍
-
类
-
封装
-
继承
-
多态
面向对象编程介绍
objcet-oriented Programming ---OOP
Class 类
一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法
Object 对象
一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同
Encapsulation 封装
在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法
Inheritance 继承
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承
Polymorphism 多态
多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
类
|
1
2
3
4
5
6
7
|
class
Role(
object
):
#定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写，以后再讲为什么
def
__init__(
self
,name,role,weapon,life_value
=
100
,money
=
15000
):
#初始化函数，在生成一个角色时要初始化的一些属性就填写在这里
self
.name
=
name
self
.role
=
role
self
.weapon
=
weapon
self
.life_value
=
life_value
self
.money
=
money
|
封装
|
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
Role(
object
):
members
=
0
##人员初始化 类变量，类属性
ac
=
None
##类公共的
def
__init__(
self
,name,role,weapon,life_value):
##形式参数，初始化方法
self
.name
=
name
### 实例变量， self自己的
self
.role
=
role
self
.weapon
=
weapon
self
.life_value
=
life_value
Role.members
+
=
1
##实例一次 加1
def
buy_weapon(
self
,weapon):
##方法
print
(
"{} is buying {}"
.
format
(
self
.name,weapon))
self
.weapon
=
weapon
##role的实例 ，把一个抽象的类变成一个具体的对象的过程 叫做 实例化
p1
=
Role(
"hequan"
,
"police"
,
"B10"
,
90
)
t1
=
Role(
"he1"
,
"Terrorist"
,
"B11"
,
100
)
t2
=
Role(
"he2"
,
"Terrorist"
,
"B12"
,
100
)
t3
=
Role(
"he2"
,
"Terrorist"
,
"B13"
,
100
)
p1.buy_weapon(
"AK47"
)
t1.buy_weapon(
"AK48"
)
p1.ac
=
"china"
##赋值,创建了一个变量 p1.ac=china,和 类的ac 没关系了。
t1.ac
=
"us"
Role.ac
=
"Janpanses"
##修改类的ac
Role.weapon
=
"D99"
print
(p1.weapon,t1.weapon)
print
(p1.ac,t1.ac)
##获取的是 p1.ac
print
(t2.ac,t3.ac)
#获取的是 类的ac
print
(t2.weapon,t3.weapon)
print
(Role.members)
##总人员
|
继承
|
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
class
SchoolMember(
object
):
member_nums
=
0
##人数初始化
def
__init__(
self
,name,age,sex):
self
.name
=
name
self
.age
=
age
self
.sex
=
sex
self
.enroll()
def
enroll(
self
):
print
(
"mSchoolMember {} is enrolled!"
.
format
(
self
.name))
SchoolMember.member_nums
+
=
1
def
tell(
self
):
print
(
"hello my name is [{}]"
.
format
(
self
.name))
class
Teacher(SchoolMember):
def
__init__(
self
,name,age,sex,course,salary):
super
(Teacher,
self
).__init__(name,age,sex)
self
.course
=
course
self
.salary
=
salary
def
teaching(
self
):
print
(
"Teacher [{}] is teaching {}."
.
format
(
self
.name,
self
.course))
class
Student(SchoolMember):
def
__init__(
self
,name,age,sex,course,tuition):
super
(Student,
self
).__init__(name,age,sex)
self
.course
=
course
self
.tuition
=
tuition
def
pay_tution(
self
):
print
(
"cao,student [{}] paying tution {}"
.
format
(
self
.name,
self
.tuition))
t1
=
Teacher(
"hequan"
,
24
,
"F"
,
"PY"
,
"10000"
)
t2
=
Teacher(
"he"
,
25
,
"N/A"
,
"PY"
,
"10000"
)
s1
=
Student(
"quan"
,
25
,
"Female"
,
"python"
,
15000
)
s2
=
Student(
"li"
,
26
,
"Female"
,
"python"
,
5000
)
print
(
"-------------------人数-----------------------"
)
print
(
"现在注册了："
,SchoolMember.member_nums ,
"人"
)
print
(
"-------------------老师-----------------------"
)
t1.tell()
t1.teaching()
print
(
"---------------------学生---------------------"
)
s2.tell()
s2.pay_tution()
mSchoolMember hequan
is
enrolled!
mSchoolMember he
is
enrolled!
mSchoolMember quan
is
enrolled!
mSchoolMember li
is
enrolled!
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
人数
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
现在注册了：
4
人
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
老师
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
hello my name
is
[hequan]
Teacher [hequan]
is
teaching PY.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
学生
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
hello my name
is
[li]
cao,student [li] paying tution
5000
|
多态
多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
class
Animal:
def
__init__(
self
, name):
# Constructor of the class
self
.name
=
name
def
talk(
self
):
# Abstract method, defined by convention only
raise
NotImplementedError(
"Subclass must implement abstract method"
)
class
Cat(Animal):
def
talk(
self
):
return
'Meow!'
class
Dog(Animal):
def
talk(
self
):
return
'Woof! Woof!'
def
animl_talk(obj):
print
(obj.talk())
c
=
Cat(
"qwe"
)
d
=
Dog(
"asd"
)
"""
animals = [Cat('Missy'),
Dog('Lassie')]
for animal in animals:
print(animal.name + ': ' + animal.talk())
"""
animl_talk(c)
animl_talk(d)
|
本文转自 295631788 51CTO博客，原文链接：http://blog.51cto.com/hequan/1886861，如需转载请自行联系原作者
