从零开始学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()
posted @ 2016-12-01 16:32  陈思齐  阅读(820)  评论(0)  编辑  收藏  举报