面向对象基础篇

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

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

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

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

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

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

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

class foo(object):     #class是关键字，表示要创建类，foo是类的名称。
    def bar(self):       #创建类中的函数
        print("he is jason")    #

obj = foo()    #根据类foo创建对象
obj.bar()      #传参数

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

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

class foo:   #创建类
    def bar(self):
        print("i am bar")

    def hello(self,name):
        print("i am %s" %name)

obj = foo()     #根据类foo创建对象obj
obj.bar()       #执行bar方法
obj.hello("wupeiqi")    #执行hello方法

3、面向对象的三大特性

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

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

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

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

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

class foo(object):   #创建类

    def __init__(self,name,age):
        self.name = name
        self.age = age


obj1 = foo("haha",20)     #根据类创建对象，自动执行foo类的__init__方法
obj2 = foo("hehe",21)     #讲hehe和21分别封装到self 的name和age里面

print(obj1.name,obj1.age)   #打印obj1的名字和年龄
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、通过对象直接调用被封装的内容

class foo(object):   #创建类

    def __init__(self,name,age):
        self.name = name
        self.age = age


obj1 = foo("haha",20)     #根据类创建对象，自动执行foo类的__init__方法
obj2 = foo("hehe",21)     #讲hehe和21分别封装到self 的name和age里面

print(obj1.name)   #直接调用obj1对象的name属性
print(obj1.age)    #直接调用obj1对象的age属性
print(obj2.name)   #直接调用obj2对象的name属性
print(obj2.age)    #直接调用boj2对象的age属性

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

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

class foo(object):   #创建类

    def __init__(self,name,age):
        self.name = name
        self.age = age
    def detail(self):
        print(self.name)
        print(self.age)

obj1 = foo("haha",20)     #根据类创建对象，自动执行foo类的__init__方法
obj1.detail()
obj2 = foo("hehe",21)     #讲hehe和21分别封装到self 的name和age里面
obj2.detail()

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

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

封装的练习

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

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

面向对象实现一

class foo(object):   #创建类

    def __init__(self,name,age,gender,profession):
        self.name = name
        self.age = age
        self.gender = gender
        self.profession = profession


obj1 = foo("小明",10,"男","上山去砍柴")

obj2 = foo("小明",10,"男","开车去东北")

obj3 = foo("小明",10,"男","最爱大保健")
obj4 = foo("老李",90,"男","上山去砍柴")
obj5 = foo("老李",90,"男","开车去东北")
obj6 = foo("老李",90,"男","最爱大保健")

print obj1.name,obj1.age,obj1.gender,obj1.profession
print obj2.name,obj2.age,obj2.gender,obj2.profession
print obj3.name,obj3.age,obj3.gender,obj3.profession
print obj4.name,obj4.age,obj4.gender,obj4.profession
print obj5.name,obj5.age,obj5.gender,obj5.profession
print obj6.name,obj6.age,obj6.gender,obj6.profession

面向对象实现二：

class foo(object):   #创建类

    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def kanchai(self):
        print "%s,%s岁，%s,上山去砍柴" %(self.name,self.age,self.gender)
    def qudongbei(self):
        print "%s,%s,%s,开车去东北" %(self.name,self.age,self.gender)
    def dabaojian(self):
        print "%s,%s,%s,最爱大保健" %(self.name,self.age,self.gender)

obj = foo("小明",10,"男")
obj.kanchai()
obj.qudongbei()
obj.dabaojian()

laoli = foo("老李",90,'男')
laoli.kanchai()
laoli.qudongbei()
laoli.dabaojian()

函数实现方法：

def kanchai(name,age,gender):
    print "%s,%s岁，%s,上山去砍柴" %(name,age,gender)
def qudongbei(name,age,gender):
    print "%s,%s岁,%s,开车去东北" %(name,age,gender)
def dabaojian(name,age,gender):
    print "%s,%s岁,%s,最爱大保健" %(name,age,gender)

kanchai("小明",10,"男")
qudongbei("小明",10,"男")
dabaojian("小明",10,"男")

kanchai("老李",10,"男")
qudongbei("老李",10,"男")
dabaojian("老李",10,"男")

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

1、创建三个游戏人物，分别是：

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

2、游戏场景，分别：

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

代码实现如下：

class game(object):
    def __init__(self,name,gender,age,fight):
        self.name = name
        self.gender = gender
        self.age = age
        self.fight = fight

    def caocong(self):
        print self.fight - 200
    def xiulian(self):
        print self.fight +100
    def youxi(self):
        print self.fight - 500
    def detail(self):
        temp = "姓名:%s;性别:%s;年龄:%s;战斗力:%s" %(self.name,self.gender,self.age,self.fight)
        print temp

cang = game("仓京京","女",18,1000)
dong = game("东尼木木","女",20,1800)
bo = game("波多多","女",19,2500)

cang.caocong()
dong.xiulian()
bo.youxi()

cang.detail()
dong.detail()
bo.detail()

 

4、继承

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

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

　　   狗可以，叫、吃、和、拉

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

class cat:
    def catcall(self):
        print "call"
    def eat(self):
        print "eat"
    def drunk(self):
        print "drunk"
    def shit(self):
        print "shit"
class dog:
    def dogcall(self):
        print "call"
    def eat(self):
        print "eat"
    def drunk(self):
        print "drunk"
    def shit(self):
        print "shit"

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

动物：吃、喝、拉

　　猫：猫叫（猫继承动物的功能）

　　狗：狗叫（狗继承动物的功能）

class animal:
    def eat(self):
        print "%s 吃" %self.name
    def drunk(self):
        print "%s 喝" %self.name
    def shit(self):
        print "%s 拉" %self.name
class cat(animal):
    def __init__(self,name):
        self.name = name
        self.breed = "猫"
    def cry(self):
        print "猫叫"
class dog(animal):
    def __init__(self,name):
        self.name = name
        self.breed = "狗"
    def cry(self):
        print "狗叫"

c1 = cat("A小猫")
c1.eat()

c2 = cat("B小猫")
c2.drunk()
d1 = dog("A狗")
d1.eat()

————————————————————————————————————

打印结果：
A小猫 吃
B小猫 喝
A狗 吃

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