本节主要内容:
1.⾯向对象和面向过程
2.⾯向对象如何编写
3.⾯向对象和面向过程大PK
4.面向对象的三大特征
1.⾯向对象和面向过程
1.1 面向过程: 一切以事物的流程为核心. 核心是"过程"二字, 过程是指解决问题的步骤,
即, 先干什么, 后干什么. 基于该思想编写程序就好比在编写一套流水线. 是一种机械式的编程思维
优点: 负责的问题流程化, 编写相对简单
缺点: 可扩展性差
1.2. 面向对象: 一切以对象为中心.
总结: 具有相同属性和动作的结合体叫对象. 面向对象思维, 要⾃己建立对象. ⾃己建立场景.
你是就是面向对象世界中的上帝. 你想让车干嘛就干嘛. 你想让人干嘛人就能干嘛.
优点: 可扩展性强
缺点: 编程的复杂度⾼高于⾯面向过程
1.3 面向对象如何编写
1.3.1 使用实例
类名首字母大写.
class Computer:
构造方法. 在创建的对象的时候由系统自动访问这个方法
self: 自己. 自身. 类的对象. 当前正在创建的对象
def __init__(self, pinpai, price, cpu, neicun): # 谁在调用, self就是谁, self 由python自动传递
self.pinpai = pinpai
self.price = price
self.cpu = cpu
self.neicun = neicun
方法. 该类型的对象能够执行哪些操作
def dayouxi(self, game): # 谁调用的这个方法. self就是谁
我用我的self.pinpai的调用. 利用很牛B的self.cpu来完成吃鸡操作
print("我要打游戏, 我要%s" % game)
c = Computer("微软",25000,"i9","5T") # 创建对象
c.dayouxi("吃鸡")
1.3.2 ⽤⾯向对象的思维来完成⽤户登录.
class User:
def __init__(self, username, password):
self.username = username
self.password = password
def login(self, uname, upws):
if uname == self.username and upws == self.password:
return True
else:
return False
u1 = User("alex", "123")
ret = u1.login(input("请输入你的用户名"), input("请输入密码"))
print(ret)
总结: 类与对象的关系: 类是对事物的总结. 抽象的概念念. 类用来描述对象. 对象是类的实例
化的结果. 对象能执行哪些方法. 都由类来决定. 类中定义了了什么. 对象就拥有什么.
3. 面向对象和面向过程大PK
看看对比
3.1 面向过程编程
#alex大战奥特曼
def daZhanAoTeMan(name, wuqi, jineng):
print("%s 使用 %s 配合 %s技能狂怼奥特曼" % (name, wuqi, jineng))
#alex大战哥斯拉
def daZhanGeSiLa(name, wuqi, jineng):
print("%s 使用 %s 配合 %s技能狂怼哥斯拉" % (name, wuqi, jineng))
# alex大战蝙蝠侠
def daZhanBianFuXia(name, wuqi, jineng):
print("%s 使用 %s 配合 %s技能狂怼蝙蝠侠" % (name, wuqi, jineng))
daZhanAoTeMan("alex", "菜刀", "动感光波")
daZhanGeSiLa("alex", "菜刀", "动感光波")
daZhanBianFuXia("alex", "菜刀", "动感光波")
3.2 面向对象编程
class Person:
def __init__(self, name, wuqi, jineng):
# 封装: 对属性的封装.
self.name = name
self.wuqi = wuqi
self.jineng = jineng
# 对方法进行封装
def daZhanAoTeMan(self):
print("%s 使用 %s 配合 %s技能狂怼奥特曼" % (self.name, self.wuqi, self.jineng))
# alex大战哥斯拉
def daZhanGeSiLa(self):
print("%s 使用 %s 配合 %s技能狂怼哥斯拉" % (self.name, self.wuqi, self.jineng))
# alex大战蝙蝠侠
def daZhanBianFuXia(self):
print("%s 使用 %s 配合 %s技能狂怼蝙蝠侠" % (self.name, self.wuqi, self.jineng))
a1 = Person("alex", "菜刀", "动感光波")
a1.daZhanAoTeMan()
a1.daZhanBianFuXia()
a1.daZhanGeSiLa()
从上面两个例子中,我们可得到:
1.主语发生了改变
2.函数式编程. 简单的基本功能还是函数式编程更加好用
3.面向对象: 如果功能非常复杂的时候.编程会比较容易编写.
4.面向对象的三大特征 封装 继承 多态
4.1 封装
概念:封装: 把很多数据封装到一个对象中. 把固定功能的代码封装到⼀个代码块, 函数, 对象, 打包成模块. 这都属于封装的思想.
具体的情况具体分析. 比如. 你写了了一个很牛B的函数. 那这个也可以被称为封装.
在面向对象思想中. 是把⼀些看似⽆无关紧要的内容组合到一起统⼀进行存储和使用. 这就是封装.
实例1:
class DBUtil:
def __init__(self, ip, username, password):
#对属性的封装(对IP 端口,密码等的封装)
self.ip = ip
self.username = username
self.password = password
# 对功能的封装(对数据库的增删改操作)
def test_connect(self):
pass
def connect(self):
pass
def add(self):
pass
def upd(self):
pass
def remove(self):
pass
def sel(self):
pass
4.2 继承
概念. 继承: 子类可以⾃自动拥有父类中除了私有属性外的其他所有内容.
实例1:
class Foo:
def a(self):
pass
def b(self):
pass
class Bar(Foo): # 子类在父类的基础上扩展了一些功能. 派生
def c(self):
pass
b = Bar()
b.a() #子类可以调用父类的功能
b.b()
b.c()
实例2:依旧是数据库相关的
class DBUtil:
def __init__(self, ip, username, password):
pass
def test_connect(self):
pass
def connect(self):
pass
def close(self):
pass
#(因为各种数据库操作模式不一样,需要子类来进行功能封装,但仍可以继承一些端口,ip等通用信息)
class Mysql_Util(DBUtil):
def add(self):
pass
def delete(self):
pass
def update(self):
pass
class Oracle_Util(DBUtil): #子类上面增加了一些自己的功能
def add(self):
pass
def delete(self):
pass
def update(self):
pass
4.3 多态
在python中多态的效果感受不够明确
class YaoGuai:
def teng(self):
print("妖怪一定会疼")
class ZhiZhuJing(YaoGuai):
def teng(self):
print("蜘蛛精很痛")
class HeiXiongJing(YaoGuai):
def teng(self):
print("黑熊精也很疼")
class BaiGuJing(YaoGuai):
def teng(self):
print("白骨精骨头很疼")
class JinJiaoDaWang(YaoGuai): #该类没有teng(),但因为继承了yaoguai的teng()也可以用
def fangundeteng(self):
print("爆炸的疼")
class SunWuKong:
def da(self, yg): #此处的yg各class YaoGuai JinJiaoDaWang BaiGuJing 都能直接由yg代理引用,便包含了多态,只要有teng()就行
yg.teng() # 只要包含了xxx功能的内容都可以试用. 鸭子模型 -> 多态性
sun = SunWuKong()
sun.da(HeiXiongJing)
sun.da(ZhiZhuJing)
sun.da(JinJiaoDaWang)
4.4 多继承(补充)
class Foo1: #爹1
def money(self):
print("有钱")
class Foo2: #爹2
def play(self):
print("玩儿")
def money(self):
print("没钱")
class Bar(Foo2, Foo1): # 谁靠近BAR谁就是亲爹,优先级更高
pass
b = Bar()
b.money()
