Day16--Python--初识面向对象

今日主要内容
一. 面向对象思想
    1. 面向过程. 重点在'过程'. 按照事物迭代发展流程.
        优点: 简单,流水线式的操作
        缺点: 可扩展性差.可维护性差.
    2. 面向对象. 对象是属性和动作的集合体.对象是一个抽象概念
       重点在'对象':属性和动作.
       (先创建一个大象,然后让大象进冰箱就可以了,具体大象如何进的冰箱由大象来完成.)
       类似上帝式思维.

       优点: 可扩展性强(多态)
       缺点: 编写相对比较复杂. 上手比较难.

    面向对象和面向过程各有千秋

二. 面向对象如何编写
    在代码中定义一个类,相当于画图纸
    class 类名:  #驼峰,类名首字母大写
         pass

    创建对象:  类名()
    1. 构造方法:
        def __init__(self, 属性):
            self.属性 = 属性
    2. 普通方法
        def 方法名(self, 参数列表):
            pass
        self: 表示当前类的对象. 当前正在执行这个动作的对象.
        对象.方法()
        类名.方法(对象,参数)

     e.g.
        #定义一辆车
        class Car:
            #出厂设置 (__init__) 构造方法,所有方法的第一个参数不用给
            def __init__(self, colour, pai, pailiang, own)  #self 表示当前类的对象
                print('我在造车')
                print(self)
                #绑定属性.
               # self.colour = '红色'
               # self.pai = '京A66666'
               self.colour = colour
               self.pai = pai
               self.pailiang = pailiang
               self.own = own

        c = Car('黑色', '黑B88888', '2.0t', 'alex')
        c1 = Car()    系统会自动调用__init__方法.并将Car()传给self
        c2 = Car()    自动调用__init__函数(方法)

        #创造一辆车,创建对象
        c= Car()  #类名()
        print(type(c))    #<class '__main__.Car'>

        c1 = Car()  #创建新对象,又叫做实例化  #类是一个概念. 对象:具体的实例
        c1.colour = '白色'
        c1.pai = '京B22222'
        c1.pailiang = '1.6t'
        c1.own = '小猪佩奇'
        print(id(c), id(c1))
        print(c1.pai)
        print(c.own)

    #函数(方法)

class Car():
    def __init__(self, colour, pai, pailiang, own):
        self.colour = colour
        self.pai = pai
        self.pailiang = pailiang
        self.own = own

     #车能跑,跑是一个动作,要写函数(方法)
    def run(self):  #self: 当前类的对象
        print('%s颜色的车在疯狂的跑' % self.colour)
        print(self)

    c1 = Car('红','京A11111', '1.5L', '小猪佩奇')
    c1.run()   #对象,方法()  用谁访问,self就是谁

--------------------------------------
        class House:
    pass

        h = House()
        h.colour = '红色'
        h.size = '500平米'
        h.floor = '两层'
        h.owner = 'Sara'

        print(type(h))

        h1 = House()
        h1.colour = '白色'
        h1.size = '250平米'
        h1.floor = '1层'
        h1.owner = 'John'

        print(id(h), id(h1))
        print(h1.colour)
        print(h.colour)

--------------------------------------------
class Meal:
    def __init__(self):
        self.food = '米饭'
        self.dish = '鱼香肉丝'
        self.drink = '可乐'

m = Meal()
print(m.food)
m.dish = '宫保鸡丁'
print(m.dish)

m1 = Meal()
print(m1.dish)

---------------------------------------------
class House:
    def __init__(self, colour, size, floor, owner):
        self.colour = colour
        self.size = size
        self.floor = floor
        self.owner = owner

H1 = House('红色', '1000平米', '4层', '王尔德')
print(H1)
print(H1.colour)
print(H1.size)

H2 = House('米黄', '500平米', '2层', '布莱曼')
print(H2.colour)
print(H2.size)
print(H2)

class HaoHan: # 驼峰. 类名首字母大写.
    def __init__(self, name, waihao, jineng):
        self.name = name
        self.waihao = waihao
        self.jineng = jineng

    def ganLaoHu(self):
        print("%s, %s 在干老虎" % (self.waihao, self.name))

    def shaSaoZi(self):
        print("%s, %s 在杀嫂子" % (self.waihao, self.name))

    def tiTianXingDao(self):
        print("%s, %s 在替天行道" % (self.waihao, self.name))

wusong = HaoHan("武松", "行者", "喝酒")

wusong.ganLaoHu()
wusong.shaSaoZi()
wusong.tiTianXingDao()

构造方法

class HeShang:

    def __init__(self, fahao, mingzi, age, miao):
        self.fahao = fahao
        self.mingzi = mingzi
        self.age = age
        self.miao = miao

    def nianjing(self):
        print("%s在念经" %  self.fahao)

    def quxifu(self, xifu):
        print("%s取了个媳妇:%s" % (self.fahao, xifu))

hs = HeShang("秃驴", "alex", 38, "路飞庙")
hs.nianjing()
hs.quxifu("wusir")

普通方法

class Account:

    def __init__(self, username, pwd):
        self.username = username
        self.pwd = pwd

    def login(self):
        if self.username == 'alex' and self.pwd == '':
            return True
        else:
            return False

acc = Account('alex', '')
print(acc.login())

用户登录

三. 面向对象和面向过程的对比(代码,思想)
    结论: 根据不同的业务逻辑, 来决定用哪种思想.

