一、面向对象技术简介
- 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
- 类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
- 数据成员:类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
- 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
- 局部变量:定义在方法中的变量,只作用于当前实例的类。
- 实例变量:在类的声明中,属性是用变量来表示的。这种变量就称为实例变量,是在类声明的内部但是在类的其他成员方法之外声明的。
- 继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。
- 实例化:创建一个类的实例,类的具体对象。
- 方法:类中定义的函数。
- 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。
二、创建类
面向对象编程是一种编程方式,此编程方式的落地需要使用 “类” 和 “对象” 来实现,所以,面向对象编程其实就是对 “类” 和 “对象” 的使用。
1、类就是一个模板,模板里可以包含多个函数,函数里实现一些功能。
对象则是根据模板创建的实例,通过实例对象可以执行类中的函数
使用 class 语句来创建一个新类,class 之后为类的名称并以冒号结尾:
ps:
- class是关键字,表示类
- 创建对象,类名称后加括号即可
- 类中的函数第一个参数必须是self
1 # 创建类 2 class Foo: 3 4 def Bar(self): 5 print 'Bar' 6 7 def Hello(self, name): 8 print 'i am %s' %name 9 10 # 根据类Foo创建对象obj 11 obj = Foo() 12 obj.Bar() #执行Bar方法 13 obj.Hello('wupeiqi') #执行Hello方法
- 面向对象:【创建对象】【通过对象执行方法】
- 函数编程:【执行函数】
三、面向对象三大特性
面向对象的三大特性是指:封装、继承和多态。
1、封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。
2、继承是面向对象程序设计方法的一个重要手段,通过继承可以更有效地组织程序结构,明确类间的关系,育雏利用已有的类来完成更复杂、更深入的程序开发。
3、多态允许以一种统一的风格处理已存在的变量和相关的类,多态性使得向系统增加功能变的容易。
-----------------------------------------------------------------------------------------------------------------------------------
封装
self 是一个形式参数
当执行 obj1 = Foo('wupeiqi', 18 ) 时,self 等于 obj1
当执行 obj2 = Foo('alex', 78 ) 时,self 等于 obj2
所以,内容其实被封装到了对象 obj1 和 obj2 中,每个对象中都有 name 和 age 属性,在内存里类似于下图来保存。
第二步:从某处调用被封装的内容
调用被封装的内容时,有两种情况:
- 通过对象直接调用
- 通过self间接调用
1、通过对象直接调用被封装的内容
上图展示了对象 obj1 和 obj2 在内存中保存的方式,根据保存格式可以如此调用被封装的内容:对象.属性名
1 class Foo: 2 3 def __init__(self, name, age): 4 self.name = name 5 self.age = age 6 7 obj1 = Foo('wupeiqi', 18) 8 print obj1.name # 直接调用obj1对象的name属性 9 print obj1.age # 直接调用obj1对象的age属性 10 11 obj2 = Foo('alex', 73) 12 print obj2.name # 直接调用obj2对象的name属性 13 print obj2.age # 直接调用obj2对象的age属性
2、通过self间接调用被封装的内容
执行类中的方法时,需要通过self间接调用被封装的内容
1 class Foo: 2 3 def __init__(self, name, age): 4 self.name = name 5 self.age = age 6 7 def detail(self): 8 print self.name 9 print self.age 10 11 obj1 = Foo('wupeiqi', 18) 12 obj1.detail() # Python默认会将obj1传给self参数,即:obj1.detail(obj1),所以,此时方法内部的 self = obj1,即:self.name 是 wupeiqi ;self.age 是 18 13 14 obj2 = Foo('alex', 73) 15 obj2.detail() # Python默认会将obj2传给self参数,即:obj1.detail(obj2),所以,此时方法内部的 self = obj2,即:self.name 是 alex ; self.age 是 78
综上所述,对于面向对象的封装来说,其实就是使用构造方法将内容封装到 对象 中,然后通过对象直接或者self间接获取被封装的内容。
eg.
小明,10岁,男,上山去砍柴
小明,10岁,男,开车去东北
小明,10岁,男,最爱大保健
老李,90岁,男,上山去砍柴
老李,90岁,男,开车去东北
1 def kanchai(name, age, gender): 2 print "%s,%s岁,%s,上山去砍柴" %(name, age, gender) 3 4 def qudongbei(name, age, gender): 5 print "%s,%s岁,%s,开车去东北" %(name, age, gender) 6 7 def dabaojian(name, age, gender): 8 print "%s,%s岁,%s,最爱大保健" %(name, age, gender) 9 10 kanchai('小明', 10, '男') 11 qudongbei('小明', 10, '男') 12 dabaojian('小明', 10, '男') 13 14 kanchai('老李', 90, '男') 15 qudongbei('老李', 90, '男') 16 dabaojian('老李', 90, '男')
1 class Foo: 2 3 def __init__(self, name, age ,gender): 4 self.name = name 5 self.age = age 6 self.gender = gender 7 8 def kanchai(self): 9 print "%s,%s岁,%s,上山去砍柴" %(self.name, self.age, self.gender) 10 11 def qudongbei(self): 12 print "%s,%s岁,%s,开车去东北" %(self.name, self.age, self.gender) 13 14 def dabaojian(self): 15 print "%s,%s岁,%s,最爱大保健" %(self.name, self.age, self.gender) 16 17 xiaoming = Foo('小明', 10, '男') 18 xiaoming.kanchai() 19 xiaoming.qudongbei() 20 xiaoming.dabaojian() 21 22 laoli = Foo('老李', 90, '男') 23 laoli.kanchai() 24 laoli.qudongbei() 25 laoli.dabaojian()
-------------------------------------------------------------------------
继承
继承,面向对象中的继承和现实生活中的继承相同,即:子可以继承父的内容。
例如:
猫可以:喵喵叫、吃、喝、拉、撒
狗可以:汪汪叫、吃、喝、拉、撒
如果我们要分别为猫和狗创建一个类,那么就需要为 猫 和 狗 实现他们所有的功能,如下所示:
1 class 动物: 2 3 def 吃(self): 4 # do something 5 6 def 喝(self): 7 # do something 8 9 def 拉(self): 10 # do something 11 12 def 撒(self): 13 # do something 14 15 # 在类后面括号中写入另外一个类名,表示当前类继承另外一个类 16 class 猫(动物): 17 18 def 喵喵叫(self): 19 print '喵喵叫' 20 21 # 在类后面括号中写入另外一个类名,表示当前类继承另外一个类 22 class 狗(动物): 23 24 def 汪汪叫(self): 25 print '喵喵叫'
1 class Animal: 2 3 def eat(self): 4 print "%s 吃 " %self.name 5 6 def drink(self): 7 print "%s 喝 " %self.name 8 9 def shit(self): 10 print "%s 拉 " %self.name 11 12 def pee(self): 13 print "%s 撒 " %self.name 14 15 class Cat(Animal): 16 17 def __init__(self, name): 18 self.name = name 19 self.breed = '猫' 20 21 def cry(self): 22 print '喵喵叫' 23 24 class Dog(Animal): 25 26 def __init__(self, name): 27 self.name = name 28 self.breed = '狗' 29 30 def cry(self): 31 print '汪汪叫' 32 33 # ######### 执行 ######### 34 35 c1 = Cat('小白家的小黑猫') 36 c1.eat() 37 38 c2 = Cat('小黑的小白猫') 39 c2.drink() 40 41 d1 = Dog('胖子家的小瘦狗') 42 d1.eat()
所以,对于面向对象的继承来说,其实就是将多个类共有的方法提取到父类中,子类仅需继承父类而不必一一实现每个方法。
注:除了子类和父类的称谓,你可能看到过 派生类 和 基类 ,他们与子类和父类只是叫法不同而已。
学习了继承的写法之后,我们用代码来是上述阿猫阿狗的功能:
1 class Animal: 2 3 def eat(self): 4 print "%s 吃 " %self.name 5 6 def drink(self): 7 print "%s 喝 " %self.name 8 9 def shit(self): 10 print "%s 拉 " %self.name 11 12 def pee(self): 13 print "%s 撒 " %self.name 14 15 class Cat(Animal): 16 17 def __init__(self, name): 18 self.name = name 19 self.breed = '猫' 20 21 def cry(self): 22 print '喵喵叫' 23 24 class Dog(Animal): 25 26 def __init__(self, name): 27 self.name = name 28 self.breed = '狗' 29 30 def cry(self): 31 print '汪汪叫' 32 33 # ######### 执行 ######### 34 35 c1 = Cat('小白家的小黑猫') 36 c1.eat() 37 38 c2 = Cat('小黑的小白猫') 39 c2.drink() 40 41 d1 = Dog('胖子家的小瘦狗') 42 d1.eat()
-------------------------------------------------------------
多态
Pyhon不支持多态并且也用不到多态,多态的概念是应用于Java和C#这一类强类型语言中,而Python崇尚“鸭子类型”。
1 class F1: 2 pass 3 4 class S1(F1): 5 6 def show(self): 7 print 'S1.show' 8 9 class S2(F1): 10 11 def show(self): 12 print 'S2.show' 13 14 # 由于在Java或C#中定义函数参数时,必须指定参数的类型 15 # 为了让Func函数既可以执行S1对象的show方法,又可以执行S2对象的show方法,所以,定义了一个S1和S2类的父类 16 # 而实际传入的参数是:S1对象和S2对象 17 18 def Func(F1 obj): 19 """Func函数需要接收一个F1类型或者F1子类的类型""" 20 21 print obj.show() 22 23 s1_obj = S1() 24 Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj,执行 S1 的show方法,结果:S1.show 25 26 s2_obj = S2() 27 Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj,执行 Ss 的show方法,结果:S2.show
1 class F1: 2 pass 3 4 class S1(F1): 5 6 def show(self): 7 print 'S1.show' 8 9 class S2(F1): 10 11 def show(self): 12 print 'S2.show' 13 14 def Func(obj): 15 print obj.show() 16 17 s1_obj = S1() 18 Func(s1_obj) 19 20 s2_obj = S2() 21 Func(s2_obj)
总结
以上就是本节对于面向对象初级知识的介绍,总结如下:
- 面向对象是一种编程方式,此编程方式的实现是基于对 类 和 对象 的使用
- 类 是一个模板,模板中包装了多个“函数”供使用
- 对象,根据模板创建的实例(即:对象),实例用于调用被包装在类中的函数
- 面向对象三大特性:封装、继承和多态