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

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

---

一，面向对象基础

（1）面向对象概述

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

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

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

1. 函数
   
   def mail(email,message):
   
   print('去发吧')
   
   return True
   
   mail("chensiqi@126.com","好人")

2. 面向对象：类和对象
   
   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()