类与对象 面向对象和面向过程对比 面向对象三大特征:封装 继承 多态

 初识面向对象
面向过程:
一切以事务的发展流程为中心.
面向对象:
一切以对象为中心. 一切皆为对象. 具体的某一个事务就是对象

打比方:
大象进冰箱
步骤: 第一步, 开门, 第二步, 装大象, 第三步, 关门

面向对象:大象, 你进冰箱.
此时主语是大象. 我操纵的是大象. 此时的大象就是对象

 

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支持的是鸭子类型. 会嘎嘎叫的东西就是鸭子
# 为了程序能够正常执行. 本来需要传递进来一只鸭子. 但是我只需要传递一个会嘎嘎叫的东西就可以了

 优点:超强的可扩展性. 面向对象的核心就是多态