初识面向对象

一 面向对象和面向过程

　　1.面向过程:一切以事物的流程为核心,核心是"过程"二字,过程是指解决问题的 步骤,即,先干什么,后干

　　　　　　　　什么,基于该思想编写程序就好比在 编写一套流水线,是一种 机械式的编程思想

　　　　优点: 负责的问题流程化,编写相对简单

　　　　缺点:可扩展性差

　　2.面向对象:一切以对象为中心

　　　　神马是对象? 

　　　　总结: 具有相同属性和动作的结合体叫 对象.面向对象思维,要自己建立对象,自己建立场景,你就是

　　　　　　　　面向对象世界中的玉皇大帝.

　　　　优点: 可扩展性强

　　　　缺点: 编程的复杂度 高于 面向过程

　　来个对比吧:

　　　　面向过程思维:

　　　　　　　　　　说,把大象装冰箱总共分几步?  三步. 第一步,打开冰箱门,第二步,把大象装进去

　　　　　　　　　　　第三部,把冰箱门关上

　　　　面向对象思维:

　　　　　　　　　　　造一个大象,说,大象去进冰箱,大象打开冰箱门,大象进冰箱,大象关冰箱门

二,面向对象如何编写

　　

class 类名:
    pass
# 这就是一个类 

class Car:       # 注意 类的首字母 大写,也就是 遵循 驼峰  原则
    pass
#  这就造了一个 车的 类

c = Car()    
# 创建了一辆车

 　　现在车有了,我们来装饰一下我们的爱车,给上个 颜色,车牌,排量 等等

c.color = "red"
c.pai = "京A88888"
c.pailiang = "1.6T"
print(c.color)
print(c.pai)
print(c.pailiang)

# 我们使用 "对象.特征" ,可以给对象设置属性信息

　　接下来,再造一辆车,并给车设置相关的属性信息

c1 = Car()
c1.color = "white"
c1.pai = "京B66666"
c1.pailiang = "1.8T"

print(c1.color)
print(c1.pai)
print(c1.pailiang)

　　我们发现 这两辆车是完全不相同的两辆车,但是,拥有相同的属性和信息,是不是有点冗余了,怎么办??

　　我们把 车的 信息写入类里,会不会更好呢?而且,我的车在创建的时候,这些信息应该是已经设计好了的

　　,不应该是后天设计的,好了,我们知道需求了,在创建对象的时候,能给对象设置一些初始化的属性信息

