类与对象,面向对象与面向过程的对比,面向对象的三大特征

类: 就是图纸. 创建对象的第一步. 先画图纸. 先写类.
对象: 对象就是车. 通过图纸造出来的具体的东西. 通过类来创建对象

类与对象的关系:
    类是对xxx事物的归类.
        写:
            __init__(self, 参数)  参数一般作为属性设置给对象. 对象就是self,
             对属性的封装.

            def 方法(self, 参数): 方法. 第一个参数一般是固定的self. 当前类的对象.
                pass

    对象是xx类型的一个具体
        创建对象: 类名()

创建类:
class 类名:

    def __init__(self): # 初始化方法. 又被成为构造方法
        self.属性 = 值
        self.属性 = 值
        self.属性 = 值

    def fangfa(self):
        方法体(函数体,  return)

创建对象:
    变量 = 类名() # 实例化 <-> 创建对象

    变量.属性 # 访问对象的属性信息
    变量.方法() # 访问类中的方法

# class Car:      #类名首字母大写.
#     pass
#
# # 造车
# c = Car()
# # 出场之后进行改装
# c.color = "red"     # 对象.属性   点:的
# c.pai = "京A88888"   # 对象.属性
# c.pailiang = "555L"   # 排量
#
# print(c.color)
# print(c.pai)
# print(c.pailiang)


# c.color = "green"  # 当属性存在的时候是修改属性信息
# 对象.属性 = xxxx 设置属性信息

# class Car:
#     # __init__ 方法是一个特殊的方法,初始化方法(构造方法)
#     # 在创建对象的时候会自动的调用__init__()
#     # self 就是你创建出来的那个对象
#
#     def __init__(self, color, pai, pailiang):   # init初始化方法,在创建对象的时候默认执行这个函数
#         self.color = color
#         self.pai = pai
#         self.pailiang = pailiang
#
#     # 跑:动作,功能 -> 函数
#     # 在类中写的函数 -> 方法
#     # self 当前类的对象
#
#     def pao(self):      # self是自动传递的,不用管它
#         print("%s我的车能跑" % self.color)   # self.color
#
#     def jump(self):
#         print("%s牛砸能蹦高" % self.color)
#
#
#
#
# c = Car("红色", '京A88888', '555L')
# c2 = Car('蓝色', '京B66666', '1.6T')
# print(c.color)
# print(c2.color)
#
# c.pao()
# c2.pao()
# c.jump()
# c2.jump()

　　面向对象与面向过程的对比

# 大象装冰箱
# 脚本  此时代码最简单,不需要构思整个程序的概况
# 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(phone_num, name, title, content):
#     print("发送短信")
#
# def send_dd(dd_num, name, title, content):
#     print("发送钉钉")
#
# def send_oa(oa_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. 对属性的封装(__init__())
                self.xxx = xxx
            2. 对方法和功能的封装

        继承
            子类自动拥有父类中除了私有内容外的其他所有内容
            class Bar(Foo):  Bar对Foo进行了扩展
                pass

            当出现x是一种y的时候. 推荐使用继承关系
            python支持多继承. 查找顺序: 先找离他近的.

        多态(python原生直接就是多态)
            python更多的支持的是鸭子模型, 只要会嘎嘎叫就是好鸭子