面向对象的详细解读
一、基本概念
1. 面向过程
(1) 概念：以过程为中心的编程思想，就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
(2) 优点：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。因为程序的流程很清楚，按着模块与函数的方法可以很好的组织。
(3) 缺点：只能用来解决一个问题，代码牵一发而动全身。
(4) 应用：用于基本很少改变的场景，著名的例子有linux内核、git、以及apache http server等。
2. 面向对象
(1) 概念：程序设计的核心是对象，面向对象的方法主要是把事物给对象化，对象包括属性与方法。
(2) 优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护。
(3) 缺点：可控性差，无法像面向过程的程序设计一样可以精准的预测问题的处理流程与结果。
(4) 应用：需求经常变化的软件，一般需求的变化都集中在用户层，如互联网应用、企业内部软件以及游戏等。
二、面向对象中的名词解析
1. 类：类就是一个模板，模板里可以包含多个函数，每个函数都能实现一些功能。
2. 对象：根据模板(类)创建的实例，通过这个实例(对象)可以执行类中的函数。
3. 属性：类中所定义的变量
4. 方法：类中所定义的函数
5. 实例化：通过类创建对象的过程
6. 总结：对象的抽象是类，类的具体化就是对象；也可以说类的实例化是对象，对象是类的实例。
》》》实例说明——类与对象的创建
我要评论# -*- encoding:utf-8 -*-
''' 实例说明——类与对象的创建 '''
class classname: #创建类，classname为类名
alary = 10000 #类的一个属性
def fun1(self): #方法1
pass #方法1的技能
def fun2(self): #方法2
pass #方法2的技能
obj = classname() #创建对象，obj为对象名
三、特征
1. 封装
(1) 概念：封装是将对象运行时所需的资源封装在程序对象中。简单来说，就是将内容封装起来，以后再去调用被封装的内容。
(2) 调用封装的内容有2种方法：
——通过对象直接调用
——通过self间接调用
》》》实例说明——面向对象的特征：封装
# -*- encoding:utf-8 -*-
''' 实例说明——面向对象的特征：封装 '''
class student:
def __init__(self, name, age):
self.name = name
self.age = age
def detail(self): #调用时对象名会传给self参数，如最后一句
print(self.name)
print(self.age)
obj1 = student('jack',15) #将'jack'和15分别封装到obj1的self的name和age属性中
print(obj1.name) #通过对象直接调用name属性和age属性
print(obj1.age)
obj2 = student('sahra',13) #将'sahra'和13分别封装到obj2的self的name和age属性中
obj2.detail() #通过self间接调用name属性和age属性
2. 继承
(1) 概念：继承可以使得子类别具有父类别的各种属性和方法，而不需要再次编写相同的代码。在令子类别继承父类别的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类别的原有属性和方法，使其获得与父类别不同的功能。
(2) 多继承
注：python的类可以继承多个类，而java和c#中则只能继承一个类
python的类如果继承了多个类，那么其寻找方法的方式有2种：
》》》实例说明——面向对象的特征：继承
# -*- encoding:utf-8 -*-
''' 实例说明——面向对象的特征：继承 '''
class person(object): #定义person父类
def talk(self): #定义父类的方法
print("person can talk.")
class chinese(person): #定义person父类的一个子类，同时是characters类的父类
def talkc(person): #定义方法
print("chinese can talk mandarin.")
class characters(chinese): #定义chinese父类的一个子类
def people(self): #定义方法
print("chinese are clever and diligent.")
class american(person): #定义person父类的一个子类
def talka(self): #定义方法
print("american can talk english.")
c = characters() #定义父类的子类的子类
a = american() #定义父类的子类
c.talk() #调用继承person类的方法
a.talka() #调用本身的方法
c.people() #调用本身的方法
3. 多态
概念：多态指同一个实体同时具有多种形式，在赋值之后，不同的子类对象调用相同的父类方法，产生的执行结果不同。
》》》实例说明——面向对象的特征：多态
1 # -*- encoding:utf-8 -*-
2 ''' 实例说明——面向对象的特征：多态 '''
3 import abc
4
5 class animal(metaclass=abc.abcmeta): #同一类事物:动物
6
7 @abc.abstractmethod
8 def talk(self):
9 pass
10
11 class people(animal): #动物的形态之一:人
12 def talk(self):
13 print('say hello')
14
15 class dog(animal): #动物的形态之二:狗
16 def talk(self):
17 print('say wangwang')
18
19 class pig(animal): #动物的形态之三:猪
20 def talk(self):
21 print('say aoao')
22
23
24 peo = people() #创建people类的对象peo
25 dog = dog() #创建dog类的对象dog
26 pig = pig() #创建pig类的对象pig
27 peo.talk() #分别使用各种的方法
28 dog.talk()
29 pig.talk()
四、类的成员
1. 简介：类的成员包括字段、方法和属性。在所有成员中，只有字段中的普通字段保存于对象中，因此创建多少个对象在内存中就有几个普通字段；而其他成员都保存在类中，也只占用一份内存空间。
2. 字段：包括普通字段和静态字段，他们在定义和使用都有所区别，而最本质的区别是内存中保存的位置不同。
(1) 普通字段保存在对象中
(2) 静态字段保存在类中
3. 方法：包括普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。
(1) 公有方法
调用：可由对象名直接调用；如果通过类名来调用属于对象的公有方法，需要显式为该方法的self参数传递一个对象名，用来明确指定访问哪个对象的数据成员。
特点：至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self。在此方法中可以访问属于类和对象的成员。
(2) 私有方法
调用：只能在属于对象的方法中通过self调用或在外部通过python支持的特殊方式来调用。在此方法中可以访问属于类和对象的成员。
(3) 静态方法
调用：可以通过类名和对象名调用，但不能直接访问属于对象的成员，只能访问属于类的成员。
特点：无默认参数。
(4) 类方法
调用：可以通过类名和对象名调用，但不能直接访问属于对象的成员，只能访问属于类的成员。
特点：至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls。
4. 属性：其实是普通方法的变种。
5. 类成员的修饰符：下划线
xxx ：公有成员，在任何地方都能访问
__xxx or ...__xxx：私有成员，只有类对象自己能访问，子类对象不能直接访问，但在对象外部可以通过“对象名._类名__xxx”这样的特殊方式来访问。
_xxx：受保护成员，不能用'from module import *'导入
__xxx__：系统定义的特殊成员
注：python中不存在严格意义上的私有成员
6. 类的特殊成员
(1) __init__：构造方法，通过类创建对象时，自动触发执行。
(2) __del__：析构方法，当对象在内存中被释放时，自动触发执行，此方法一般无需定义。
(3) 类的属性
dir(类名)：查出的是一个名字列表
类名.__dict__：查出的是一个字典，key为属性名，value为属性值
(4) 特殊的类属性
类名.__name__：类的名字(字符串)
类名.__doc__：类的文档字符串
类名.__base__：类的第一个父类(在讲继承时会讲)
类名.__bases__：类所有父类构成的元组(在讲继承时会讲)
类名.__dict__：类的字典属性
类名.__module__：类定义所在的模块
类名.__class__：实例对应的类(仅新式类中)
如对本文有疑问， 点击进行留言回复！！
网友评论