类与对象 面向对象和面向过程对比 面向对象三大特征:封装 继承 多态
初识面向对象
面向过程:
一切以事务的发展流程为中心.
面向对象:
一切以对象为中心. 一切皆为对象. 具体的某一个事务就是对象
打比方:
大象进冰箱
步骤: 第一步, 开门, 第二步, 装大象, 第三步, 关门
面向对象:大象, 你进冰箱.
此时主语是大象. 我操纵的是大象. 此时的大象就是对象
1. 面向过程: 一切以事物的流程为核心. 核心是"过程"二字, 过程是指解决问题的步骤, 即, 先⼲干什么, 后干什么. 基于该思想编写程序就好比在编写一套流水线. 是一种机械 式的编程思维
优点: 负责的问题流程化, 编写相对简单
缺点: 可扩展性差
2. ⾯向对象: ⼀切以对象为中心. 什么是对象? 不好解释. 先解释什么是车? 有轱辘, 有⽅方向盘, 有发动机, 会跑的 是车. 好 在解释一个. 什么是人. 有名字, 年年龄, 爱好, 会唱歌跳舞思考的是人. 我们给这两个 东⻄下了一个简单的定义. 总结: 具有相同属性和动作的结合体叫对象. 面向对象思维, 要自 ⼰建立对象. 自己建立场景. 你是就是面向对象世界中的上帝. 你想让车干嘛就干嘛. 你想让 人干嘛人就能干嘛.
优点: 可扩展性强
缺点: 编程的复杂度⾼高于面向过程
# 造车 c = Car() # 类名() # 创建对象 # 出厂之后进行改装 c.color = "红颜色" # 对象.属性 点: 的 当属性不存在的时候. 添加一个属性 c.pai = "京A88888" # 对象.属性 c.pailiang = "555L" # 排量 print(c.color) # 此车是红颜色 print(c.pai) print(c.pailiang) c.color = "绿颜色" # 当属性存在的时候是修改属性信息. # 对象.属性 = xxxx 设置属性信息 print(c.color)class Car:
# 类名首字母大写, 严格遵守驼峰命名规范
# __init__方法是一个特殊的方法. 初始化方法. (构造方法)
#在python中我们可以是用__init__(self) 函数给对象进行初始化操作. 这个函数(方法)被称为构造函数(方法).
# 在创建对象的时候会自动的调用__init__()
# self就是你创建出来的那个对象
def __init__(self, color, pai, pailiang): # init初始化方法. 在创建对象的时候. 默认执行这个函数
# print("我是init")
# print("self = ", self)
# self.color="红色" # 在出厂的时候都是红色
self.color = color
self.pai = pai
self.pailiang = pailiang
# c.color = "红色"
# 跑: 动作, 功能 -> 函数
# 在类中写的函数 -> 方法
# self 当前类的对象.
def pao(self): # self是自动传递的. 不用管它
print("%s我的车能跑" % self.color) # self.color
def jump(self):
print("you jump, I jump")
类. 对象 类就是对属性和方法的封装
类:
就是图纸. 创建对象的第一步. 先画图纸.也就是先写类.
对象: 对象就是车. 通过图纸造出来的具体的东西. 通过类来创建对象
类与对象的关系:
类是对事物的总结. 抽象的概念念. 类用来描述对象. 对象是类的实例化的结果.
对象能执行哪些方法. 都由类来决定. 类中定义了什么. 对象就拥有什么
类是对xxx事物的归类.
写法:
__init__(self, 参数) 参数一般作为属性设置给对象. 对象就是self, 对属性的封装.
# 在python中我们可以是用__init__(self) 函数给对象进行初始化操作. 这个函数(方法)被称为构造函数(方法).
def 方法(self, 参数): 方法. 第一个参数一般是固定的self. 当前类的对象.
pass
对象是xx类型的一个具体
创建对象: 类名()
创建类:
class 类名:
def __init__(self): # 初始化方法. 又被成为构造方法
self.属性 = 值
self.属性 = 值
self.属性 = 值
def fangfa(self):
方法体(函数体, return)
创建对象:
变量 = 类名() # 实例化 <-> 创建对象
变量.属性 # 访问对象的属性信息
变量.方法() # 访问类中的方法
面向对象和面向过程对比
大象装冰箱
脚本, 此时代码是最简单的. 不需要构思整个程序的概况
print("开门")
print("装大象")
print("关门")
函数式编程. 比脚本麻烦. 对功能有了概况.
def kai():
print('开门')
def zhuang():
print("装大象")
def guan():
print('关门')
kai()
zhuang()
guan()
面向对象编程, 对整个系统进行分析. 分析出需要哪些对象. 然后给对象进行归类.
先写类. 然后使用类创建对象. 最后用对象去执行相关的操作
class Elephant:
def __init__(self):
print("创建了一个大象")
def kai(self):
print("开门")
def zuan(self):
print("大象进冰箱")
def guan(self):
print("大象把门带上")
dx = Elephant()
dx.kai()
dx.zuan()
dx.guan()
第一回合
脚本胜
函数侧重的是功能
面向对象侧重的是 归类
PK2回合
# 小猪佩奇. 使用嘴巴嘟嘟技能攻击 超人
# 小猪佩奇. 使用嘴巴嘟嘟技能攻击 蝙蝠侠
# 小猪佩奇. 使用嘴巴嘟嘟技能攻击 蜘蛛侠
# 面向过程: 代码非常的冗余. 尤其是参数
def fight_superman(name, jineng):
print("%s使用%s攻击超人" % (name, jineng))
def fight_batman(name, jineng):
print("%s使用%s攻击蝙蝠侠" % (name, jineng))
def fight_spiderman(name, jineng):
print("%s使用%s攻击蜘蛛侠" % (name, jineng))
fight_superman('小猪佩奇', "嘴巴嘟嘟")
fight_batman('小猪佩奇', "嘴巴嘟嘟")
fight_spiderman('小猪佩奇', "嘴巴嘟嘟")
class Pig:
def __init__(self, name, jineng):
self.name = name
self.jineng = jineng
def fight_superman(self):
print("%s使用%s攻击超人" % (self.name, self.jineng))
def fight_batman(self):
print("%s使用%s攻击蝙蝠侠" % (self.name, self.jineng))
def fight_spiderman(self):
print("%s使用%s攻击蜘蛛侠" % (self.name, self.jineng))
pg = Pig("小猪佩奇", "嘴巴嘟嘟")
# 不需要向原来一样传递一样的参数了
# 面向对象的程序: 结果相对清晰. 缺点: 代码量比原来大, 上手太难
pg.fight_batman()
pg.fight_spiderman()
pg.fight_superman()
如果写一个定时任务, 半夜12点. 给老板发送财务报表(一张图)
def send_email(address, name, title, content):
print("发送邮件")
def send_wechat(wechat_num, name, title, content):
print("发送微信")
def send_chat(wechat_num, name, title, content):
print("发送短信")
def send_dd(wechat_num, name, title, content):
print("发送钉钉")
def send_oa(wechat_num, name, title, content):
print("发送OA")
class Messager:
def __init__(self, name, title, content):
self.name = name
self.title = title
self.content = content
def send_email(self, address):
print("发送邮件")
def send_wechat(self, wechat_num):
print("发送微信")
def send_chat(self, phone_num):
print("发送短信")
def send_dd(self, dd_num):
print("发送钉钉")
def send_oa(self, oa_num):
print("发送OA")
用面向对象就比面向过程稍微好一些.
可维护性比原来好
python同时支持面向对象和面向过程:
面向过程: 应用程序相对比较小. 不需要大规模的设计
面向对象: 程序非常大. 项目管理 维护成本很高. 此时更适合用面向对象(结构)
java : 纯面向对象 => 可以把一个微型项目. 做成巨型项目
面向对象三大特征:封装 继承 多态
1. 封装: 把很多数据封装到一个对象中. 把固定功能的代码封装到一个代码块, 函数, 对 象, 打包成模块. 这都属于封装的思想. 具体的情况具体分析. 比如.你写了⼀个很⽜B 的函数. 那这个也可以被称为封装. 在面向对象思想中. 是把一些看似无关紧要的内容组合到一起统一进行存储和使用. 这就是封装.
# 封装:
# 1. 对属性的封装
# 2. 对功能的封装
# 3. 模块
# 4. 包
2. 继承: ⼦类可以自动拥有父类中除了私有属性外的其他所有内容. 说白了, 儿子可以 随便用爹的东西. 但是朋友们, ⼀定要认清楚一个事情. 必须先有爹, 后有⼉子. 顺序不能乱, 在python中实现继承非常简单. 在声明类的时候, 在类名后面添加⼀个小括号, 就可以完成继承关系. 那么什么情况可以使⽤继承呢? 单纯的从代码层面上来看. 两 个类具有相同的功能或者特征的时候. 可以采⽤继承的形式. 提取⼀个⽗类, 这个父类中编写着两个类相同的部分. 然后两个类分别取继承这个类就可以了. 这样写的好处 是我们可以避免写很多重复的功能和代码. 如果从语义中去分析的话. 会简单很多. 如果语境中出现了了x是⼀种y. 这时, y是⼀种泛化的概念. x比y更加具体. 那这时x就是y的 ⼦类. 比如. 猫是⼀种动物. 猫继承动物. 动物能动. 猫也能动. 这时猫在创建的时候就 有了动物的"动"这个属性. 再比如, ⽩骨精是⼀一个妖怪. 妖怪天⽣生就有⼀个比较不好的功能叫"吃人", 白骨精⼀出⽣就知道如何"吃人". 此时 白骨精继承妖精. 话不多说上代码.
在python中, ⼀个类可以同时继承多个父类. 说⽩了, 现在一个⼉子可能会有多个爹了. 既然是有这么多个爹, 总得有远有近. 比如. 有⼀个这样的牛B的人物, 叫锅不美. 就有很多个爹嘛.
# 当出现xxx是一种yyy类型的东西. 可以使用继承关系 # 猫是一种动物 class Animal: def dong(self): print("动物会动, 顾雍") class Cat(Animal): # 子类其实是对父类的一种扩展 def catchMouse(self): print("猫很皮, 抓老鼠") # c = Cat() # c.dong() # c.catchMouse() a = Animal() # 父类的对象不能执行子类中的功能 a.dong() #动物会动, 顾雍 # a.catchMouse() # 创建的是动物. 动物不能执行抓老鼠
class Animal: def dong(self): print("动物会动, 顾雍") class Cat(Animal): # 子类其实是对父类的一种扩展 def dong(self): # 子类中写了和父类一模一样的方法. 这个叫方法的覆盖, 重写 print("猫上蹿下跳") def catchMouse(self): print("猫很皮, 抓老鼠") c = Cat() # 创建的是猫. c.dong() # 类中的方法的查询顺序. 先找自己, 然后再找父类 #猫上蹿下跳
# python支持多继承
class Foo1:
def getMoney(self):
print('给你个大嘴巴子')
def play(self):
print("玩儿")
class Foo2:
def getMoney(self):
print('给多点儿')
class Bar(Foo1, Foo2): # 离当前类最近的是亲爹, 后面的是干爹.
pass
b = Bar() # 就近原则, MRO的C3算法
b.getMoney() # Foo2里的
#给你个大嘴巴子
3. 多态: 同⼀个对象, 多种形态. 这个在python中其实是很不容易说明白的. 因为我们一 直在用. 只是没有具体的说. 比如. 我们创建一个变量a = 10 , 我们知道此时a是整数 类型. 但是我们可以通过程序让a = "alex", 这时, a又变成了字符串类型. 这是我们都知道的. 但是, 我要告诉你的是. 这个就是多态性. 同一个变量a可以是多种形态. 可能 这样的程序和说法你还get不到具体什么是多态. 接下来. 我们来看一个程序. 北京动 物园饲养员alex⼀一天的⼯工作. 从早上开始喂养猪猪, 中午喂哈⼠士奇, 晚上还得喂阿拉斯加. 来我们⽤代码实现这样的代码:
多态的好处: 程序具有超高的可扩展性. ⾯向对象思想的核心与灵魂. python⾃带多态.
# 多态性: 同一个对象. 多种形态.
# python支持的是鸭子类型. 会嘎嘎叫的东西就是鸭子
# 为了程序能够正常执行. 本来需要传递进来一只鸭子. 但是我只需要传递一个会嘎嘎叫的东西就可以了
优点:超强的可扩展性. 面向对象的核心就是多态
