zoukankan      html  css  js  c++  java
  • 面向对象基础篇

    1、面向对象和函数的区别

      面向过程:根据业务逻辑从上到下写垒代码

      函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可

      面向对象:对函数进行分类和封装,让开发“更快更好更强

    2、面向对象是一种编程方式,此编程方式一般使用“类”和“对象”来实现,所以面向对象编程就是对类和对象的使用。

    类就是一个模板,模板里面包含很多函数,在函数中实现一些功能。

    对象就是根据模板创建的实例,通过实例对象可以执行类中的函数。

    1 class foo(object):     #class是关键字,表示要创建类,foo是类的名称。
    2     def bar(self):       #创建类中的函数
    3         print("he is jason")    #
    4 
    5 obj = foo()    #根据类foo创建对象
    6 obj.bar()      #传参数

    备注:类中函数的第一个参数必须是self,表示类中的对象。类中定义的函数叫做方法。

    简单类的创建及其方法的调用等

     1 class foo:   #创建类
     2     def bar(self):
     3         print("i am bar")
     4 
     5     def hello(self,name):
     6         print("i am %s" %name)
     7 
     8 obj = foo()     #根据类foo创建对象obj
     9 obj.bar()       #执行bar方法
    10 obj.hello("wupeiqi")    #执行hello方法

    3、面向对象的三大特性

    面向对象的三大特征是指封装、继承和多态

    一、封装:封装就是将内容封装到某个地方,以后再去调用被封装在某处的内容。

    所以在使用面向对象封装特性时,需要:

    •   将内容封装到某处
    •   从某处调用被封装的内容

    第一步:将内容封装到某处

     1 class foo(object):   #创建类
     2 
     3     def __init__(self,name,age):
     4         self.name = name
     5         self.age = age
     6 
     7 
     8 obj1 = foo("haha",20)     #根据类创建对象,自动执行foo类的__init__方法
     9 obj2 = foo("hehe",21)     #讲hehe和21分别封装到self 的name和age里面
    10 
    11 print(obj1.name,obj1.age)   #打印obj1的名字和年龄
    12 print(obj2.name,obj2.age)   #打印obj2的名字和年龄

    self 是一个形式参数,当执行obj1 = foo("haha",20)时,self ==obj1

              当执行obj2 = foo(“hehe”,21)时,self == obj2

    所以,内容被封装到了对象obj1和obj2中,每个对象中都有name和age属性。

    第二步:从某处调用被封装的内容

    调用被封装的内容时,有两种情况:

    • 通过对象直接调用
    • 通过self间接调用

    1、通过对象直接调用被封装的内容

     1 class foo(object):   #创建类
     2 
     3     def __init__(self,name,age):
     4         self.name = name
     5         self.age = age
     6 
     7 
     8 obj1 = foo("haha",20)     #根据类创建对象,自动执行foo类的__init__方法
     9 obj2 = foo("hehe",21)     #讲hehe和21分别封装到self 的name和age里面
    10 
    11 print(obj1.name)   #直接调用obj1对象的name属性
    12 print(obj1.age)    #直接调用obj1对象的age属性
    13 print(obj2.name)   #直接调用obj2对象的name属性
    14 print(obj2.age)    #直接调用boj2对象的age属性

    2、通过self间接调用被封装的内容

    执行类中的方法时,需要通过self间接调用被封装的内容

     1 class foo(object):   #创建类
     2 
     3     def __init__(self,name,age):
     4         self.name = name
     5         self.age = age
     6     def detail(self):
     7         print(self.name)
     8         print(self.age)
     9 
    10 obj1 = foo("haha",20)     #根据类创建对象,自动执行foo类的__init__方法
    11 obj1.detail()
    12 obj2 = foo("hehe",21)     #讲hehe和21分别封装到self 的name和age里面
    13 obj2.detail()

    如上所示:python首先执行init函数,把obj 传给self。并通过detail函数打印出结果

    综上所述,对于面向对象的封装来说,就是使用构造方法将内容封装到对象中,然后通过对象直接或者间接通过self获取被封装的内容。

    封装的练习

    练习一:在终端输出如下信息

    • 小明,10岁,男,上山去砍柴
    • 小明,10岁,男,开车去东北
    • 小明,10岁,男,最爱大保健
    • 老李,90岁,男,上山去砍柴
    • 老李,90岁,男,开车去东北
    • 老李,90岁,男,最爱大保健
    • 老张...

    面向对象实现一

     1 class foo(object):   #创建类
     2 
     3     def __init__(self,name,age,gender,profession):
     4         self.name = name
     5         self.age = age
     6         self.gender = gender
     7         self.profession = profession
     8 
     9 
    10 obj1 = foo("小明",10,"","上山去砍柴")
    11 
    12 obj2 = foo("小明",10,"","开车去东北")
    13 
    14 obj3 = foo("小明",10,"","最爱大保健")
    15 obj4 = foo("老李",90,"","上山去砍柴")
    16 obj5 = foo("老李",90,"","开车去东北")
    17 obj6 = foo("老李",90,"","最爱大保健")
    18 
    19 print obj1.name,obj1.age,obj1.gender,obj1.profession
    20 print obj2.name,obj2.age,obj2.gender,obj2.profession
    21 print obj3.name,obj3.age,obj3.gender,obj3.profession
    22 print obj4.name,obj4.age,obj4.gender,obj4.profession
    23 print obj5.name,obj5.age,obj5.gender,obj5.profession
    24 print obj6.name,obj6.age,obj6.gender,obj6.profession
    面向对象实现一

    面向对象实现二:

     1 class foo(object):   #创建类
     2 
     3     def __init__(self,name,age,gender):
     4         self.name = name
     5         self.age = age
     6         self.gender = gender
     7     def kanchai(self):
     8         print "%s,%s岁,%s,上山去砍柴" %(self.name,self.age,self.gender)
     9     def qudongbei(self):
    10         print "%s,%s,%s,开车去东北" %(self.name,self.age,self.gender)
    11     def dabaojian(self):
    12         print "%s,%s,%s,最爱大保健" %(self.name,self.age,self.gender)
    13 
    14 obj = foo("小明",10,"")
    15 obj.kanchai()
    16 obj.qudongbei()
    17 obj.dabaojian()
    18 
    19 laoli = foo("老李",90,'')
    20 laoli.kanchai()
    21 laoli.qudongbei()
    22 laoli.dabaojian()
    面向对象实现二

    函数实现方法:

     1 def kanchai(name,age,gender):
     2     print "%s,%s岁,%s,上山去砍柴" %(name,age,gender)
     3 def qudongbei(name,age,gender):
     4     print "%s,%s岁,%s,开车去东北" %(name,age,gender)
     5 def dabaojian(name,age,gender):
     6     print "%s,%s岁,%s,最爱大保健" %(name,age,gender)
     7 
     8 kanchai("小明",10,"")
     9 qudongbei("小明",10,"")
    10 dabaojian("小明",10,"")
    11 
    12 kanchai("老李",10,"")
    13 qudongbei("老李",10,"")
    14 dabaojian("老李",10,"")
    函数实现

     封装的练习二:游戏人生程序

    1、创建三个游戏人物,分别是:

    • 苍井井,女,18,初始战斗力1000
    • 东尼木木,男,20,初始战斗力1800
    • 波多多,女,19,初始战斗力2500

    2、游戏场景,分别:

    • 草丛战斗,消耗200战斗力
    • 自我修炼,增长100战斗力
    • 多人游戏,消耗500战斗力

    代码实现如下:

     1 class game(object):
     2     def __init__(self,name,gender,age,fight):
     3         self.name = name
     4         self.gender = gender
     5         self.age = age
     6         self.fight = fight
     7 
     8     def caocong(self):
     9         print self.fight - 200
    10     def xiulian(self):
    11         print self.fight +100
    12     def youxi(self):
    13         print self.fight - 500
    14     def detail(self):
    15         temp = "姓名:%s;性别:%s;年龄:%s;战斗力:%s" %(self.name,self.gender,self.age,self.fight)
    16         print temp
    17 
    18 cang = game("仓京京","",18,1000)
    19 dong = game("东尼木木","",20,1800)
    20 bo = game("波多多","",19,2500)
    21 
    22 cang.caocong()
    23 dong.xiulian()
    24 bo.youxi()
    25 
    26 cang.detail()
    27 dong.detail()
    28 bo.detail()

    4、继承

    面向对象的继承和现实生活中的继承相同,即 子可以继承父的内容。

    例如:猫可以   叫、吃、喝、拉

         狗可以,叫、吃、和、拉

    如果要分别为猫和狗创建一个类,那么就需要为猫和狗实现他们 所有的功能,如下所示:

     1 class cat:
     2     def catcall(self):
     3         print "call"
     4     def eat(self):
     5         print "eat"
     6     def drunk(self):
     7         print "drunk"
     8     def shit(self):
     9         print "shit"
    10 class dog:
    11     def dogcall(self):
    12         print "call"
    13     def eat(self):
    14         print "eat"
    15     def drunk(self):
    16         print "drunk"
    17     def shit(self):
    18         print "shit"

    上述代码可以看出,吃、喝拉都屎猫和狗具有的共同功能,我们分别为狗和猫的类中写了两次。如果使用继承的思想,如下实现:

    动物:吃、喝、拉

      猫:猫叫(猫继承动物的功能)

      狗:狗叫(狗继承动物的功能)

     1 class animal:
     2     def eat(self):
     3         print "%s 吃" %self.name
     4     def drunk(self):
     5         print "%s 喝" %self.name
     6     def shit(self):
     7         print "%s 拉" %self.name
     8 class cat(animal):
     9     def __init__(self,name):
    10         self.name = name
    11         self.breed = ""
    12     def cry(self):
    13         print "猫叫"
    14 class dog(animal):
    15     def __init__(self,name):
    16         self.name = name
    17         self.breed = ""
    18     def cry(self):
    19         print "狗叫"
    20 
    21 c1 = cat("A小猫")
    22 c1.eat()
    23 
    24 c2 = cat("B小猫")
    25 c2.drunk()
    26 d1 = dog("A狗")
    27 d1.eat()
    28 
    29 ————————————————————————————————————
    30 
    31 打印结果:
    32 A小猫 吃
    33 B小猫 喝
    34 A狗 吃

    对于面向对象的继承来说,就是将多个类共有的方法提取到父类中,子类仅需继承父类,而不再一一写下此功能,统一在父类中实现即可。

  • 相关阅读:
    关于because the weaver option '-Xset:weaveJavaxPackages=true' has not been specified报错的解决方案
    对不起,这是一篇负能量爆棚的文章
    selenium启动报错“ incorrect JSON status mapping for 'unknown error' (500 expected)”
    解决关于win10下eclipse代码格式化不生效问题
    递归遍历所有xml的节点及子节点
    性能调优-CPU方面,内存方面
    二进制日志备份与恢复,快照备份,复制
    逻辑备份,mysqldump,SELECT…INTO OUTFILE,恢复
    备份与恢复概述,冷备,热备
    分布式事务,不好的事务习惯
  • 原文地址:https://www.cnblogs.com/bravexz/p/5034679.html
Copyright © 2011-2022 走看看