欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

第十五天-面向对象01

程序员文章站 2022-03-23 16:39:38
# 面向对象与面向过程# 面向过程:以事物流程为中心,核心是“过程”步骤,即,先干什么,后干什么.# 优点:负责的问题流程化,编写相对简单# 缺点:可扩展性差# 面向对象:一切以对象为中心,万事万物皆是对象(object)# 优点: 可扩展性强# 缺点: 编程的复杂度高于面向过程 # 面向对象# 如... ......

 

# 面向对象与面向过程

# 面向过程:以事物流程为中心,核心是“过程”步骤,即,先干什么,后干什么.
# 优点:负责的问题流程化,编写相对简单
# 缺点:可扩展性差

# 面向对象:一切以对象为中心,万事万物皆是对象(object)
# 优点: 可扩展性强
# 缺点: 编程的复杂度高于面向过程


# 面向对象
# 如何编写面向对象
 1 # class 表示创建一个类
 2 # car 类名 类是对事物的定义 归类
 3 class car:  # 类名首字母大写
 4     pass
 5 
 6 c = car()  # 通过类来创建对象 把类概念实例化  对象 = 类()
 7 
 8 c.chelu ="圆的" # 属性
 9 c.color ="酷黑"
10 c.pailiang = "5.5"
11 c.pz = "浙a86666"
12 # c.xxx  可理解成  对象的 xx属性/xx参数
13 print(c.pailiang)
14 print(c.color)
15 print(c.chelu)
16 print(c.pz)
17 
18 c1 = car()  # 新的对象 不同对象是放在不同空间的 类可多次使用
19 c1.pz = "京a66666"
20 c1.pl = "6.6"
21 c1.color = "骚红"
22 c1.suoyouren = "jiang"
23 
24 print(c1.suoyouren)
25 print(c1.color)
26 print(c1.pl)
27 print(c1.pz)
28 # print(c.price) # 没有的属性会报错
29 #  attributeerror: 'car' object has no attribute 'price'

 

 

# 类的实例化
# 实例化:类名加括号就是实例化,会自动触发__init__函数的运行,可用它来为每个实例定制自己的特征
# self:在实例化时自动将对象/实例本身传给__init__的第一个参数.
 1 class computer:  # 创建类
 2     # 构造方法 __init__(self) 在创建对象时自动访问这个方法 设置一些初始化的属性信息
 3     def __init__(self,pinpai,price,cpu,neicun): # 谁调用,self就是谁 传参时self自动传 self 自身本身
 4         self.pinpai = pinpai
 5         self.price = price
 6         self.cpu = cpu
 7         self.neicun = neicun
 8 
 9     def playgame(self,game): # 定义方法可以新添参数
10         print("我要打游戏,我要%s"% game)
11         print("我用我的%s电脑,利用很吊的%s来成功%s"%(self.pinpai,self.cpu,game))
12 
13 d = computer("小米","8999","i7-8750h","16g") # 创建对象 实例化
14 print(d.pinpai)
15 #
16 d1 = computer("神舟","9999","i7-9700k","32g")
17 print(d1.cpu)
18 #
19 d1.playgame("吃鸡") # 使用 playgame 方法 参数"吃鸡"传给game
# 总结:类与对象的关系:类是对事物的总结.抽象的概念.类用来描述对象.对象是类的
# 实例化的结果.对象能执行哪些方法.都由类来决定.类中定义了什么.对象就拥有什么

 

 

# 练习题
# 思考过程:
# 准备创建类class -> 定义__init__() self.xxx = xxxx
# 对象能干什么事儿? 方法. def 方法名(self, 参数...)
 1 # 1.创建一个武松.武松可以打老虎,杀嫂子,替天行道
 2 class haohan: # 创建类
 3     def __init__(self,mingzi,chenhao,wugong,wuqi):  # 初始化参数
 4         self.mingzi = mingzi
 5         self.chenaho = chenhao
 6         self.wugong = wugong
 7         self.wuqi = wuqi
 8 
 9     def dalaohu(self): # 定义方法
