核能来袭-初识面向对象
1.面向对象和面向过程
2.面向对象如何编写
3.面向对象和面向过程大PK
4.面向对象三大特征
一.面向对象和面向过程(重点理解)
1.面向过程:一切以事物的流程为核心.核心就是"过程"二字,过程是指解决问题的步骤,即先干什么,后干什么.基于该思想编写程序就好比在编写一套流水线. 是一种机械式的编程思维
优点:负责问题流程化,编写相对简单. 缺点:可可扩展性差.
2.面向对象:一切以对象为中心.具有相同属性和动作的结合体叫面向对象.面向对象思维要自己建立对象.自己建立场景.你就是面向对象世界中的上帝.你想让车干嘛. 你想让人干嘛人就能干嘛.
优点:可扩展性强 缺点:编程的复杂程度高于面向过程.
二.面向对象如何编写呢?想想在我们的世界中.我们如何造一辆车?
在这里我们画图纸的过程需要我们写类,我们用类来描述一个对象.类的语法很简单.
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)
我们使用"对象.特征"可以给对象设置属性信息
接下来,再造一辆车,并给车设置相关的属性信息
c2=Car()
c2.color="white"
c2.pai="京B22222"
c2.pailiang="2.0T"
print(c1)
print(c2)
在python中我们可以用__init__(self)函数给对象进行初始化操作.这个函数(方法)被称为构造函数(方法)
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")
print(c1.color)
print(c2.color)
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方法的第一个参数位置.
总结:类与对象的关系: 类是对事物的总结. 抽象的概念.
类⽤来描述对象. 对象是类的实例 化的结果. 对象能执⾏哪些⽅法. 都由类来决定. 类中定义了什么. 对象就拥有什么.
三.面向对象和面向过程大PK
1.面向过程:
非函数版:
print("开冰箱门")
print("装大象")
print("关冰箱门")
函数版;
def open_door():
print("开冰箱门")
def zhuang():
print("装大象")
def close_door():
print("关冰箱门")
open_door()
zhuang()
close_door()
2.面向对象:
class Elephant:
def open(self):
print("打开冰箱门")
def close(self):
print("关冰箱门")
def zhuang(self):
print("把自己装进去")
dx=Elephant()
dx.open()
dx.close()
dx.zhuang()
小猪佩奇大战奥特曼.说有一个小猪叫佩奇,今年40岁了.会使用嘴巴嘟嘟必杀技.他不光大战奥特曼,还会大战蝙蝠侠,蜘蛛侠.
1.面向过程:
def da_ao_te_man(name,age,jn):
print("%s,今年%s岁了,使用%s技能疯狂输出奥特曼" % (name,age,jn))
def da_bian_fu_xia(name, age, jn):
print("%s,今年%s岁了,使用%s技能疯狂输出蝙蝠侠" % (name,age,jn))
def da_zhi_zhu_xia(name, age, jn):
print("%s,今年%s岁了,使用%s技能疯狂输出蜘蛛侠" % (name,age,jn))
da_ao_te_man("小猪佩奇",40,"嘴巴嘟嘟")
("小猪佩奇",40,"嘴巴嘟嘟")
da_ao_te_man("小猪佩奇",40,"嘴巴嘟嘟")
da_bian_fu_xia("小猪佩奇",40,"嘴巴嘟嘟")
da_zhi_zhu_xia("小猪佩奇",40,"嘴巴嘟嘟")
2.面向对象
class Pig:
def __init__(self,name,age,jn):
self.name=name
self.age=age
self.jn=jn
def da_ao_te_man(self):
print("%s,今年%s岁了,使用%s技能疯狂输出奥特曼" % (self.name, self.age, self.jn))
def da_bian_fu_xia(self):
print("%s,今年%s岁了,使用%s技能疯狂输出蝙蝠侠" % (self.name, self.age, self.jn))
def da_zhi_zhu_xia(self):
print("%s,今年%s岁了,使用%s技能疯狂输出蜘蛛侠" % (self.name, self.age, self.jn))
peiqi=Pig("小猪佩奇", 40, "嘴巴嘟嘟")
peiqi.da_ao_te_man()
peiqi.da_bian_fu_xia()
peiqi.da_zhi_zhu_xia()
四.面向对象的三大特征
面向对象的三大特征:封装,继承,多态.只要是面向对象编程语言,都有这三个特征
1.封装:把很多数据封装到一个对象中.把固定功能的代码封装到一个代码块,函数,对象,打包成模块.这都属于封装的思想.
2.继承:子类可以自动拥有父类中除了私有属性外的其他所有内容.说白了,儿子可以随便用爹的东西.必须先有爹后有儿子.顺序不能乱.
在python中 实现继承非常简单.在声明类的时候.可以采用继承的形式.提取到一个父类,这个父类中编写者两个类相同的部分.然后两个类分别采取继承这个类就可以了. 这样写的好处就是我们避免写很多重复的功能和代码.如果从语义中去分析的话.会简单很多.如果语境中出现了x是y.这时y就是一种泛化的概念
白骨精是一个妖怪,妖怪生来就有一个比较不好的功能叫"吃人",白骨精一出生就知道如何"吃人".此时白骨精继承妖精.
class Yao:
def chi(self):
print("我是妖怪,我天生就会吃人")
class BaiGuJing(Yao):
pass
bgj=BaiGuJing()
bgj.chi() #我是妖怪,我天生就会吃人 #虽然白骨精类中没有编写chi,但是她有爹啊.直接拿来用
在python中,一个类可以同时继承多个父类.
class QinDie():
def chi(self):
print("亲爹给你好吃的")
def play(self):
print("亲爹陪你玩")
class GanDie():
def qian(self):
print("干爹给你钱啊")
def play(self):
print("干爹会陪你玩")
class GuNiang(QinDie,GanDie):
pass
bumei=GuNiang()
bumei.chi() #亲爹
bumei.qian() #亲爹没有,找干爹
bumei.play() #亲爹有了,就不找干爹了
3.多态：同一个对象，多种形态。 例子：北京动物园饲养员alex一天的工作,从早上开始为主,中午喂哈士奇,晚上还得喂阿拉斯加.
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 yang_animal(self,ani):
ani.chi()
zhu=Pig()
erha=Haski()
ala=Alasika()
alex=SiYangYuan()
alex.yang_animal(zhu)
alex.yang_animal(erha)
alex.yang_animal(ala)
多态的好处:程序具有超高的可扩展性.面向对象思想的核心与灵魂.python自带多态
