从零开始学Python第六周：面向对象基础（需修改）

标签（空格分隔）：面向对象

一，面向对象基础

（1）面向对象概述

面向过程：根据业务逻辑从上到下写代码
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象：对函数进行分类和封装，让开发“更快更好更强...”

面向过程编程最易被初学者接受，往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。

（2）面向对象编程和函数式编程对比

函数
def mail(email,message):
print(\'去发吧\')
return True
mail("chensiqi@126.com","好人")
面向对象：类和对象
class Foo:
def mail(self,email,message):
print(\'去发吧\')
return True

调用（对象，类名）

obj = Foo()

通过对象去执行方法

obj.mail("chensiqi@126.com","好人")

（3）面向对象中对象和类的关系

面向对象编程是一种编程方式，此编程方式的落地需要使用"类"和"对象"来实现，所以，面向对象编程其实就是对"类"和"对象"的使用

类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
class是关键字，表示类
创建对象，类名称后加括号即可

（4）面向对象之构造方法

（5）面向对象之应用场景实例

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

小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健

老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健

面向对象编程：

class Person:
    def __init__(self,name,age,sex):
        self.Name = name
        self.Age = age
        self.Sex = sex
    
    def action(self):
        print (self.Name,self.Age,self.Sex,\'上山去砍柴\'）
        print (self.Name,self.Age,self.Sex,\'开车去东北\'）
        print (self.Name,self.Age,self.Sex,\'最爱大保健\'）
P1 = Person(\'小明\',\'10岁\',\'男\')
P2 = Person(\'老李\',\'90岁\',\'男\')
P1.action()
P2.action()

函数式编程：

def action(name,age,sex):
    print ("{0},{1}岁，上山去砍柴".format(\'name\',\'age\',\'sex\'))
    print ("{0},{1}岁，开车去东北".format(\'name\',\'age\',\'sex\'))
    print ("{0},{1}岁，最爱大保健".format(\'name\',\'age\',\'sex\'))

action(\'小明\',\'10岁\',\'男\')
action(\'老李\',\'90岁\',\'男\')

二，面向对象之对象的封装

面向对象编程：

Objext oriented Programming，简称OOP
程序开发的一种方法
一种在程序中包含各种独立而又互相调用的对象的思想
每一个对象都能接数据，处理数据，并将数据传达给其他对象

封装性：

将某些东西包装盒隐藏起来，让外界无法直接使用，只能通过某些特定的方式才能访问
被封装的特性只能通过特定的行为去访问
优点：数据独立性、具有隐藏性和安全性、易于维护

示例：

    class Plane:        #将Plane的特征和行为包装起来
        pCount = 0      #需要先创建对象，再访问属性或调用方法
        def __init__(self,name,category,carry):
            self.name = name
            self.category = category             #初始化属性
            self.carry = carry
            Plane.pCount += 1
    p1 = plane(\'平安\',\'播音777\',380)            #创建对象p1
    print （\'已生产\',Plane.pCount,\'架飞机\'）
    print （\'飞机名称：{0} 型号：{1} 载客量：{2}\'.format(p1.name,p1.category,p1.carry)）
    p1.name = \'魔鬼\'
    p1.category = \'直升飞机\'
    p1.carry = -40                              #修改对象p1的名称、型号、载客量
    print (\'飞机名称：{0} 型号：{1} 载客量：{2}\'.format(p1.name,p1.category,p1carry))

数据隐藏：

解释器对下划线有特殊的解释
名称前单下划线：
（1）以"_"为名称前缀的属性、方法应该视为API中非公开的部分
（2）不能用"from module import" 导入
名称前双"__"作为对象属性名称的前缀，外界将无法直接查看和修改该属性
如果类对象的属性或方法需要与外界共享，应避免使用下划线作为其名称的前缀

问：如何为私有属性赋值？

答：通过方法可以为私有属性赋值？

示例：为私有属性赋值

class Plane:
    pCount = 0
    def__init__(self,__name,__category,__carry):
        self.__name = __name
        self.__category = __category
        self.__carry = __carry
        Plane.pCount += 1
    def setCarry(self,__carry):   
        if __carry > 0 :
            self.__carry = __carry
        else:
            print ("载客量的数值不对"，__carry)
    def getCarry(self):     #获取私有属性的值
        return self.__carry
p1 = Plane("平安","播音777",380)
print("已生产"，Plane.pCount,"架飞机")
p1.setCarry(-40)      #将-40赋给carry属性
carryNum = p1.getCarry()
print("飞机载客量是：",carryNum)
p1.setcarry(240)    #将240赋给carry属性
carryNum = p1.getCarry()
print("飞机载客量是",carryNum)

三，面向对象之对象的继承

单继承：一个类只有一个直接父类
多继承：一个类有多个直接父类（py2.7x版本示意图）
多继承：一个类有多个直接父类（py3.x版本示意图）

（1）对象的单继承

继承性：

使用已存在的类定义创建新的类
新类的定义中可以增加新的属性和方法
如果B类继承A类，那么B类对象便具有A类的一切属性和方法
称A类为基类，或父类，或超类
称B类为A的派生类或子类
单继承：一个类只有一个直接父类
语法

class 子类（父类）：
\'\'\'类文档字符串\'\'\'
def init(self,参数列表1）：
父类.init(self,参数列表2）：
... ...
子类的新增类成员
参数列表1中包含有父类和子类的属性
参数列表2中只包含父类的属性
实现步骤：

示例：实现单继承

Plane类派生出军用飞机类和民用飞机类
分析：
（1）将Plane作为父类，共享属性和方法
（2）由Plane类派生出2个子类：军用飞机、民用飞机
（3）在继承Plane类成员后，2个子类分别新增了自身的属性和方法

Plane类派生出军用飞机类和民用飞机类：父类（Plane类）定义

 class Plane:
     pCount = 0
     def __init__(self,__name,__category):
         self.name = __name           #名称    共有属性
         self.__category = __category   #型号   
         Plane.pCount += 1
     def showPlaneinfo(self):      #共有方法
         print("飞机名称：{0} 类型：{1}".format(self.__name,self.__category))

Plane类派生出军用飞机类和民用飞机类：子类（AviomPlane类）定义

 class AvionPlane(Plane):   #继承父类
     def __init__(self,__name,__category,__gun):    #子类构造方法
         Plane.___init__(self,__name,__category)  #调用父类构造方法
         self.__gun = __gun       #可携带的枪炮数 ,添加特有属性
     def setCarry(self,__gun):
         if __gun > 0 :
             self.__gun = __gun
         else:
             print(\'携带的枪炮数值不对\',__gun)    #添加特有方法
     def getCarry(self):
         return self.__gun
     def showAvioninfo(self):
         print (\'携带的枪炮数量：{0}\'.format(self.gun))

Plane类派生出军用飞机类和民用飞机类

 p1 = AvionPlane(\'凯旋\',\'歼10\',6)   #创建AvionPlane类对象p1
 print（\'已生产\'，p1.pCount，\'架飞机\'）
 p1.showPlaneinfo()           #调用Plane类方法
 p1.showAvioninfo()           #调用AvionPlane类方法
 p2 = AvionPlane(\'平安\',\'播音777\',240)
 print（\'已生产\',p2.Pcount,\'架飞机\'）
 p2.showPlaneinfo()                 #创建AvionPlane类对象p2
 p2.showCivillnfo()                  #调用Plane类方法调用AvionPlane类方法

方法的重写（Override）

假设父类和子类中都有show（）方法，那么调用执行子类show（）方法的结果是什么？

 class Plane:
     pCount = 0      #生产的飞机数量
     def __init__(self,__name,__category):
         self.name = __name           #名称    
         self.__category = __category   #型号   
         Plane.pCount += 1
     def show(self):          #父类show（）方法
         print("飞机名称：{0} 类型：{1}".format(self.__name,self.__category))
         
 class CivilPlane(Plane):   #继承父类
     def __init__(self,__name,__category,__gun):   
         Plane.__init__(self.__name,__category)
         self.__carry = carry           #载客量
     def show(self):                    #重写父类show（）方法
         print (\'携带的枪炮数量：{0}\'.format(self.gun))
     
     p = CivilPlane("平安","播音777",240)
     print("已生产",p.pCount,"架飞机")        #只调用执行CivilPlane类的show（）方法
     p.show()

一，面向对象基础

（1）面向对象概述

（2）面向对象编程和函数式编程对比

调用（对象，类名）

通过对象去执行方法

（3）面向对象中对象和类的关系

（4）面向对象之构造方法

（5）面向对象之应用场景实例

面向对象编程：

函数式编程：

二，面向对象之对象的封装

面向对象编程：

封装性：

示例：

数据隐藏：

问：如何为私有属性赋值？

答：通过方法可以为私有属性赋值？

示例：为私有属性赋值

三，面向对象之对象的继承

（1）对象的单继承

继承性：

示例：实现单继承

方法的重写（Override）