10         print("%s使用%s爆锤老虎"%(self.mingzi,self.wuqi))
11 
12     def shasaozi(self):
13         print("%s怒杀嫂子" % self.mingzi)
14 
15     def titianxingdao(self):
16         print("%s一双%s,走南闯北,替天行道" % (self.mingzi,self.wugong))
17 
18 wusong = haohan("武松","行者","王霸拳","拳头")
19 wusong.dalaohu()
20 wusong.shasaozi()
21 wusong.titianxingdao()
22 # 谁调用,self就是谁,可以多次调用
23 likui = haohan("李逵","黑旋风","板斧","旋风斩")
24 likui.dalaohu()
25 likui.shasaozi()
26 likui.titianxingdao()
27 
28 # 2.⽤面向对象的思维来模拟lol里的盖伦上阵杀敌.
29 class juese:
30     def __init__(self,xingwei,hp,fy):
31         self.xingwei = xingwei
32         self.hp = hp
33         self.fy = fy
34 
35     def yinggang(self,mingzi):
36         print("选%s,%shp%s防御%s就是杠" % (mingzi,self.xingwei,self.hp,self.fy))
37 
38 gailun = juese("上阵杀敌",5000,200)
39 gailun.yinggang("盖伦")
40 
41 # 3.创建一个和尚类,*发挥属性和方法
42 class heshang:
43     def __init__(self,mingzi,wugong,xingwei,simiao,shifu):
44         self.mingzi = mingzi
45         self.wugong = wugong
46         self.xingwei = xingwei
47         self.simiao = simiao
48         self.shifu = shifu
49 
50     def day(self):
51         print("%s师承%s,至%s而来,一身大成%s,%s英勇无敌"%(self.mingzi,self.shifu,self.simiao,self.wugong,self.xingwei))
52 
53 bajie = heshang("八戒","金刚经","降妖除魔","灵隐寺","玄奘")
54 bajie.day()
55 
56 # 4.模拟用户登录
57 class user: # 类名
58     def __init__(self,username,password): # 初始化
59         self.username = username
60         self.password = password
61 
62     def login(self,use,pas):  # 定义登录方法
63         if use == self.username and pas == self.password:
64             return true
65         else:
66             return false
67 
68 u1 = user("王尼玛","123")  # 对象 u1
69 re = u1.login(input("请输入账号:"),input("请输入密码:")) # 调用方法login
70 print(re)

 

 

# 面向对象与面向过程
 1 # 例子1:要把大象装进冰箱
 2 # 面向过程
 3 def open():
 4     print("开门")
 5 def zhuang():
 6     print("装大象")
 7 def close():
 8     print("关门")
 9 open()
10 zhuang()
11 close()
12 
13 # 面向对象
14 class daxiang:
15     def __init__(self,open,zhuang,close):
16         self.open = open
17         self.zhuang = zhuang
18         self.close = close
19 dx = daxiang("开冰箱","装大象","关冰箱")
20 print(dx.open)
21 print(dx.zhuang)
22 print(dx.close)
23 # 如上可看到面向对象很麻烦
24 
25 # 例子2:佩奇大战奥特曼
26 # 面向过程
27 def da_atm(name,age,jn):
28     print("%s,今年%s岁了,使用%s技能疯狂输出奥特曼"%(name,age,jn))
29 def da_bfx(name,age,jn):
30     print("%s,今年%s岁了,使用%s技能疯狂输出蝙蝠侠"%(name,age,jn))
31 def da_zzx(name,age,jn):
32     print("%s,今年%s岁了,使用%s技能疯狂输出蜘蛛侠"%(name,age,jn))
33 
34 da_atm("小猪佩奇",9,"嘴巴嘟嘟")
35 da_bfx("小猪佩奇",9,"嘴巴嘟嘟")
36 da_zzx("小猪佩奇",9,"嘴巴嘟嘟")
37 
38 # 面向对象
39 class pig:
40     def __init__(self,name,age,jn):
41         self.name = name
42         self.age = age
43         self.jn = jn
44 
45     def da_atm(self):
46         print("%s,今年%s岁了,使用%s技能疯狂输出奥特曼" % (self.name,self.age,self.jn))
47     def da_bfx(self):
48         print("%s,今年%s岁了,使用%s技能疯狂输出蝙蝠侠" % (self.name,self.age,self.jn))
49     def da_zzx(self):
50         print("%s,今年%s岁了,使用%s技能疯狂输出蜘蛛侠" % (self.name,self.age,self.jn))
51 
52 peiqi = pig("小猪佩奇",9,"嘴巴嘟嘟")
53 peiqi.da_atm()
54 peiqi.da_bfx()
55 peiqi.da_zzx()
56 
57 # 如上案例 面向对象思路更好,增添方法也容易
58 # 所以.用哪种编程思想不是绝对的.得根据需求来完成.
# 函数式编程:简单的基本功能 函数式编程更好用
# 面向对象:如果功能非常复杂的时候. 面向对象
# 面向对象比面向过程复杂

 

 

