首页 > > 网络编程 > 其它 >

python 初识面向对象

2018-12-28 08:05:00来源：博客园阅读 ()

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('哈哈')