（十五）初识对象

⼀. ⾯向对象和⾯向过程

1. ⾯向过程: ⼀切以事物的流程为核⼼. 核⼼是"过程"⼆字, 过程是指解决问题的步骤,即, 先⼲什么, 后⼲什么. 基于该思想编写程序就好比在编写⼀套流⽔线. 是⼀种机械式的编程思维

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

　　 缺点: 可扩展性差

2. ⾯向对象: ⼀切以对象为中⼼.

       什么是对象? 不好解释. 先解释什么是⻋? 有轱辘, 有⽅向盘, 有发动机, 会跑的是⻋。 在看⼀个例子。什么是⼈？有名字, 年龄, 爱好, 会唱歌跳舞思考的是⼈。我们给这两个

例子下了⼀个简单的定义。总结: 具有相同属性和动作的结合体叫对象。⾯向对象思维, 要⾃⼰建立对象，⾃⼰建立场景。你就是⾯向对象世界中的上帝，你想让⻋⼲嘛就⼲嘛，你想让⼈⼲嘛⼈就能⼲嘛。

 优点: 可扩展性强

 缺点: 编程的复杂度⾼于⾯向过程

 对比:

       要把⼤象装冰箱, 总共分⼏步? 三步：第⼀步，打开冰箱⻔；第⼆步，装⼤象； 第三步关，冰箱⻔。 这是⼀个典型的⾯向过程的思维⽅式。来我们如果换成⾯向对象呢? 很简单，想办法造⼀个会钻冰箱的⼤象就可以了，然后命令⼤象，进冰箱， ⼤象就乖乖的进冰箱了， 这就是⾯向对象思维。 我们⾯向的不再是事物发展的流程, ⽽是操纵某⼀种事物的个体， 具体的某⼀个个体。

⼆. ⾯向对象如何编写

1. 格式：

格式：class 类名：
     　　pass
例子：假设，我们创建一个车类
     class Car:
           pass

      #⻋有了，我们的⻋⾄少得有个颜⾊, ⻋牌, 排量等等信息。 不同的⻋, 有不同的颜⾊, ⻋牌, 排量等。

　c = Car( )

    c.color = "red"

　c.pai = "京A66666"

　c.pailiang = "1.6T"

　print(c.color)

　print(c.pai)

　print(c.pailiang)

　　

      车有了，也创建了，但是如果还想再多创建几辆怎么办呢？简单，把上面代码再复制几份就是了。但是，如果这样操作了，就会产生很多冗余的代码，看着也不简洁。看下面的写法：

 class Car:
 　　def __init__(self, color, pai, pailiang): # self表示当前类的对象. 当前你创建的是谁, 谁来访问的这个⽅法.那这个self就是谁.
 　　　　self.color = color
 　　　　self.pai = pai
 　　　　self.pailiang = pailiang
c1 = Car("red", "京A66666", "1.6T")#创建第一辆
c2 = Car("white", "京B22222", "2,0T")#创建第二辆

　　

属性值，设置完了，一辆车有了。但是车的作用是什么？就是在路上跑啊。所以，再把跑这个功能添加进去。

class Car:
 　　def __init__(self, color, pai, pailiang): # self表示当前类的对象. 当前你创建的是谁, 谁来访问#的这个⽅法.那这个self就是谁.
 　　　　self.color = color
 　　　　self.pai = pai
 　　　　self.pailiang = pailiang
 　　def run(self, speed):
 　　　　print("⻋可以跑%s迈" % speed)

c = Car("red", "京A66666", "2.0T")#创建一个对象，就是新建一辆车
c.run(100) # 这时. python会⾃动把对象c传递给run⽅法的第⼀个参数位置. 

　　

总结: 类与对象的关系: 类是对事物的总结。抽象的概念，类⽤来描述对象，对象是类的实例化的结果。对象能执⾏哪些⽅法，都由类来决定，类中定义了什么，对象就拥有什么。

三. ⾯向对象的三⼤特征

      ⾯向对象三⼤特征: 封装, 继承, 多态。只要是⾯向对象编程语⾔，都有这三个特征。

      1. 封装: 把很多数据封装到⼀个对象中，把固定功能的代码封装到⼀个代码块，函数, 对象, 打包成模块， 这都属于封装的思想。具体的情况具体分析，比如，你写了⼀个很⽜B