　　在 python 中,我们可以用 __init__(self) 函数给对象进行初始化操作,这个函数(方法)被称为构造函数(方法

class Car:
    def __init__(self,color,pai,pailiang):
        # self 表示当前类的对象,当前你创建的谁,谁访问这个方法,那这个self就是谁
        self.color = color
        self.pai = pai
        self.pailiang = pailiang

c1 = Car("红色","新J66666","2.0T")
c2 = Car("绿色","新J88888","206T")

print(c1.color)    # 红色
print(c2.color)    # 绿色

# 通过打印,我们发现,这两个对象原来可以这样完成属性的设置

　　现在车的属性设置好了,那现在我想让我的车跑,可以吗? 答案是肯定的,那我的车能飞嘛? 答案依然是肯定

　　的.那么 跑 和 飞 是什么?/ 是一个动作吧,所以我们把 跑和飞 写成一个函数,但是在面向对象编程中,我们

　　不应该叫函数,改成 方法,只不过这个 方法写起来 比正常的 函数多了一个参数 self,仅此而已....

class Car:
    def __init__(self,color,pai,pailiang):
        # self 表示当前类的对象,当前你创建的谁,谁访问这个方法,那这个self就是谁
        self.color = color
        self.pai = pai
        self.pailiang = pailiang

    def run(self):
        print("我的车真的可以跑,哈哈哈")

    def fly(self):
        print("我的车还可以飞,哈哈哈真厉害...")

c1 = Car("红色","新J66666","2.0T")
c2 = Car("绿色","新J88888","206T")

c1.run()  # 我的车真的可以跑,哈哈哈
c2.fly()  #  我的车还可以飞,哈哈哈真厉害...

　　总结:

　　　　类与对象的关系:类是对事物的总结.抽象的概念,类用来描述对象

　　　　　　　　　　　　对象是类的实例化结果,对象能执行哪些方法,都是由类来决定

　　　　　　　　　　　　类中定义了什么功能,那对象就拥有什么功能

三 面向对象 和 面向过程 大  PK

　　那么面向对象和面向过程,哪个更好呢? 具体问题,具体分析,没有绝对的好与不好,这一点要注意

还来装大象看下:

1.面向过程

# 非函数版
print("开冰箱门")
print("装大象")
print("关冰箱门")

# 函数版
def open():
    print("开冰箱门")
def zhuang():
    print("装大象")
def close():
    print("关冰箱门")

open()
zhuang()
close()

2.面向对象

class Elephant:
    def __init__(self):
        pass

    def open(self):
        print("大象打开冰箱门")
    def zhuang(self):
        print("大象自己进冰箱")
    def close(self):
        print("大象关冰箱门")
elp = Elephant()
elp.open()
elp.zhuang()
elp.close()

# 面向对象 主体是 大象,所有的动作 都是大象自己 主动完成的

　　孙悟空大战葫芦娃,有一个小猴,叫悟空,会使用 瞪着眼睛看 必杀技

　　1.面向过程

def func1(name,age,bsj):
    print("%s,今年%s岁了,使用%s 必杀技,疯狂输出大娃" % (name,age,bsj))
def func2(name,age,bsj):
    print("%s,今年%s岁了,使用%s 必杀技,疯狂输出二娃" % (name,age,bsj))
def func3(name,age,bsj):
    print("%s,今年%s岁了,使用%s 必杀技,疯狂输出三娃" % (name,age,bsj))

func1("悟空",500,"登着眼睛看")
func2("悟空",500,"登着眼睛看")
func3("悟空",500,"登着眼睛看")

# 悟空,今年500岁了,使用登着眼睛看 必杀技,疯狂输出大娃
# 悟空,今年500岁了,使用登着眼睛看 必杀技,疯狂输出二娃
# 悟空,今年500岁了,使用登着眼睛看 必杀技,疯狂输出三娃

　　2.面向对象

class Monkey:
    def __init__(self,name,age,bsj):
        self.name = name
        self.age = age
        self.bsj = bsj

    def big(self):
        print("%s,今年%s 岁了,使用他的 %s 必杀技,疯狂输出大娃" % (self.name,self.age,self.bsj))

    def sec(self):
        print("%s,今年%s 岁了,使用他的 %s 必杀技,疯狂输出大娃" % (self.name, self.age, self.bsj))

    def three(self):
        print("%s,今年%s 岁了,使用他的 %s 必杀技,疯狂输出大娃" % (self.name, self.age, self.bsj))

m = Monkey("悟空",500,"瞪着眼睛看")
m.big()
m.sec()
m.three()

# 悟空,今年500 岁了,使用他的 瞪着眼睛看 必杀技,疯狂输出大娃
# 悟空,今年500 岁了,使用他的 瞪着眼睛看 必杀技,疯狂输出大娃
# 悟空,今年500 岁了,使用他的 瞪着眼睛看 必杀技,疯狂输出大娃

　　在这个 实例 中,我们都会觉得 面向对象 的 思维更加清晰一些,代码也更容易编写一些,所以,用哪种

　　　　编程思想不是绝对的,要根据需求和需要来完成,具体问题具体分析嘛!!!

四 面向对象三大特征

　　面向对象三大特征:封装,继承,多态,只要是面向对象编程语言,都有这三个特征

　　1.封装: 把很多数据封装到一个对象中,把固定功能的代码封装到一个代码块,函数,对象,打包成模块

　　　　　　这都属于封装的思想

　　2.继承:子类可以自动拥有父类除了 私有属性外的其他所有内容.

　　　　　　在类名的后面添一个小括号,小括号写入你要继承的类名,就完成了继承关系

　　　　　　类的继承顺序是先在自己类里找,找不到去父类里找,就近原则

来看一段代码:

class Yao:
    def chi(self):
        print("妖精都是会吃人的")

class Xyao(Yao):
    pass

xy = Xyao()
xy.chi()      # 妖精都是会吃人的

　　在 python 中,一个类可以同时继承 多个父类

class Qindie:
    def chi(self):
        print("亲爹给你好吃的")

    def play(self):
        print("亲爹会陪你玩")

class Gandie:
    def money(self):
        print("干爹给钱啊")

    def play(self):
        print("干爹也会陪你玩")

class Girl(Qindie,Gandie):
    pass

xiaohua = Girl()
xiaohua.chi()
xiaohua.play()
xiaohua.money()

# 亲爹给你好吃的
# 亲爹会陪你玩
# 干爹给钱啊

　　具体的MRO((method resolution order)算法,我们到后面会具体的进行分析和讲解

　　3.多态: 同一个对象,多种形态.这个在 python中是很不容易说明白的,因为我们一直在用,只是没有具体

　　　　　　的说,比如,我们创建一个变量 a = 10,此时我们知道 a 是整型,但是我们可以通过程序让

　　　　　　a = "哈哈哥" ,这时,a 又变成了 字符串,这是我们都知道的,但是,我要告诉你,这就是多态性

　　　　　　同一个变量可以有 多种形态,接下来 让我们 看一个程序.

　　　　　　饲养员  哈哈哥 的一天的工作,从早上开始喂猪,中午喂哈士奇,晚上喂阿拉斯加

class Animal:
    def chi(self):
        print("我会吃")

class Pig(Animal):
    def chi(self):
        print("猪在吃")

class Hasiqi(Animal):
    def chi(self):
        print("哈士奇在吃")

class Alasika(Animal):
    def chi(self):
        print("阿拉斯加在吃")
class Syy:
    def wei_animal(self,ani):
        ani.chi()

zhu = Pig()
erha = Hasiqi()
als = Alasika()

hahage = Syy()
hahage.wei_animal(zhu)
hahage.wei_animal(erha)
hahage.wei_animal(als)

# 猪在吃
# 哈士奇在吃
# 阿拉斯加在吃

　　多态的好处: 程序具有超高的可扩展性,面向对象思想的核心和灵魂,python自带多态