# 封装:把很多数据封装到一个对象中.把固定功能的代码封装到一个代码块,函数,对象,打包成模块.这都属于封装的思想
 1 class pig:
 2     def __init__(self,name,age,jn):
 3         # 封装 对属性进行封装
 4         self.name = name
 5         self.age = age
 6         self.jn = jn
 7 
 8     # 对方法进行封装 丢到类pig里面
 9     def da_atm(self):
10         print("%s,今年%s岁了,使用%s技能疯狂输出奥特曼" % (self.name,self.age,self.jn))
11     def da_bfx(self):
12         print("%s,今年%s岁了,使用%s技能疯狂输出蝙蝠侠" % (self.name,self.age,self.jn))
13     def da_zzx(self):
14         print("%s,今年%s岁了,使用%s技能疯狂输出蜘蛛侠" % (self.name,self.age,self.jn))
15 
16 peiqi = pig("小猪佩奇",9,"嘴巴嘟嘟")
17 peiqi.da_atm()
18 peiqi.da_bfx()
19 peiqi.da_zzx()
20 
21 # da_zzx() 直接访问不到
22 # 把属性 方法封装到pig里面 新建对象peiqi拿出来使用
# 封装 应用在数据库里
 1 class dbutil:
 2     def __init__(self, ip, username, password):
 3         self.ip = ip
 4         self.username = username
 5         self.password = password
 6 
 7    # 对功能的封装
 8     def test_connect(self):
 9         pass
10 
11     def connect(self):
12         pass
13 
14     def add(self):
15         pass
16 
17     def upd(self):
18         pass
19 
20     def remove(self):
21         pass
22 
23     def sel(self):
24         pass
25 
26 db = dbutil("192.168.1.1","root","123")  # 方便快速调用
# 相似的 文件读取 工具类 封装
# # excel doc txt 视频 图片



# 继承: 子类自动拥有父类中除了私有内容外的其他所有内容
# 现阶段在我们写的内容没有私有的

'''
继承:儿子可以随便用爹的东西.但一定要认清楚,必须先有爹,后有儿子.顺序不 能乱,
在python中实现继承非常简单.在声明类的时候,类名后面添加一个⼩括号,就可以完成继承关系.
'''
 1 # 例子
 2 class niu:
 3     def da(self):
 4         print("牛魔王打架很厉害")
 5 
 6 class honghaier(niu):
 7     # pass
 8     def da(self):
 9         print("喷火")
10 hhl = honghaier()
11 # hhl.da()  # 没有这个功能找父类要 打印出牛魔王打假很厉害
12 hhl.da() # 喷火 自己有先用自己的
# 当程序中出现了 x是一种y. x可以继承y
1 class animal:
2     def chi(self):
3         print("喜欢吃东西")
4 
5 # 当程序中出现了 x是一种y. x可以继承y
6 # 如 猫是一种动物
7 class cat(animal):
8     pass

 

# 派生 子类在父类的基础上扩展了一些功能
 1 class foo:
 2     def a(self):
 3         pass
 4 
 5     def b(self):
 6         pass
 7 
 8 class bar(foo): #  子类在父类的基础上扩展了一些功能. 派生
 9     def c(self): # 拓展
10         pass
11 
12 # b = bar()
13 # b.a()
14 # b.b()
15 # b.c()

 

# 多继承
# 靠谁近先找谁,自己有先用自己的
 1 class foo1:
 2     def money(self):
 3         print("有钱")
 4 
 5 class foo2:
 6     def play(self):
 7         print("玩儿")
 8 
 9     def money(self):
10         print("没钱")
11 
12 class bar(foo2, foo1): # mro c3算法
13     pass
14 
15 b = bar() # 谁靠近 找谁
16 b.play()
17 b.money()

 

 

 

# 多态: 同一个对象, 多种形态.
1 # 如 创建一个变量a = 10,此时a是整数类型.但我们可以通过让a = "duotai",这时a又变成了字符串类型.
2 a = 10
3 a = "duotai"
4 print(a) # duotai
5 # 这就是多态性 同一个变量可以是多种形态
# python自动多态效果
 1 class aniaml:
 2     def dong(self):
 3         print("动物可以动")
 4 
 5 class cat(aniaml):
 6     def chi(self):
 7         print("猫喜欢吃鱼")
 8 
 9 a = cat()
10 a.chi() # 站在猫的角度. 可以吃
11 a.dong() # 站在动物的角度可以动

 

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