1. 初识面向对象
面向过程:
一切以事务的发展流程为中心.
面向对象:
一切以对象为中心. 一切皆为对象. 具体的某一个事务就是对象
打比方:
大象进冰箱
步骤: 第一步, 开门, 第二步, 装大象, 第三步, 关门
面向对象:大象, 你进冰箱.
此时主语是大象. 我操纵的是大象. 此时的大象就是对象
1 class Car: # 类名首字母大写,严格蹲守驼峰命名规则 2 pass 3 4 5 # 造车 6 c = Car() # 类名() # 创建对象 7 8 # 出厂之后进行改装 9 c.color = '红颜色' # 对象.属性 点:的 当属性不存在的时候, 添加一个属性 10 c.pai = '京A8888' # 对象.属性 11 c.pailiang = '555L' # 排量 12 13 print(c.color) # 此车是红颜色 14 print(c.pai) 15 print(c.pailiang) 16 17 c.color = '绿颜色' # 当属性存在的时候是修改属性信息 18 # 对象.属性 =xxx 设置属性信息 19 print(c.color)
2. 类. 对象
类: 就是图纸. 创建对象的第一步. 先画图纸. 先写类.
对象: 对象就是车. 通过图纸造出来的具体的东西. 通过类来创建对象
类与对象的关系:
类是对xxx事物的归类.
写:
__init__(self, 参数) 参数一般作为属性设置给对象. 对象就是self, 对属性的封装.
def 方法(self, 参数): 方法. 第一个参数一般是固定的self. 当前类的对象.
pass
对象是xx类型的一个具体
创建对象: 类名()
创建类:
class 类名:
def __init__(self): # 初始化方法. 又被成为构造方法
self.属性 = 值
self.属性 = 值
self.属性 = 值
def fangfa(self):
方法体(函数体, return)
创建对象:
变量 = 类名() # 实例化 <-> 创建对象
变量.属性 # 访问对象的属性信息
变量.方法() # 访问类中的方法
1 1.
2 class Car: # 类名首字母大写,严格蹲守驼峰命名规则
3 # __init__方法是一个特殊的方法. 初始化方法. (构造方法)
4 # 在创建对象的时候会自动的调用__init__()
5 # self就是你创建出来的那个对象
6 def __init__(self): # init初识方法. 在创建对象的时候. 默认执行这个函数
7 print('我是init')
8 print('self=', self)
9
10
11 c = Car() # 创建Car类型对象. 此时self参数不需要我们管
12 print('c=', c)
13
14 2.
15 class Car: # 类名首字母大写,严格蹲守驼峰命名规则
16 def __init__(self, color, pai, pailiang): # init初识方法. 在创建对象的时候. 默认执行这个函数
17 # self.color = '红色' # 在出厂的时候都是红色 静态的
18 self.color = color # 动态获取 第一个color是设置 第二个color是获取的参数
19 self.pai = pai
20 self.pailiang = pailiang
21
22 # 跑: 动作, 功能 -> 函数
23 # 在类中写的函数-> 方法
24 # self 当前类的对象
25 def pao(self): # self是自动传递的. 不用管它
26 print('%s我的车能跑' % self.color) #self.color
27 def jump(self):
28 print('you jump, I jump')
29 #
30 #
31 #
32 #
33 c = Car('红色', '京A8888', '555L') # 创建Car类型对象. 此时self参数不需要我们管
34 c2 = Car('蓝色', '京B6666', '1.6T')
35 print(c.color)
36 print(c2.color)
37 #
38 #
39 c.pao()
40 c2.pao()
41 c.jump()
3. 面向对象和面向过程的对比
如果写一些比较小的程序用面向过程.
程序很复杂. 很庞大建议用面向对象.
4. 面向对象的三大特征
封装:
1. 对属性的封装(__init__())
self.xxx = xxx
2. 对方法和功能的封装
继承
子类自动拥有父类中除了私有内容外的其他所有内容
class Bar(Foo): Bar对Foo进行了扩展
pass
当出现x是一种y的时候. 推荐使用继承关系
python支持多继承. 查找顺序: 先找离他近的.
1 class Foo:
2 def getMoney(self):
3 print('拿钱')
4
5 class Bar(Foo):
6 pass
7
8 b = Bar()
9 b.getMoney() # 此时调用的是父类中的方法
多态(python原生直接就是多态)
python更多的支持的是鸭子模型, 只要会嘎嘎叫就是好鸭子
1 多态性: 用一个对象. 多种形态
2 python 支持的是鸭子类型. 会嘎嘎叫的东西就是鸭子
3 为了程序能够正常执行. 本来需要传递进来一只鸭子. 但是我只需要传递一个会嘎嘎叫的东西就可以了
4 def func(yazi):
5 yazi.gagajiao()
6
7 class Animal:
8 def chi(self):
9 print("会吃")
10
11 class GoldenMonkey(Animal):
12 def chi(self):
13 print("用手拿着吃, 五花八门")
14
15 class Tiger(Animal):
16 def chi(self):
17 print("老虎吃肉")
18
19 class Elephant(Animal):
20 def chi(self):
21 print("大象吃香蕉")
22
23 class QiE(Animal):
24 def chi(self):
25 print("企鹅吃人民币")
26
27 # 以下代码是饲养员
28 # 优点: 超强的可扩展行. 面向对象的核心就是多态
29 def wei_animal(ani): # 传进来的东西要会吃的就行
30 ani.chi()
31
32 # 动物园
33 t = Tiger()
34 m = GoldenMonkey()
35 e = Elephant()
36
37 wei_animal(t)
38 wei_animal(m)
39 wei_animal(e)
40
41 a = 188
42 def cul(n): # python中万事万物都是对象, object(对象)
43 print(n)
44
45 cul(a)
46 cul('哈哈')
来源：https://www.cnblogs.com/beargod/p/10187551.html