面向对象PK面向过程

装大象, 脚本
print("打开冰箱门")
print("装大象")
print("关上冰箱门")

函数式编程
def kaimen():
    print("打开冰箱门")
def zhuangdaxiang():
    print("装大象")
def guanmen():
    print("关门")
kaimen()
zhuangdaxiang()
guanmen()

面向对象
class Elephant:

    def open(self):
        print("大象会开门")
    def zhuang(self):
        print("把自己装进去")
    def close(self):
        print("把门关上")

# 创建大象
e = Elephant()
e.open()
e.zhuang()
e.close()

# 第一回合. 面向过程赢

# 第二回合. 小猪佩奇(name, age, 技能)大战奥特曼, 蜘蛛侠, 蝙蝠侠
# 函数式
def da_ao_te_man(name, age, jineng):
    print("%s, %s岁了, 用技能%s 打奥特曼" % (name, age, jineng))
def da_zhi_zhu_xia(name, age, jineng):
    print("%s, %s岁了, 用技能%s 打蜘蛛侠" % (name, age, jineng))
def da_bian_fu_xia(name, age, jineng):
    print("%s, %s岁了, 用技能%s 打蝙蝠侠" % (name, age, jineng))

da_ao_te_man("小猪佩奇", 40, "嘴巴嘟嘟")
da_zhi_zhu_xia("小猪佩奇", 40, "嘴巴嘟嘟")
da_bian_fu_xia("小猪佩奇", 40, "嘴巴嘟嘟")

# 面向对象
class Pig:

    def __init__(self, name, age, jineng):
        self.name = name
        self.age = age
        self.jineng = jineng

    def da_ao_te_man(self):
        print("%s, %s岁了, 用技能%s 打奥特曼" % (self.name, self.age, self.jineng))
    def da_zhi_zhu_xia(self):
        print("%s, %s岁了, 用技能%s 打蜘蛛侠" % (self.name, self.age, self.jineng))
    def da_bian_fu_xia(self):
        print("%s, %s岁了, 用技能%s 打蝙蝠侠" % (self.name, self.age, self.jineng))

peiqi = Pig("小猪佩奇", 40, "嘴巴嘟嘟") # 把这三个属性封装到了一个对象里.
peiqi.da_ao_te_man()
peiqi.da_zhi_zhu_xia()
peiqi.da_bian_fu_xia()

# 平手. 当属性和方法非常多的时候, 才能感觉到面向对象的好.
# 你要知道. 面向对象和面向过程都是思想. 用哪一个取决于业务逻辑.

四. 面向对象的三个特征(记下来)
    1. 封装: 把具有相同属性和功能的内容封装在一个对象中
    2. 继承: 子类可以自动拥有父类中 除了私有属性外的其他所有内容. 好处:两个类具有相同的功能或特征时,可以避免写很多重复的功能和代码.
    3. 多态: 同一类的对象. 可以拥有多种形态,本质是子类通过重写父类的方法,使得对同一类对象调用同一个方法,产生不同结果. python原生自带多态性.  e.g.父类中定义了eat方法,子类中又重新定义了eat方法.

继承

class Fa:
    def play(self):
        print('Fa中的play')
    def func(self):
        print('我是一号')

class Fa2:
    def play(self):
        print('Fa2中的play')
    def tool(self):
        print('我是2号')

class Son(Fa, Fa2):   #可以从多个类中继承,调用顺序先找自己,再从左到右按顺序继承
    pass

s = Son()
s.func()
s.tool()
s.play()

一个子类继承多个父类

class Pet:
    def __init__(self, name):
        self.name = name

    def eat(self):
        print('吃')
    def sleep(self):
        print('睡')

class Cat(Pet):
    def catch_mouse(self):
        print('%s喜欢抓老鼠' % self.name)

class Dog(Pet):
    def chaijia(self):
        print('%s喜欢拆家' % self.name)

c = Cat('Tom')
c.catch_mouse()
c.eat()
c.sleep()

d = Dog('John')
d.chaijia()
d.eat()
d.sleep()

多个子类继承一个父类

多态

# # 变量 = 类名()
# c = Cat() # 猫类型的
# python本来就是多态. 里面没有所谓的类型.

class Animal:
    def chi(self):
        print("所有的动物都会吃")

class Haski(Animal):
    def chi(self):
        print("疯了一样的吃")

class Monkey(Animal):
    def chi(self):
        print("龇牙咧嘴的吃")

class Tiger(Animal):
    def chi(self):
        print("跟猫一样的吃")

class Elephant(Animal):
    def chi(self):
        print("大象用鼻子卷着吃")

class YingWu(Animal):
    def chi(self):
        print("xxxxx")

class SiYangYuan:
    def wei(self, ani):  # 多态性. 超强的可扩展性. 不论传递进来的是什么. 都统一当成动物来对待.
        ani.chi()

syy = SiYangYuan()

# 造动物
hou = Monkey()
ha = Haski()
lao = Tiger()
yw = YingWu()

syy.wei(ha)
syy.wei(hou)
syy.wei(lao)
syy.wei(yw)

class Car:
    def run(self, speed):
        print("车能跑%s迈" % speed)

c = Car() # 实例化一个对象
Car.run(c, 50)
c.run(50)

类.动作(对象,参数) = 对象.动作(参数)