的函数，那这个也可以被称为封装。在⾯向对象思想中，是把⼀些看似⽆关紧要的内容组合到⼀起统⼀进⾏存储和使⽤，这就是封装。

      2. 继承: ⼦类可以⾃动拥有⽗类中除了私有属性外的其他所有内容，说⽩了, ⼉⼦可以随便⽤爹的东⻄，但是朋友们, ⼀定要认清楚⼀个事情. 必须先有爹, 后有⼉⼦，顺序不能乱。在python中实现继承非常简单，在声明类的时候, 在类名后⾯添加⼀个⼩括号,就可以完成继承关系。那么什么情况可以使⽤继承呢? 单纯的从代码层⾯上来看，两个类具有相同的功能或者特征的时候，可以采⽤继承的形式，提取⼀个⽗类, 这个⽗类中编写着两个类相同的部分，然后两个类分别去继承这个类就可以了。 这样写的好处是我们可以避免写很多重复的功能和代码，如果从语义中去分析的话，会简单很多。如果语境中出现了x是⼀种y，这时, y是⼀种泛化的概念，x比y更加具体。那这时x就是y的⼦类。比如，猫是⼀种动物，猫继承动物，动物能动，猫也能动，这时猫在创建的时候就有了动物的"动"这个属性。再比如, ⽩骨精是⼀个妖怪. 妖怪天⽣就有⼀个比较不好的功能"吃⼈", ⽩骨精⼀出⽣就知道如何"吃⼈"，此时⽩骨精继承妖精。话不多说上代码：

class Yao:
 	def chi(self):
 		print("我是妖怪, 我天⽣就会吃⼈")
class BaiGuJing(Yao): # ⽩⻣精继承妖怪
 	pass
bgj = BaiGuJing()
bgj.chi() # 我是妖怪, 我天⽣就会吃⼈ # 虽然⽩⻣精类中没有编写chi. 但是他爹有啊. 直接拿来⽤

　　

在python中, ⼀个类可以同时继承多个⽗类。说⽩了, 现在⼀个⼉⼦可能会有多个爹了。既然是有这么多个爹, 总得有远有近。

class Cla01:
     def fun01(self):
        print("Cla01.fun01")
     def fun02(self):
        print("Cla01.fun02")
class Cla02:
     def fun03(self):
        print("Cla02.fun03")
     def fun02(self):
        print("Cla02.fun02")
class Cla(Cla01, Cla02):
     pass
obj = Cla()
obj.fun01() # 亲爹
obj.fun03() # 亲爹没有, 找⼲爹
obj.fun02() # 亲爹有了, 就不找⼲爹了

　　

3. 多态: 同⼀个对象, 多种形态。这个在python中其实是很不容易说明⽩的， 因为我们⼀直在⽤，只是没有具体的说。比如，我们创建⼀个变量a = 10 , 我们知道此时a是整数类型， 但是我们可以通过程序让a = "alex", 这时, a⼜变成了字符串类型。这是我们都知道的，但是, 我要告诉你的是，这个就是多态性。同⼀个变量a可以是多种形态，可能这样的程序和说法你还geet不到具体什么是多态。接下来，我们来看⼀个程序，北京动物园饲养员Tom⼀天的⼯作， 从早上开始喂养猪, 中午喂哈⼠奇, 晚上还得喂阿拉斯加。来我们⽤代码实现这样的代码: 

class Animal:
 	def chi(self):
 		print("动物就知道吃")
class Pig(Animal):
 	def chi(self):
 		print("猪在吃")
class Haski(Animal):
 	def chi(self):
 		print("哈⼠奇在吃")
class Alasika(Animal):
 　　def chi(self):
 　　　　print(("阿拉斯加在吃")
 
class SiYangYuan:
 　　def yanng_animal(self, ani):
 	ani.chi()
 
zhu = Pig()
erha = Haski()
ala = Alasika()

Tom= SiYangYuan()
Tom.yanng_animal(zhu)
Tom.yanng_animal(erha)
Tom.yanngg_animal(ala)

　　

多态的好处: 程序具有超⾼的可扩展性. ⾯向对象思想的核⼼与灵魂. python⾃带多态。