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

Posted 2021-01-28 h1050676808

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

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

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

 

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

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