zoukankan      html  css  js  c++  java
  • 面向对象的程序设计

    • 一 面向对象的程序设计的由来
    • 二 什么是面向对象的程序设计及为什么要有它
    • 三 类和对象
    • 3.1 类相关知识
    • 3.2 对象相关知识
    • 3.3 对象之间的交互
    • 3.4 类名称空间与对象/实例名称空间
    • 3.5 小结
    • 四 继承与派生
    • 4.1 什么是继承
    • 4.2 继承与抽象(先抽象再继承)
    • 4.3 继承与重用性
    • 4.4 组合与重用性
    • 4.5 接口与归一化设计
    • 4.6 抽象类
    • 4.7 继承实现的原理(继承顺序)
    • 4.8 子类中调用父类方法
    • 五 多态
    • 六 封装
    • 6.1 要封装什么
    • 6.2 为什么要封装
    • 6.3 封装分为两个层面
    • 6.4 封装与扩展性
    • 八 面向对象的软件开发
    •  
    • 六 静态属性、类方法、静态方法
    • 8.2 多态
    • 九 小白容易犯的错误
    • 十 python中关于OOP的常用术语

    一 面向对象的程序设计的由来

    见概述:http://www.cnblogs.com/linhaifeng/articles/6428835.html

    二 什么是面向对象的程序设计及为什么要有它

    面向过程的程序设计的核心是过程,过程即解决问题的步骤,面向过程的设计就好比精心设计好一条流水线,考虑周全什么时候处理什么东西。

    优点是:极大的降低了程序的复杂度

    缺点是:一套流水线或者流程就是用来解决一个问题,生产汽水的流水线无法生产汽车,即便是能,也得是大改,改一个组件,牵一发而动全身。

    应用场景:一旦完成基本很少改变的场景,著名的例子有Linux內核,git,以及Apache HTTP Server等。

    面向对象的程序设计的核心是对象,要理解对象为何物,必须把自己当成上帝,上帝眼里世间存在的万物皆为对象,不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记,如来要解决的问题是把经书传给东土大唐,如来想了想解决这个问题需要四个人:唐僧,沙和尚,猪八戒,孙悟空,每个人都有各自的特征和技能(这就是对象的概念,特征和技能分别对应对象的数据属性和方法属性),然而这并不好玩,于是如来又安排了一群妖魔鬼怪,为了防止师徒四人在取经路上被搞死,又安排了一群神仙保驾护航,这些都是对象。然后取经开始,师徒四人与妖魔鬼怪神仙交互着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取。

    面向对象的程序设计的

    优点是:解决了程序的扩展性。对某一个对象单独修改,会立刻反映到整个体系中,如对游戏中一个人物参数的特征和技能修改都很容易。

    缺点:可控性差,无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果,面向对象的程序一旦开始就由对象之间的交互解决问题,即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现,一刀砍死3个人,这个游戏就失去平衡。

    应用场景:需求经常变化的软件,一般需求的变化都集中在用户层,互联网应用,企业内部软件,游戏等都是面向对象的程序设计大显身手的好地方

    面向对象的程序设计并不是全部。对于一个软件质量来说,面向对象的程序设计只是用来解决扩展性。

    三 类和对象

    提示:python的class术语与c++有一定区别,与 Modula-3更像。

    python中一切皆为对象,且python3统一了类与类型的概念,类型就是类,所以,不管你信不信,你已经使用了很长时间的类了

    1 >>> dict #类型dict就是类dict
    2 <class 'dict'>
    3 >>> d=dict(name='egon') #实例化
    4 >>> d.pop('name') #向d发一条消息,执行d的方法pop
    5 'egon'

    基于面向对象设计一个款游戏:英雄联盟,每个玩家选一个英雄,每个英雄都有自己的特征和和技能,特征即数据属性,技能即方法属性,特征与技能的结合体就一个对象。

    从一组对象中提取相似的部分就是,类也是特征与技能的结合体,特征即数据并且是所有对象共享的数据,技能即函数属性并且是所有对象共享的函数属性。

    garen_hero.Q()称为向garen_hero这个对象发送了一条消息,让他去执行Q这个函数,完成一个功能,类似的有:

    garen_hero.W()

    garen_hero.E()

    garen_hero.R()

    一个英雄可以攻击另外一个英雄,这就是对象之间的交互

    garen_hero.attack(Riven)

    3.1 类相关知识

    3.1.1 初识类

    在python中声明函数与声明类很相似

    声明函数

    1 def functionName(args):
    2      '函数文档字符串'
    3       函数体 

    声明类

    复制代码
     1 '''
     2 class 类名:
     3     '类的文档字符串'
     4     类体
     5 '''
     6 
     7 #我们创建一个类
     8 class Data:
     9     pass 
    复制代码
    大前提:
    1.只有在python2中才分新式类和经典类,python3中统一都是新式类
    2.新式类和经典类声明的最大不同在于,所有新式类必须继承至少一个父类
    3.所有类甭管是否显式声明父类,都有一个默认继承object父类(讲继承时会讲,先记住)
    在python2中的区分
    经典类:
    class 类名:
        pass
    
    经典类:
    class 类名(父类):
        pass
    
    在python3中,上述两种定义方式全都是新式类
    经典类与新式类

    在本节开头介绍得出结论,类是数据与函数的结合,二者称为类的属性

    class Garen:        #定义英雄盖伦的类,不同的玩家可以用它实例出自己英雄;
        camp='Demacia'  #所有玩家的英雄(盖伦)的阵营都是Demacia;
        def attack(self,enemy):   #普通攻击技能,enemy是敌人;
            enemy.life_value-=self.aggressivity #根据自己的攻击力,攻击敌人就减掉敌人的生命值。

    3.1.2 类有两种作用:属性引用和实例化

    3.1.2.1 属性引用(类名.属性)

    >>> Garen.camp #引用类的数据属性,该属性与所有对象/实例共享
    'Demacia'
    >>> Garen.attack #引用类的函数属性,该属性也共享
    <function Garen.attack at 0x101356510>
    >>> Garen.name='Garen' #增加属性
    >>> del Garen.name #删除属性

    3.1.2.2 实例化(__init__与self)

    类名加括号就是实例化,会自动触发__init__函数的运行,可以用它来为每个实例定制自己的特征

    复制代码
    class Garen:        #定义英雄盖伦的类,不同的玩家可以用它实例出自己英雄;
        camp='Demacia'  #所有玩家的英雄(盖伦)的阵营都是Demacia;
        def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...;
            self.nickname=nickname  #为自己的盖伦起个别名;
            self.aggressivity=aggressivity #英雄都有自己的攻击力;
            self.life_value=life_value #英雄都有自己的生命值;
        def attack(self,enemy):   #普通攻击技能,enemy是敌人;
            enemy.life_value-=self.aggressivity #根据自己的攻击力,攻击敌人就减掉敌人的生命值。
    复制代码

    实例化:类名+括号

    >>> g1=Garen('草丛伦') #就是在执行Garen.__init__(g1,'草丛伦'),然后执行__init__内的代码g1.nickname=‘草丛伦’等

    self的作用是在实例化时自动将对象/实例本身传给__init__的第一个参数,self可以是任意名字,但是瞎几把写别人就看不懂了。

    这种自动传递的机制还体现在g1.attack的调用上,后续会介绍。

    一:我们定义的类的属性到底存到哪里了?有两种方式查看
    dir(类名):查出的是一个名字列表
    类名.__dict__:查出的是一个字典,key为属性名,value为属性值
    
    二:特殊的类属性
    类名.__name__# 类的名字(字符串)
    类名.__doc__# 类的文档字符串
    类名.__base__# 类的第一个父类(在讲继承时会讲)
    类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
    类名.__dict__# 类的字典属性
    类名.__module__# 类定义所在的模块
    类名.__class__# 实例对应的类(仅新式类中)
    类属性的补充

    3.2 对象相关知识

    对象是关于类而实际存在的一个例子,即实例

    >>> g1=Garen('草丛伦') #类实例化得到g1这个实例,基于该实例我们讲解实例相关知识

    3.2.1 对象/实例只有一种作用:属性引用  

    复制代码
    #对象/实例本身其实只有数据属性
    >>> g1.nickname
    '草丛伦'
    >>> g1.aggressivity
    58
    >>> g1.life_value
    455
    '''
    查看实例属性
    同样是dir和内置__dict__两种方式
    特殊实例属性
    __class__
    __dict__
    ....
    '''
    复制代码

    对象/实例本身只有数据属性,但是python的class机制会将类的函数绑定到对象上,称为对象的方法,或者叫绑定方法

    >>> g1.attack #对象的绑定方法
    <bound method Garen.attack of <__main__.Garen object at 0x101348dd8>>
    
    >>> Garen.attack #对象的绑定方法attack本质就是调用类的函数attack的功能,二者是一种绑定关系
    <function Garen.attack at 0x101356620>

    对象的绑定方法的特别之处在于:obj.func()会把obj传给func的第一个参数。

    3.3 对象之间的交互

    我们可以仿照garen类再创建一个Riven类

    复制代码
    class Riven:
        camp='Noxus'  #所有玩家的英雄(锐雯)的阵营都是Noxus;
        def __init__(self,nickname,aggressivity=54,life_value=414): #英雄的初始攻击力54;
            self.nickname=nickname  #为自己的锐雯起个别名;
            self.aggressivity=aggressivity #英雄都有自己的攻击力;
            self.life_value=life_value #英雄都有自己的生命值;
        def attack(self,enemy):   #普通攻击技能,enemy是敌人;
            enemy.life_value-=self.aggressivity #根据自己的攻击力,攻击敌人就减掉敌人的生命值。 
    复制代码

    实例出一个Riven来

    >>> r1=Riven('锐雯雯')

    交互:锐雯雯攻击草丛伦,反之一样

    >>> g1.life_value
    455
    >>> r1.attack(g1)
    >>> g1.life_value
    401 

    3.4 类名称空间与对象/实例名称空间

    创建一个类就会创建一个类的名称空间,用来存储类中定义的所有名字,这些名字称为类的属性

    而类有两种属性:数据属性和函数属性

    其中类的数据属性是共享给所有对象的

    >>> id(r1.camp) #本质就是在引用类的camp属性,二者id一样
    4315241024
    >>> id(Riven.camp)
    4315241024

    而类的函数属性是绑定到所有对象的:

    复制代码
    >>> id(r1.attack) 
    4302501512
    >>> id(Riven.attack)
    4315244200
    
    '''
    r1.attack就是在执行Riven.attack的功能,python的class机制会将Riven的函数属性attack绑定给r1,r1相当于拿到了一个指针,指向Riven类的attack功能
    
    除此之外r1.attack()会将r1传给attack的第一个参数
    '''
    复制代码

    创建一个对象/实例就会创建一个对象/实例的名称空间,存放对象/实例的名字,称为对象/实例的属性

    在obj.name会先从obj自己的名称空间里找name,找不到则去类中找,类也找不到就找父类...最后都找不到就抛出异常 

    3.5 小结

    定义锐雯类:

    复制代码
    class Riven:
        camp='Noxus'
        def __init__(self,nickname,
                     aggressivity=54,
                     life_value=414,
                     money=1001,
                     armor=3):
            self.nickname=nickname
            self.aggressivity=aggressivity
            self.life_value=life_value
            self.money=money
            self.armor=armor
        def attack(self,enemy):
            damage_value=self.aggressivity-enemy.armor
            enemy.life_value-=damage_value
    复制代码

    定义盖文类:

    复制代码
    class Garen:
        camp='Demacia'
        def __init__(self,nickname,
                     aggressivity=58,
                     life_value=455,
                     money=100,
                     armor=10):
            self.nickname=nickname
            self.aggressivity=aggressivity
            self.life_value=life_value
            self.money=money
            self.armor=armor
        def attack(self,enemy):
            damage_value=self.aggressivity-enemy.armor
            enemy.life_value-=damage_value
    复制代码

    定义装备:

    复制代码
    class BlackCleaver:
        def __init__(self,price=475,aggrev=9,life_value=100):
            self.price=price
            self.aggrev=aggrev
            self.life_value=life_value
        def update(self,obj):
            obj.money-=self.price #减钱
            obj.aggressivity+=self.aggrev #加攻击
            obj.life_value+=self.life_value #加生命值
        def fire(self,obj): #这是该装备的主动技能,喷火,烧死对方
            obj.life_value-=1000 #假设火烧的攻击力是1000
    复制代码

    测试交互

    复制代码
    r1=Riven('草丛伦')
    g1=Garen('盖文')
    b1=BlackCleaver()
    
    print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲
    
    if r1.money > b1.price:
        r1.b1=b1
        b1.update(r1)
    
    
    print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲
    
    print(g1.life_value)
    r1.attack(g1) #普通攻击
    print(g1.life_value)
    r1.b1.fire(g1) #用装备攻击
    print(g1.life_value) #g1的生命值小于0就死了 
    复制代码

    按照这种思路一点一点的设计类和对象,最终你完全可以实现一个对战类游戏。

    四 继承与派生

    4.1 什么是继承

    继承是一种创建新的类的方式,在python中,新建的类可以继承自一个或者多个父类,原始类称为基类或超类,新建的类称为派生类或子类。

    python中类的继承分为:单继承和多继承

    复制代码
    class ParentClass1: #定义父类
        pass
    
    class ParentClass2: #定义父类
        pass
    
    class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass
        pass
    
    class SubClass2(ParentClass1,ParentClass2): #python支持多继承,用逗号分隔开多个继承的类
        pass
    复制代码

    查看继承

    >>> SubClass1.__bases__
    (<class '__main__.ParentClass1'>,)
    >>> SubClass2.__bases__
    (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

    提示:如果没有指定基类,python的类会默认继承object类,object是所有python类的基类,它提供了一些常见方法(如__str__)的实现。

    >>> ParentClass1.__bases__
    (<class 'object'>,)
    >>> ParentClass2.__bases__
    (<class 'object'>,)

    4.2 继承与抽象(先抽象再继承)

    抽象即抽取类似或者说比较像的部分。

    抽象分成两个层次: 

    1.将奥巴马和梅西这俩对象比较像的部分抽取成类; 

    2.将人,猪,狗这三个类比较像的部分抽取成父类。

    抽象最主要的作用是划分类别(可以隔离关注点,降低复杂度)

     

    继承:是基于抽象的结果,通过编程语言去实现它,肯定是先经历抽象这个过程,才能通过继承的方式去表达出抽象的结构。

    抽象只是分析和设计的过程中,一个动作或者说一种技巧,通过抽象可以得到类

    4.3 继承与重用性

    ==========================第一部分
    例如
    
      猫可以:喵喵叫、吃、喝、拉、撒
    
      狗可以:汪汪叫、吃、喝、拉、撒
    
    如果我们要分别为猫和狗创建一个类,那么就需要为 猫 和 狗 实现他们所有的功能,伪代码如下:
     
    
    #猫和狗有大量相同的内容
    class 猫:
    
        def 喵喵叫(self):
            print '喵喵叫'
    
        def 吃(self):
            # do something
    
        def 喝(self):
            # do something
    
        def 拉(self):
            # do something
    
        def 撒(self):
            # do something
    
    class 狗:
    
        def 汪汪叫(self):
            print '喵喵叫'
    
        def 吃(self):
            # do something
    
        def 喝(self):
            # do something
    
        def 拉(self):
            # do something
    
        def 撒(self):
            # do something
    
    
    
    ==========================第二部分
    上述代码不难看出,吃、喝、拉、撒是猫和狗都具有的功能,而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想,如下实现:
    
      动物:吃、喝、拉、撒
    
         猫:喵喵叫(猫继承动物的功能)
    
         狗:汪汪叫(狗继承动物的功能)
    
    伪代码如下:
    class 动物:
    
        def 吃(self):
            # do something
    
        def 喝(self):
            # do something
    
        def 拉(self):
            # do something
    
        def 撒(self):
            # do something
    
    # 在类后面括号中写入另外一个类名,表示当前类继承另外一个类
    class 猫(动物):
    
        def 喵喵叫(self):
            print '喵喵叫'
            
    # 在类后面括号中写入另外一个类名,表示当前类继承另外一个类
    class 狗(动物):
    
        def 汪汪叫(self):
            print '喵喵叫'
    
    
    
    
    ==========================第三部分
    #继承的代码实现
    class Animal:
    
        def eat(self):
            print("%s 吃 " %self.name)
    
        def drink(self):
            print ("%s 喝 " %self.name)
    
        def shit(self):
            print ("%s 拉 " %self.name)
    
        def pee(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('小白家的小黑猫')
    c1.eat()
    
    c2 = Cat('小黑的小白猫')
    c2.drink()
    
    d1 = Dog('胖子家的小瘦狗')
    d1.eat()
    使用继承来重用代码比较好的例子

     在开发程序的过程中,如果我们定义了一个类A,然后又想新建立另外一个类B,但是类B的大部分内容与类A的相同时

    我们不可能从头开始写一个类B,这就用到了类的继承的概念。

    通过继承的方式新建类B,让B继承A,B会‘遗传’A的所有属性(数据属性和函数属性),实现代码重用

    复制代码
    class Hero:
        def __init__(self,nickname,aggressivity,life_value):
            self.nickname=nickname
            self.aggressivity=aggressivity
            self.life_value=life_value
    
        def move_forward(self):
            print('%s move forward' %self.nickname)
    
        def move_backward(self):
            print('%s move backward' %self.nickname)
    
        def move_left(self):
            print('%s move forward' %self.nickname)
    
        def move_right(self):
            print('%s move forward' %self.nickname)
    
        def attack(self,enemy):
            enemy.life_value-=self.aggressivity
    class Garen(Hero):
        pass
    
    class Riven(Hero):
        pass
    
    g1=Garen('草丛伦',100,300)
    r1=Riven('锐雯雯',57,200)
    
    print(g1.life_value)
    r1.attack(g1)
    print(g1.life_value)
    
    '''
    运行结果
    300
    243
    '''
    复制代码

    提示:用已经有的类建立一个新的类,这样就重用了已经有的软件中的一部分设置大部分,大大生了编程工作量,这就是常说的软件重用,不仅可以重用自己的类,也可以继承别人的,比如标准库,来定制新的数据类型,这样就是大大缩短了软件开发周期,对大型软件开发来说,意义重大.

    注意:像g1.life_value之类的属性引用,会先从实例中找life_value然后去类中找,然后再去父类中找...直到最顶级的父类。

    当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性(不会影响到父类),需要注意的是,一旦重新定义了自己的属性且与父类重名,那么调用新增的属性时,就以自己为准了。

    class Riven(Hero):
        camp='Noxus'
        def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
            print('from riven')
        def fly(self): #在自己这里定义新的
            print('%s is flying' %self.nickname)

    在子类中,新建的重名的函数属性,在编辑函数内功能的时候,有可能需要重用父类中重名的那个函数功能,应该是用调用普通函数的方式,即:类名.func(),此时就与调用普通函数无异了,因此即便是self参数也要为其传值

    复制代码
    class Riven(Hero):
        camp='Noxus'
        def __init__(self,nickname,aggressivity,life_value,skin):
            Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能
            self.skin=skin #新属性
        def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
            Hero.attack(self,enemy) #调用功能
            print('from riven')
        def fly(self): #在自己这里定义新的
            print('%s is flying' %self.nickname)
    
    r1=Riven('锐雯雯',57,200,'比基尼')
    r1.fly()
    print(r1.skin)
    
    '''
    运行结果
    锐雯雯 is flying
    比基尼
    
    '''
    复制代码

    4.4 组合与重用性

    软件重用的重要方式除了继承之外还有另外一种方式,即:组合

    组合指的是,在一个类中以另外一个类的对象作为数据属性,称为类的组合

    其实早在3.5小节中我们就体会了组合的用法,比如一个英雄有一个装备

    复制代码
    >>> class Equip: #武器装备类
    ...     def fire(self):
    ...         print('release Fire skill')
    ... 
    >>> class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
    ...     camp='Noxus'
    ...     def __init__(self,nickname):
    ...         self.nickname=nickname
    ...         self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
    ... 
    >>> r1=Riven('锐雯雯')
    >>> r1.equip.fire() #可以使用组合的类产生的对象所持有的方法
    release Fire skill
    复制代码

    组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同,

    1.继承的方式

    通过继承建立了派生类与基类之间的关系,它是一种'是'的关系,比如白马是马,人是动物。

    当类之间有很多相同的功能,提取这些共同的功能做成基类,用继承比较好,比如教授是老师

    复制代码
    >>> class Teacher:
    ...     def __init__(self,name,gender):
    ...         self.name=name
    ...         self.gender=gender
    ...     def teach(self):
    ...         print('teaching')
    ... 
    >>> 
    >>> class Professor(Teacher):
    ...     pass
    ... 
    >>> p1=Professor('egon','male')
    >>> p1.teach()
    teaching
    复制代码

    2.组合的方式

    用组合的方式建立了类与组合的类之间的关系,它是一种‘有’的关系,比如教授有生日,教授教python课程

    复制代码
    class BirthDate:
        def __init__(self,year,month,day):
            self.year=year
            self.month=month
            self.day=day
    
    class Couse:
        def __init__(self,name,price,period):
            self.name=name
            self.price=price
            self.period=period
    
    class Teacher:
        def __init__(self,name,gender):
            self.name=name
            self.gender=gender
        def teach(self):
            print('teaching')
    class Professor(Teacher):
        def __init__(self,name,gender,birth,course):
            Teacher.__init__(self,name,gender)
            self.birth=birth
            self.course=course
    
    p1=Professor('egon','male',
                 BirthDate('1995','1','27'),
                 Couse('python','28000','4 months'))
    
    print(p1.birth.year,p1.birth.month,p1.birth.day)
    print(p1.course.name,p1.course.price,p1.course.period)
    '''
    运行结果:
    1995 1 27
    python 28000 4 months
    '''
    复制代码

    当类之间有显著不同,并且较小的类是较大的类所需要的组件时,用组合比较好

    4.5 接口与归一化设计

    1.什么是接口

    =================第一部分:Java 语言中的接口很好的展现了接口的含义: IAnimal.java
    /*
    * Java的Interface很好的体现了我们前面分析的接口的特征:
    * 1)是一组功能的集合,而不是一个功能
    * 2)接口的功能用于交互,所有的功能都是public,即别的对象可操作
    * 3)接口只定义函数,但不涉及函数实现
    * 4)这些功能是相关的,都是动物相关的功能,但光合作用就不适宜放到IAnimal里面了 */
    
    package com.oo.demo;
    public interface IAnimal {
        public void eat();
        public void run(); 
        public void sleep(); 
        public void speak();
    }
    
    =================第二部分:Pig.java:猪”的类设计,实现了IAnnimal接口 
    package com.oo.demo;
    public class Pig implements IAnimal{ //如下每个函数都需要详细实现
        public void eat(){
            System.out.println("Pig like to eat grass");
        }
    
        public void run(){
            System.out.println("Pig run: front legs, back legs");
        }
    
        public void sleep(){
            System.out.println("Pig sleep 16 hours every day");
        }
    
        public void speak(){
            System.out.println("Pig can not speak"); }
    }
    
    =================第三部分:Person2.java
    /*
    *实现了IAnimal的“人”,有几点说明一下: 
    * 1)同样都实现了IAnimal的接口,但“人”和“猪”的实现不一样,为了避免太多代码导致影响阅读,这里的代码简化成一行,但输出的内容不一样,实际项目中同一接口的同一功能点,不同的类实现完全不一样
    * 2)这里同样是“人”这个类,但和前面介绍类时给的类“Person”完全不一样,这是因为同样的逻辑概念,在不同的应用场景下,具备的属性和功能是完全不一样的 */
    
    package com.oo.demo;
    public class Person2 implements IAnimal { 
        public void eat(){
            System.out.println("Person like to eat meat");
        }
    
        public void run(){
            System.out.println("Person run: left leg, right leg");
        }
    
        public void sleep(){
            System.out.println("Person sleep 8 hours every dat"); 
        }
    
        public void speak(){
            System.out.println("Hellow world, I am a person");
        } 
    }
    
    =================第四部分:Tester03.java
    package com.oo.demo;
    
    public class Tester03 {
        public static void main(String[] args) {
            System.out.println("===This is a person==="); 
            IAnimal person = new Person2();
            person.eat();
            person.run();
            person.sleep();
            person.speak();
            
            System.out.println("
    ===This is a pig===");
            IAnimal pig = new Pig();
            pig.eat();
            pig.run();
            pig.sleep();
            pig.speak();
        } 
    }
    java中的interface

    继承有两种用途:

    一:继承基类的方法,并且做出自己的改变或者扩展(代码重用)

    二:声明某个子类兼容于某基类,定义一个接口类Interface,接口类中定义了一些接口名(就是函数名)且并未实现接口的功能,子类继承接口类,并且实现接口中的功能

    复制代码
    class Interface:#定义接口Interface类来模仿接口的概念,python中压根就没有interface关键字来定义一个接口。
        def read(self): #定接口函数read
            pass
    
        def write(self): #定义接口函数write
            pass
    
    
    class Txt(Interface): #文本,具体实现read和write
        def read(self):
            print('文本数据的读取方法')
    
        def write(self):
            print('文本数据的读取方法')
    
    class Sata(Interface): #磁盘,具体实现read和write
        def read(self):
            print('硬盘数据的读取方法')
    
        def write(self):
            print('硬盘数据的读取方法')
    
    class Process(All_file):
        def read(self):
            print('进程数据的读取方法')
    
        def write(self):
            print('进程数据的读取方法')
    复制代码

    实践中,继承的第一种含义意义并不很大,甚至常常是有害的。因为它使得子类与基类出现强耦合。

    继承的第二种含义非常重要。它又叫“接口继承”。
    接口继承实质上是要求“做出一个良好的抽象,这个抽象规定了一个兼容接口,使得外部调用者无需关心具体细节,可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上,叫做归一化。

    归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样,所有东西都可以当文件处理,不必关心它是内存、磁盘、网络还是屏幕(当然,对底层设计者,当然也可以区分出“字符设备”和“块设备”,然后做出针对性的设计:细致到什么程度,视需求而定)。

    在python中根本就没有一个叫做interface的关键字,上面的代码只是看起来像接口,其实并没有起到接口的作用,子类完全可以不用去实现接口 ,如果非要去模仿接口的概念,可以借助第三方模块:

    http://pypi.python.org/pypi/zope.interface

    twisted的twistedinternetinterface.py里使用zope.interface

    文档https://zopeinterface.readthedocs.io/en/latest/

    2. 为何要用接口

    接口提取了一群类共同的函数,可以把接口当做一个函数的集合。

    然后让子类去实现接口中的函数。

    这么做的意义在于归一化,什么叫归一化,就是只要是基于同一个接口实现的类,那么所有的这些类产生的对象在使用时,从用法上来说都一样。

    归一化,让使用者无需关心对象的类是什么,只需要的知道这些对象都具备某些功能就可以了,这极大地降低了使用者的使用难度。

    比如:我们定义一个动物接口,接口里定义了有跑、吃、呼吸等接口函数,这样老鼠的类去实现了该接口,松鼠的类也去实现了该接口,由二者分别产生一只老鼠和一只松鼠送到你面前,即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑,都会吃,都能呼吸。

    再比如:我们有一个汽车接口,里面定义了汽车所有的功能,然后由本田汽车的类,奥迪汽车的类,大众汽车的类,他们都实现了汽车接口,这样就好办了,大家只需要学会了怎么开汽车,那么无论是本田,还是奥迪,还是大众我们都会开了,开的时候根本无需关心我开的是哪一类车,操作手法(函数调用)都一样

    4.6 抽象类

    1 什么是抽象类

        与java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化

    2 为什么要有抽象类

        如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类是从一堆中抽取相同的内容而来的,内容包括数据属性和函数属性。

      比如我们有香蕉的类,有苹果的类,有桃子的类,从这些类抽取相同的内容就是水果这个抽象的类,你吃水果时,要么是吃一个具体的香蕉,要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。

        从设计角度去看,如果类是从现实对象抽象而来的,那么抽象类就是基于类抽象而来的。

      从实现角度来看,抽象类与普通类的不同之处在于:抽象类中只能有抽象方法(没有实现功能),该类不能被实例化,只能被继承,且子类必须实现抽象方法。这一点与接口有点类似,但其实是不同的,即将揭晓答案

    3. 在python中实现抽象类

    复制代码
    #_*_coding:utf-8_*_
    __author__ = 'Linhaifeng'
    #一切皆文件
    import abc #利用abc模块实现抽象类
    
    class All_file(metaclass=abc.ABCMeta):
        all_type='file'
        @abc.abstractmethod #定义抽象方法,无需实现功能
        def read(self):
            '子类必须定义读功能'
            pass
    
        @abc.abstractmethod #定义抽象方法,无需实现功能
        def write(self):
            '子类必须定义写功能'
            pass
    
    # class Txt(All_file):
    #     pass
    #
    # t1=Txt() #报错,子类没有定义抽象方法
    
    class Txt(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('文本数据的读取方法')
    
        def write(self):
            print('文本数据的读取方法')
    
    class Sata(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('硬盘数据的读取方法')
    
        def write(self):
            print('硬盘数据的读取方法')
    
    class Process(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('进程数据的读取方法')
    
        def write(self):
            print('进程数据的读取方法')
    
    wenbenwenjian=Txt()
    
    yingpanwenjian=Sata()
    
    jinchengwenjian=Process()
    
    #这样大家都是被归一化了,也就是一切皆文件的思想
    wenbenwenjian.read()
    yingpanwenjian.write()
    jinchengwenjian.read()
    
    print(wenbenwenjian.all_type)
    print(yingpanwenjian.all_type)
    print(jinchengwenjian.all_type)
    复制代码

    4. 抽象类与接口

    抽象类的本质还是类,指的是一组类的相似性,包括数据属性(如all_type)和函数属性(如read、write),而接口只强调函数属性的相似性。

    抽象类是一个介于类和接口直接的一个概念,同时具备类和接口的部分特性,可以用来实现归一化设计

    4.7 继承实现的原理(继承顺序)

    1 继承顺序

    class A(object):
        def test(self):
            print('from A')
    
    class B(A):
        def test(self):
            print('from B')
    
    class C(A):
        def test(self):
            print('from C')
    
    class D(B):
        def test(self):
            print('from D')
    
    class E(C):
        def test(self):
            print('from E')
    
    class F(D,E):
        # def test(self):
        #     print('from F')
        pass
    f1=F()
    f1.test()
    print(F.__mro__) #只有新式才有这个属性可以查看线性列表,经典类没有这个属性
    
    #新式类继承顺序:F->D->B->E->C->A
    #经典类继承顺序:F->D->B->A->E->C
    #python3中统一都是新式类
    #pyhon2中才分新式类与经典类
    继承顺序

    2 继承原理(python如何实现的继承)

    python到底是如何实现继承的,对于你定义的每一个类,python会计算出一个方法解析顺序(MRO)列表,这个MRO列表就是一个简单的所有基类的线性顺序列表,例如

    >>> F.mro() #等同于F.__mro__
    [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

    为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
    而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
    1.子类会先于父类被检查
    2.多个父类会根据它们在列表中的顺序被检查
    3.如果对下一个类存在两个合法的选择,选择第一个父类

    4.8 子类中调用父类方法

    子类继承了父类的方法,然后想进行修改,注意了是基于原有的基础上修改,那么就需要在子类中调用父类的方法

    方法一:父类名.父类方法()

    #_*_coding:utf-8_*_
    __author__ = 'Linhaifeng'
    
    class Vehicle: #定义交通工具类
         Country='China'
         def __init__(self,name,speed,load,power):
             self.name=name
             self.speed=speed
             self.load=load
             self.power=power
    
         def run(self):
             print('开动啦...')
    
    class Subway(Vehicle): #地铁
        def __init__(self,name,speed,load,power,line):
            Vehicle.__init__(self,name,speed,load,power)
            self.line=line
    
        def run(self):
            print('地铁%s号线欢迎您' %self.line)
            Vehicle.run(self)
    
    line13=Subway('中国地铁','180m/s','1000人/箱','',13)
    line13.run()
    View Code

    方法二:super()

    返回主页    
    吾日三洗吾身,洗头、洗脸、洗身体
    
        博客园
        首页
        新随笔
        联系
        订阅
        管理
    
    随笔 - 14  文章 - 24  评论 - 8
    第十篇 面向对象的程序设计
    
    阅读目录
    
        一 面向对象的程序设计的由来
        二 什么是面向对象的程序设计及为什么要有它
        三 类和对象
        3.1 类相关知识
        3.2 对象相关知识
        3.3 对象之间的交互
        3.4 类名称空间与对象/实例名称空间
        3.5 小结
        四 继承与派生
        4.1 什么是继承
        4.2 继承与抽象(先抽象再继承)
        4.3 继承与重用性
        4.4 组合与重用性
        4.5 接口与归一化设计
        4.6 抽象类
        4.7 继承实现的原理(继承顺序)
        4.8 子类中调用父类方法
        五 多态
        六 封装
        6.1 要封装什么
        6.2 为什么要封装
        6.3 封装分为两个层面
        6.4 封装与扩展性
        八 面向对象的软件开发
         
        六 静态属性、类方法、静态方法
        8.2 多态
        九 小白容易犯的错误
        十 python中关于OOP的常用术语
    
    回到顶部
    一 面向对象的程序设计的由来
    
    见概述:http://www.cnblogs.com/linhaifeng/articles/6428835.html
    回到顶部
    二 什么是面向对象的程序设计及为什么要有它
    
    面向过程的程序设计的核心是过程,过程即解决问题的步骤,面向过程的设计就好比精心设计好一条流水线,考虑周全什么时候处理什么东西。
    
    优点是:极大的降低了程序的复杂度
    
    缺点是:一套流水线或者流程就是用来解决一个问题,生产汽水的流水线无法生产汽车,即便是能,也得是大改,改一个组件,牵一发而动全身。
    
    应用场景:一旦完成基本很少改变的场景,著名的例子有Linux內核,git,以及Apache HTTP Server等。
    
     
    
    面向对象的程序设计的核心是对象,要理解对象为何物,必须把自己当成上帝,上帝眼里世间存在的万物皆为对象,不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记,如来要解决的问题是把经书传给东土大唐,如来想了想解决这个问题需要四个人:唐僧,沙和尚,猪八戒,孙悟空,每个人都有各自的特征和技能(这就是对象的概念,特征和技能分别对应对象的数据属性和方法属性),然而这并不好玩,于是如来又安排了一群妖魔鬼怪,为了防止师徒四人在取经路上被搞死,又安排了一群神仙保驾护航,这些都是对象。然后取经开始,师徒四人与妖魔鬼怪神仙交互着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取。
    
    面向对象的程序设计的
    
    优点是:解决了程序的扩展性。对某一个对象单独修改,会立刻反映到整个体系中,如对游戏中一个人物参数的特征和技能修改都很容易。
    
    缺点:可控性差,无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果,面向对象的程序一旦开始就由对象之间的交互解决问题,即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现,一刀砍死3个人,这个游戏就失去平衡。
    
    应用场景:需求经常变化的软件,一般需求的变化都集中在用户层,互联网应用,企业内部软件,游戏等都是面向对象的程序设计大显身手的好地方
    
    面向对象的程序设计并不是全部。对于一个软件质量来说,面向对象的程序设计只是用来解决扩展性。
    
    回到顶部
    三 类和对象
    
    提示:python的class术语与c++有一定区别,与 Modula-3更像。
    
    python中一切皆为对象,且python3统一了类与类型的概念,类型就是类,所以,不管你信不信,你已经使用了很长时间的类了
    
    1 >>> dict #类型dict就是类dict
    2 <class 'dict'>
    3 >>> d=dict(name='egon') #实例化
    4 >>> d.pop('name') #向d发一条消息,执行d的方法pop
    5 'egon'
    
     
    
    基于面向对象设计一个款游戏:英雄联盟,每个玩家选一个英雄,每个英雄都有自己的特征和和技能,特征即数据属性,技能即方法属性,特征与技能的结合体就一个对象。
    
    从一组对象中提取相似的部分就是类,类也是特征与技能的结合体,特征即数据并且是所有对象共享的数据,技能即函数属性并且是所有对象共享的函数属性。
    
    garen_hero.Q()称为向garen_hero这个对象发送了一条消息,让他去执行Q这个函数,完成一个功能,类似的有:
    
    garen_hero.W()
    
    garen_hero.E()
    
    garen_hero.R()
    
    一个英雄可以攻击另外一个英雄,这就是对象之间的交互
    
    garen_hero.attack(Riven)
    
    回到顶部
    3.1 类相关知识
    
    3.1.1 初识类
    
    在python中声明函数与声明类很相似
    
    声明函数
    
    1 def functionName(args):
    2      '函数文档字符串'
    3       函数体 
    
    声明类
    复制代码
    
     1 '''
     2 class 类名:
     3     '类的文档字符串'
     4     类体
     5 '''
     6 
     7 #我们创建一个类
     8 class Data:
     9     pass 
    
    复制代码
    按 Ctrl+C 复制代码
    按 Ctrl+C 复制代码
    
     在本节开头介绍得出结论,类是数据与函数的结合,二者称为类的属性
    
    class Garen:        #定义英雄盖伦的类,不同的玩家可以用它实例出自己英雄;
        camp='Demacia'  #所有玩家的英雄(盖伦)的阵营都是Demacia;
        def attack(self,enemy):   #普通攻击技能,enemy是敌人;
            enemy.life_value-=self.aggressivity #根据自己的攻击力,攻击敌人就减掉敌人的生命值。
    
    3.1.2 类有两种作用:属性引用和实例化
    
    3.1.2.1 属性引用(类名.属性)
    
    >>> Garen.camp #引用类的数据属性,该属性与所有对象/实例共享
    'Demacia'
    >>> Garen.attack #引用类的函数属性,该属性也共享
    <function Garen.attack at 0x101356510>
    >>> Garen.name='Garen' #增加属性
    >>> del Garen.name #删除属性
    
    3.1.2.2 实例化(__init__与self)
    
    类名加括号就是实例化,会自动触发__init__函数的运行,可以用它来为每个实例定制自己的特征
    复制代码
    
    class Garen:        #定义英雄盖伦的类,不同的玩家可以用它实例出自己英雄;
        camp='Demacia'  #所有玩家的英雄(盖伦)的阵营都是Demacia;
        def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...;
            self.nickname=nickname  #为自己的盖伦起个别名;
            self.aggressivity=aggressivity #英雄都有自己的攻击力;
            self.life_value=life_value #英雄都有自己的生命值;
        def attack(self,enemy):   #普通攻击技能,enemy是敌人;
            enemy.life_value-=self.aggressivity #根据自己的攻击力,攻击敌人就减掉敌人的生命值。
    
    复制代码
    
     
    
    实例化:类名+括号
    
    >>> g1=Garen('草丛伦') #就是在执行Garen.__init__(g1,'草丛伦'),然后执行__init__内的代码g1.nickname=‘草丛伦’等
    
     
    
    self的作用是在实例化时自动将对象/实例本身传给__init__的第一个参数,self可以是任意名字,但是瞎几把写别人就看不懂了。
    
    这种自动传递的机制还体现在g1.attack的调用上,后续会介绍。
    按 Ctrl+C 复制代码
    按 Ctrl+C 复制代码
    
     
    回到顶部
    3.2 对象相关知识
    
    对象是关于类而实际存在的一个例子,即实例
    
    >>> g1=Garen('草丛伦') #类实例化得到g1这个实例,基于该实例我们讲解实例相关知识
    
    3.2.1 对象/实例只有一种作用:属性引用  
    复制代码
    
    #对象/实例本身其实只有数据属性
    >>> g1.nickname
    '草丛伦'
    >>> g1.aggressivity
    58
    >>> g1.life_value
    455
    '''
    查看实例属性
    同样是dir和内置__dict__两种方式
    特殊实例属性
    __class__
    __dict__
    ....
    '''
    
    复制代码
    
     
    
    对象/实例本身只有数据属性,但是python的class机制会将类的函数绑定到对象上,称为对象的方法,或者叫绑定方法
    
    >>> g1.attack #对象的绑定方法
    <bound method Garen.attack of <__main__.Garen object at 0x101348dd8>>
    
    >>> Garen.attack #对象的绑定方法attack本质就是调用类的函数attack的功能,二者是一种绑定关系
    <function Garen.attack at 0x101356620>
    
    对象的绑定方法的特别之处在于:obj.func()会把obj传给func的第一个参数。
    回到顶部
    3.3 对象之间的交互
    
    我们可以仿照garen类再创建一个Riven类
    复制代码
    
    class Riven:
        camp='Noxus'  #所有玩家的英雄(锐雯)的阵营都是Noxus;
        def __init__(self,nickname,aggressivity=54,life_value=414): #英雄的初始攻击力54;
            self.nickname=nickname  #为自己的锐雯起个别名;
            self.aggressivity=aggressivity #英雄都有自己的攻击力;
            self.life_value=life_value #英雄都有自己的生命值;
        def attack(self,enemy):   #普通攻击技能,enemy是敌人;
            enemy.life_value-=self.aggressivity #根据自己的攻击力,攻击敌人就减掉敌人的生命值。 
    
    复制代码
    
    实例出一个Riven来
    
    >>> r1=Riven('锐雯雯')
    
    交互:锐雯雯攻击草丛伦,反之一样
    
    >>> g1.life_value
    455
    >>> r1.attack(g1)
    >>> g1.life_value
    401 
    
    回到顶部
    3.4 类名称空间与对象/实例名称空间
    
    创建一个类就会创建一个类的名称空间,用来存储类中定义的所有名字,这些名字称为类的属性
    
    而类有两种属性:数据属性和函数属性
    
    其中类的数据属性是共享给所有对象的
    
    >>> id(r1.camp) #本质就是在引用类的camp属性,二者id一样
    4315241024
    >>> id(Riven.camp)
    4315241024
    
     
    
    而类的函数属性是绑定到所有对象的:
    复制代码
    
    >>> id(r1.attack) 
    4302501512
    >>> id(Riven.attack)
    4315244200
    
    '''
    r1.attack就是在执行Riven.attack的功能,python的class机制会将Riven的函数属性attack绑定给r1,r1相当于拿到了一个指针,指向Riven类的attack功能
    
    除此之外r1.attack()会将r1传给attack的第一个参数
    '''
    
    复制代码
    
    创建一个对象/实例就会创建一个对象/实例的名称空间,存放对象/实例的名字,称为对象/实例的属性
    
    在obj.name会先从obj自己的名称空间里找name,找不到则去类中找,类也找不到就找父类...最后都找不到就抛出异常  
    回到顶部
    3.5 小结
    
    定义锐雯类:
    
    复制代码
    
    class Riven:
        camp='Noxus'
        def __init__(self,nickname,
                     aggressivity=54,
                     life_value=414,
                     money=1001,
                     armor=3):
            self.nickname=nickname
            self.aggressivity=aggressivity
            self.life_value=life_value
            self.money=money
            self.armor=armor
        def attack(self,enemy):
            damage_value=self.aggressivity-enemy.armor
            enemy.life_value-=damage_value
    
    复制代码
    
     
    
    定义盖文类:
    
    复制代码
    
    class Garen:
        camp='Demacia'
        def __init__(self,nickname,
                     aggressivity=58,
                     life_value=455,
                     money=100,
                     armor=10):
            self.nickname=nickname
            self.aggressivity=aggressivity
            self.life_value=life_value
            self.money=money
            self.armor=armor
        def attack(self,enemy):
            damage_value=self.aggressivity-enemy.armor
            enemy.life_value-=damage_value
    
    复制代码
    
     
    
    定义装备:
    
    复制代码
    
    class BlackCleaver:
        def __init__(self,price=475,aggrev=9,life_value=100):
            self.price=price
            self.aggrev=aggrev
            self.life_value=life_value
        def update(self,obj):
            obj.money-=self.price #减钱
            obj.aggressivity+=self.aggrev #加攻击
            obj.life_value+=self.life_value #加生命值
        def fire(self,obj): #这是该装备的主动技能,喷火,烧死对方
            obj.life_value-=1000 #假设火烧的攻击力是1000
    
    复制代码
    
     
    
    测试交互
    复制代码
    
    r1=Riven('草丛伦')
    g1=Garen('盖文')
    b1=BlackCleaver()
    
    print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲
    
    if r1.money > b1.price:
        r1.b1=b1
        b1.update(r1)
    
    
    print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲
    
    print(g1.life_value)
    r1.attack(g1) #普通攻击
    print(g1.life_value)
    r1.b1.fire(g1) #用装备攻击
    print(g1.life_value) #g1的生命值小于0就死了 
    
    复制代码
    
    按照这种思路一点一点的设计类和对象,最终你完全可以实现一个对战类游戏。
    回到顶部
    四 继承与派生
    回到顶部
    4.1 什么是继承
    
    继承是一种创建新的类的方式,在python中,新建的类可以继承自一个或者多个父类,原始类称为基类或超类,新建的类称为派生类或子类。
    
    python中类的继承分为:单继承和多继承
    复制代码
    
    class ParentClass1: #定义父类
        pass
    
    class ParentClass2: #定义父类
        pass
    
    class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass
        pass
    
    class SubClass2(ParentClass1,ParentClass2): #python支持多继承,用逗号分隔开多个继承的类
        pass
    
    复制代码
    
    查看继承
    
    >>> SubClass1.__bases__
    (<class '__main__.ParentClass1'>,)
    >>> SubClass2.__bases__
    (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
    
    提示:如果没有指定基类,python的类会默认继承object类,object是所有python类的基类,它提供了一些常见方法(如__str__)的实现。
    
    >>> ParentClass1.__bases__
    (<class 'object'>,)
    >>> ParentClass2.__bases__
    (<class 'object'>,)
    
    回到顶部
    4.2 继承与抽象(先抽象再继承)
    
    抽象即抽取类似或者说比较像的部分。
    
    抽象分成两个层次: 
    
    1.将奥巴马和梅西这俩对象比较像的部分抽取成类; 
    
    2.将人,猪,狗这三个类比较像的部分抽取成父类。
    
    抽象最主要的作用是划分类别(可以隔离关注点,降低复杂度)
    
     
    
    继承:是基于抽象的结果,通过编程语言去实现它,肯定是先经历抽象这个过程,才能通过继承的方式去表达出抽象的结构。
    
    抽象只是分析和设计的过程中,一个动作或者说一种技巧,通过抽象可以得到类
    
     
    回到顶部
    4.3 继承与重用性
    按 Ctrl+C 复制代码
    按 Ctrl+C 复制代码
    
     在开发程序的过程中,如果我们定义了一个类A,然后又想新建立另外一个类B,但是类B的大部分内容与类A的相同时
    
    我们不可能从头开始写一个类B,这就用到了类的继承的概念。
    
    通过继承的方式新建类B,让B继承A,B会‘遗传’A的所有属性(数据属性和函数属性),实现代码重用
    复制代码
    
    class Hero:
        def __init__(self,nickname,aggressivity,life_value):
            self.nickname=nickname
            self.aggressivity=aggressivity
            self.life_value=life_value
    
        def move_forward(self):
            print('%s move forward' %self.nickname)
    
        def move_backward(self):
            print('%s move backward' %self.nickname)
    
        def move_left(self):
            print('%s move forward' %self.nickname)
    
        def move_right(self):
            print('%s move forward' %self.nickname)
    
        def attack(self,enemy):
            enemy.life_value-=self.aggressivity
    class Garen(Hero):
        pass
    
    class Riven(Hero):
        pass
    
    g1=Garen('草丛伦',100,300)
    r1=Riven('锐雯雯',57,200)
    
    print(g1.life_value)
    r1.attack(g1)
    print(g1.life_value)
    
    '''
    运行结果
    300
    243
    '''
    
    复制代码
    
    提示:用已经有的类建立一个新的类,这样就重用了已经有的软件中的一部分设置大部分,大大生了编程工作量,这就是常说的软件重用,不仅可以重用自己的类,也可以继承别人的,比如标准库,来定制新的数据类型,这样就是大大缩短了软件开发周期,对大型软件开发来说,意义重大.
    
    注意:像g1.life_value之类的属性引用,会先从实例中找life_value然后去类中找,然后再去父类中找...直到最顶级的父类。
    
     
    
    当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性(不会影响到父类),需要注意的是,一旦重新定义了自己的属性且与父类重名,那么调用新增的属性时,就以自己为准了。
    
    class Riven(Hero):
        camp='Noxus'
        def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
            print('from riven')
        def fly(self): #在自己这里定义新的
            print('%s is flying' %self.nickname)
    
    在子类中,新建的重名的函数属性,在编辑函数内功能的时候,有可能需要重用父类中重名的那个函数功能,应该是用调用普通函数的方式,即:类名.func(),此时就与调用普通函数无异了,因此即便是self参数也要为其传值
    复制代码
    
    class Riven(Hero):
        camp='Noxus'
        def __init__(self,nickname,aggressivity,life_value,skin):
            Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能
            self.skin=skin #新属性
        def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
            Hero.attack(self,enemy) #调用功能
            print('from riven')
        def fly(self): #在自己这里定义新的
            print('%s is flying' %self.nickname)
    
    r1=Riven('锐雯雯',57,200,'比基尼')
    r1.fly()
    print(r1.skin)
    
    '''
    运行结果
    锐雯雯 is flying
    比基尼
    
    '''
    
    复制代码
    回到顶部
    4.4 组合与重用性
    
    软件重用的重要方式除了继承之外还有另外一种方式,即:组合
    
    组合指的是,在一个类中以另外一个类的对象作为数据属性,称为类的组合
    
    其实早在3.5小节中我们就体会了组合的用法,比如一个英雄有一个装备
    复制代码
    
    >>> class Equip: #武器装备类
    ...     def fire(self):
    ...         print('release Fire skill')
    ... 
    >>> class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
    ...     camp='Noxus'
    ...     def __init__(self,nickname):
    ...         self.nickname=nickname
    ...         self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
    ... 
    >>> r1=Riven('锐雯雯')
    >>> r1.equip.fire() #可以使用组合的类产生的对象所持有的方法
    release Fire skill
    
    复制代码
    
      
    
    组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同,
    
    1.继承的方式
    
    通过继承建立了派生类与基类之间的关系,它是一种''的关系,比如白马是马,人是动物。
    
    当类之间有很多相同的功能,提取这些共同的功能做成基类,用继承比较好,比如教授是老师
    复制代码
    
    >>> class Teacher:
    ...     def __init__(self,name,gender):
    ...         self.name=name
    ...         self.gender=gender
    ...     def teach(self):
    ...         print('teaching')
    ... 
    >>> 
    >>> class Professor(Teacher):
    ...     pass
    ... 
    >>> p1=Professor('egon','male')
    >>> p1.teach()
    teaching
    
    复制代码
    
     
    
    2.组合的方式
    
    用组合的方式建立了类与组合的类之间的关系,它是一种‘有’的关系,比如教授有生日,教授教python课程
    复制代码
    
    class BirthDate:
        def __init__(self,year,month,day):
            self.year=year
            self.month=month
            self.day=day
    
    class Couse:
        def __init__(self,name,price,period):
            self.name=name
            self.price=price
            self.period=period
    
    class Teacher:
        def __init__(self,name,gender):
            self.name=name
            self.gender=gender
        def teach(self):
            print('teaching')
    class Professor(Teacher):
        def __init__(self,name,gender,birth,course):
            Teacher.__init__(self,name,gender)
            self.birth=birth
            self.course=course
    
    p1=Professor('egon','male',
                 BirthDate('1995','1','27'),
                 Couse('python','28000','4 months'))
    
    print(p1.birth.year,p1.birth.month,p1.birth.day)
    print(p1.course.name,p1.course.price,p1.course.period)
    '''
    运行结果:
    1995 1 27
    python 28000 4 months
    '''
    
    复制代码
    
    当类之间有显著不同,并且较小的类是较大的类所需要的组件时,用组合比较好
    回到顶部
    4.5 接口与归一化设计
    
    1.什么是接口
    按 Ctrl+C 复制代码
    按 Ctrl+C 复制代码
    
    继承有两种用途:
    
    一:继承基类的方法,并且做出自己的改变或者扩展(代码重用)
    
    二:声明某个子类兼容于某基类,定义一个接口类Interface,接口类中定义了一些接口名(就是函数名)且并未实现接口的功能,子类继承接口类,并且实现接口中的功能
    复制代码
    
    class Interface:#定义接口Interface类来模仿接口的概念,python中压根就没有interface关键字来定义一个接口。
        def read(self): #定接口函数read
            pass
    
        def write(self): #定义接口函数write
            pass
    
    
    class Txt(Interface): #文本,具体实现read和write
        def read(self):
            print('文本数据的读取方法')
    
        def write(self):
            print('文本数据的读取方法')
    
    class Sata(Interface): #磁盘,具体实现read和write
        def read(self):
            print('硬盘数据的读取方法')
    
        def write(self):
            print('硬盘数据的读取方法')
    
    class Process(All_file):
        def read(self):
            print('进程数据的读取方法')
    
        def write(self):
            print('进程数据的读取方法')
    
    复制代码
    
    实践中,继承的第一种含义意义并不很大,甚至常常是有害的。因为它使得子类与基类出现强耦合。
    
    继承的第二种含义非常重要。它又叫“接口继承”。
    接口继承实质上是要求“做出一个良好的抽象,这个抽象规定了一个兼容接口,使得外部调用者无需关心具体细节,可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上,叫做归一化。
    
    归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样,所有东西都可以当文件处理,不必关心它是内存、磁盘、网络还是屏幕(当然,对底层设计者,当然也可以区分出“字符设备”和“块设备”,然后做出针对性的设计:细致到什么程度,视需求而定)。
    
     
    
    在python中根本就没有一个叫做interface的关键字,上面的代码只是看起来像接口,其实并没有起到接口的作用,子类完全可以不用去实现接口 ,如果非要去模仿接口的概念,可以借助第三方模块:
    
    http://pypi.python.org/pypi/zope.interface
    
    twisted的twistedinternetinterface.py里使用zope.interface
    
    文档https://zopeinterface.readthedocs.io/en/latest/
    
    2. 为何要用接口
    
    接口提取了一群类共同的函数,可以把接口当做一个函数的集合。
    
    然后让子类去实现接口中的函数。
    
    这么做的意义在于归一化,什么叫归一化,就是只要是基于同一个接口实现的类,那么所有的这些类产生的对象在使用时,从用法上来说都一样。
    
    归一化,让使用者无需关心对象的类是什么,只需要的知道这些对象都具备某些功能就可以了,这极大地降低了使用者的使用难度。
    
    比如:我们定义一个动物接口,接口里定义了有跑、吃、呼吸等接口函数,这样老鼠的类去实现了该接口,松鼠的类也去实现了该接口,由二者分别产生一只老鼠和一只松鼠送到你面前,即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑,都会吃,都能呼吸。
    
    再比如:我们有一个汽车接口,里面定义了汽车所有的功能,然后由本田汽车的类,奥迪汽车的类,大众汽车的类,他们都实现了汽车接口,这样就好办了,大家只需要学会了怎么开汽车,那么无论是本田,还是奥迪,还是大众我们都会开了,开的时候根本无需关心我开的是哪一类车,操作手法(函数调用)都一样
    回到顶部
    4.6 抽象类
    
    1 什么是抽象类
    
        与java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化
    
    2 为什么要有抽象类
    
        如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类就是从一堆类中抽取相同的内容而来的,内容包括数据属性和函数属性。
    
      比如我们有香蕉的类,有苹果的类,有桃子的类,从这些类抽取相同的内容就是水果这个抽象的类,你吃水果时,要么是吃一个具体的香蕉,要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。
    
        从设计角度去看,如果类是从现实对象抽象而来的,那么抽象类就是基于类抽象而来的。
    
      从实现角度来看,抽象类与普通类的不同之处在于:抽象类中只能有抽象方法(没有实现功能),该类不能被实例化,只能被继承,且子类必须实现抽象方法。这一点与接口有点类似,但其实是不同的,即将揭晓答案
    
    3. 在python中实现抽象类
    复制代码
    
    #_*_coding:utf-8_*_
    __author__ = 'Linhaifeng'
    #一切皆文件
    import abc #利用abc模块实现抽象类
    
    class All_file(metaclass=abc.ABCMeta):
        all_type='file'
        @abc.abstractmethod #定义抽象方法,无需实现功能
        def read(self):
            '子类必须定义读功能'
            pass
    
        @abc.abstractmethod #定义抽象方法,无需实现功能
        def write(self):
            '子类必须定义写功能'
            pass
    
    # class Txt(All_file):
    #     pass
    #
    # t1=Txt() #报错,子类没有定义抽象方法
    
    class Txt(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('文本数据的读取方法')
    
        def write(self):
            print('文本数据的读取方法')
    
    class Sata(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('硬盘数据的读取方法')
    
        def write(self):
            print('硬盘数据的读取方法')
    
    class Process(All_file): #子类继承抽象类,但是必须定义read和write方法
        def read(self):
            print('进程数据的读取方法')
    
        def write(self):
            print('进程数据的读取方法')
    
    wenbenwenjian=Txt()
    
    yingpanwenjian=Sata()
    
    jinchengwenjian=Process()
    
    #这样大家都是被归一化了,也就是一切皆文件的思想
    wenbenwenjian.read()
    yingpanwenjian.write()
    jinchengwenjian.read()
    
    print(wenbenwenjian.all_type)
    print(yingpanwenjian.all_type)
    print(jinchengwenjian.all_type)
    
    复制代码
    
    4. 抽象类与接口
    
    抽象类的本质还是类,指的是一组类的相似性,包括数据属性(如all_type)和函数属性(如read、write),而接口只强调函数属性的相似性。
    
    抽象类是一个介于类和接口直接的一个概念,同时具备类和接口的部分特性,可以用来实现归一化设计 
    回到顶部
    4.7 继承实现的原理(继承顺序)
    
    1 继承顺序
    
    按 Ctrl+C 复制代码
    按 Ctrl+C 复制代码
    
     
    
    2 继承原理(python如何实现的继承)
    
    python到底是如何实现继承的,对于你定义的每一个类,python会计算出一个方法解析顺序(MRO)列表,这个MRO列表就是一个简单的所有基类的线性顺序列表,例如
    
    >>> F.mro() #等同于F.__mro__
    [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
    
     
    
    为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
    而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
    1.子类会先于父类被检查
    2.多个父类会根据它们在列表中的顺序被检查
    3.如果对下一个类存在两个合法的选择,选择第一个父类
    回到顶部
    4.8 子类中调用父类方法
    
    子类继承了父类的方法,然后想进行修改,注意了是基于原有的基础上修改,那么就需要在子类中调用父类的方法
    
    方法一:父类名.父类方法()
    按 Ctrl+C 复制代码
    按 Ctrl+C 复制代码
    
     
    
    方法二:super()
    复制代码
    
    class Vehicle: #定义交通工具类
         Country='China'
         def __init__(self,name,speed,load,power):
             self.name=name
             self.speed=speed
             self.load=load
             self.power=power
    
         def run(self):
             print('开动啦...')
    
    class Subway(Vehicle): #地铁
        def __init__(self,name,speed,load,power,line):
            #super(Subway,self) 就相当于实例本身 在python3中super()等同于super(Subway,self)
            super().__init__(name,speed,load,power)
            self.line=line
    
        def run(self):
            print('地铁%s号线欢迎您' %self.line)
            super(Subway,self).run()
    
    class Mobike(Vehicle):#摩拜单车
        pass
    
    line13=Subway('中国地铁','180m/s','1000人/箱','',13)
    line13.run()
    
    复制代码
    
     
    
    不用super引发的惨案
    View Code
    
     
    
    当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。只要每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次(注意注意注意:使用super调用的所有属性,都是从MRO列表当前的位置往后找,千万不要通过看代码去找继承关系,一定要看MRO列表)
    View Code
    
     
    回到顶部
    五 多态
    
    生活中处处可见多态
    
     
    回到顶部
    六 封装
    
        从封装本身的意思去理解,封装就好像是拿来一个麻袋,把小猫,小狗,小王八,还有alex一起装进麻袋,然后把麻袋封上口子。但其实这种理解相当片面
    
        首先我们要了解
    回到顶部
    6.1 要封装什么
    
    你钱包的有多少钱(数据的封装)
    
    你的性取向(数据的封装)
    
    你撒尿的具体功能是怎么实现的(方法的封装)
    回到顶部
    6.2 为什么要封装
    
    封装数据的主要原因是:保护隐私(作为男人的你,脸上就写着:我喜欢男人,你害怕么?)
    
    封装方法的主要原因是:隔离复杂度(快门就是傻瓜相机为傻瓜们提供的方法,该方法将内部复杂的照相功能都隐藏起来了,比如你不必知道你自己的尿是怎么流出来的,你直接掏出自己的接口就能用尿这个功能)
    
    将数据和方法
    回到顶部
    6.3 封装分为两个层面
    
    封装其实分为两个层面,但很多资料中都混在一起去说,很容易让初学者懵逼:
    
    第一个层面的封装(什么都不用做):创建类和对象会分别创建二者的名称空间,我们只能用类名.或者obj.的方式去访问里面的名字,这本身就是一种封装
    
    >>> r1.nickname
    '草丛伦'
    >>> Riven.camp
    'Noxus'
    
    第二个层面的封装:类中把某些属性和方法隐藏起来(或者说定义成私有的),只在类的内部使用、外部无法访问,或者留下少量接口(函数)供外部访问。
    
    在python中用双下划线的方式实现隐藏属性(设置成私有的)
    
    类中所有双下划线开头的名称如__x都会自动变形成:_类名__x的形式:
    复制代码
    
    class A:
        __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
        def __init__(self):
            self.__X=10 #变形为self._A__X
        def __foo(self): #变形为_A__foo
            print('from A')
        def bar(self):
            self.__foo() #只有在类内部才可以通过__foo的形式访问到.
    
    复制代码
    
    这种自动变形的特点:
    
    1.类中定义的__x只能在内部使用,如self.__x,引用的就是变形的结果。
    
    2.这种变形其实正是针对外部的变形,在外部是无法通过__x这个名字访问到的。
    
    2.在子类定义的__x不会覆盖在父类定义的__x,因为子类中变形成了:_子类名__x,而父类中变形成了:_父类名__x,即双下滑线开头的属性在继承给子类时,子类是无法覆盖的。
    
     
    
         这种变形需要注意的问题是:
    
    1.这种机制也并没有真正意义上限制我们从外部直接访问属性,知道了类名和属性名就可以拼出名字:_类名__属性,然后就可以访问了,如a._A__N
    复制代码
    
    >>> a=A()
    >>> a._A__N
    0
    >>> a._A__X
    10
    >>> A._A__N
    0
    
    复制代码
    
    2.变形的过程只在类的定义是发生一次,在定义后的赋值操作,不会变形
    
    3.在继承中,父类如果不想让子类覆盖自己的方法,可以将方法定义为私有的
    复制代码
    
    #正常情况
    >>> class A:
    ...     def fa(self):
    ...         print('from A')
    ...     def test(self):
    ...         self.fa()
    ... 
    >>> class B(A):
    ...     def fa(self):
    ...         print('from B')
    ... 
    >>> b=B()
    >>> b.test()
    from B
    
    复制代码
    
     
    
     
    复制代码
    
    #把fa定义成私有的,即__fa
    >>> class A:
    ...     def __fa(self): #在定义时就变形为_A__fa
    ...         print('from A')
    ...     def test(self):
    ...         self.__fa() #只会与自己所在的类为准,即调用_A__fa
    ... 
    >>> class B(A):
    ...     def __fa(self):
    ...         print('from B')
    ... 
    >>> b=B()
    >>> b.test()
    from A
    
    复制代码
    
     
    
    ps:面向对象的封装有三种方式:
    【public】
    这种其实就是不封装,是对外公开的
    【protected】
    这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
    【private】
    这种封装对谁都不公开
    注意:python并没有在语法上把它们三个内建到自己的class机制中,在C++里一般会将所有的所有的数据都设置为私有的,然后提供set和get方法去设置和获取,在python中通常直接设置,但是新式类引入了大量全新的特征可以让我们按照自己的需要严格地定制访问权限,详见下一篇,面向对象进阶
    
     
    
    python并不会真的阻止你访问私有的属性,模块也遵循这种约定,如果模块名以单下划线开头,那么from module import *时不能被导入,但是你from module import _private_module依然是可以导入的
    
    其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys._clear_type_cache),这些都是私有的,原则上是供内部调用的,作为外部的你,一意孤行也是可以用的,只不过显得稍微傻逼一点点
    回到顶部
    6.4 封装与扩展性
    
    封装在于明确区分内外,使得类实现者可以修改封装内的东西而不影响外部调用者的代码;而外部使用用者只知道一个接口(函数),只要接口(函数)名、参数不变,使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说,只要接口这个基础约定不变,则代码改变不足为虑。 
    复制代码
    
    #类的设计者
    class Room:
        def __init__(self,name,owner,width,length,high):
            self.name=name
            self.owner=owner
            self.__width=width
            self.__length=length
            self.__high=high
        def tell_area(self): #对外提供的接口,隐藏了内部的实现细节,此时我们想求的是面积
            return self.__width * self.__length
    
    复制代码
    
     
    
    #使用者
    >>> r1=Room('卧室','egon',20,20,20)
    >>> r1.tell_area() #使用者调用接口tell_area
    400
    
     
    复制代码
    
    #类的设计者,轻松的扩展了功能,而类的使用者完全不需要改变自己的代码
    class Room:
        def __init__(self,name,owner,width,length,high):
            self.name=name
            self.owner=owner
            self.__width=width
            self.__length=length
            self.__high=high
        def tell_area(self): #对外提供的接口,隐藏内部实现,此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法,但是功能已经变了
            return self.__width * self.__length * self.__high
    
    复制代码
    
     
    
    对于仍然在使用tell_area接口的人来说,根本无需改动自己的代码,就可以用上新功能
    
    >>> r1.tell_area()
    8000
    
    六 静态方法和类方法
    
    七 特性
    回到顶部
    八 面向对象的软件开发
    
        很多人在学完了python的class机制之后,遇到一个生产中的问题,还是会懵逼,这其实太正常了,因为任何程序的开发都是先设计后编程,python的class机制只不过是一种编程方式,如果你硬要拿着class去和你的问题死磕,变得更加懵逼都是分分钟的事,在以前,软件的开发相对简单,从任务的分析到编写程序,再到程序的调试,可以由一个人或一个小组去完成。但是随着软件规模的迅速增大,软件任意面临的问题十分复杂,需要考虑的因素太多,在一个软件中所产生的错误和隐藏的错误、未知的错误可能达到惊人的程度,这也不是在设计阶段就完全解决的。
    
        所以软件的开发其实一整套规范,我们所学的只是其中的一小部分,一个完整的开发过程,需要明确每个阶段的任务,在保证一个阶段正确的前提下再进行下一个阶段的工作,称之为软件工程
    
        面向对象的软件工程包括下面几个部:
    
    1.面向对象分析(object oriented analysis ,OOA)
    
        软件工程中的系统分析阶段,要求分析员和用户结合在一起,对用户的需求做出精确的分析和明确的表述,从大的方面解析软件系统应该做什么,而不是怎么去做。面向对象的分析要按照面向对象的概念和方法,在对任务的分析中,从客观存在的事物和事物之间的关系,贵南出有关的对象(对象的‘特征’和‘技能’)以及对象之间的联系,并将具有相同属性和行为的对象用一个类class来标识。
    
        建立一个能反映这是工作情况的需求模型,此时的模型是粗略的。
    
    2 面向对象设计(object oriented design,OOD)
    
        根据面向对象分析阶段形成的需求模型,对每一部分分别进行具体的设计。
    
        首先是类的设计,类的设计可能包含多个层次(利用继承与派生机制)。然后以这些类为基础提出程序设计的思路和方法,包括对算法的设计。
    
        在设计阶段并不牵涉任何一门具体的计算机语言,而是用一种更通用的描述工具(如伪代码或流程图)来描述
    
    3 面向对象编程(object oriented programming,OOP)
    
        根据面向对象设计的结果,选择一种计算机语言把它写成程序,可以是python
    
    4 面向对象测试(object oriented test,OOT)
    
        在写好程序后交给用户使用前,必须对程序进行严格的测试,测试的目的是发现程序中的错误并修正它。
    
        面向对的测试是用面向对象的方法进行测试,以类作为测试的基本单元。
    
    5 面向对象维护(object oriendted soft maintenance,OOSM)
    
        正如对任何产品都需要进行售后服务和维护一样,软件在使用时也会出现一些问题,或者软件商想改进软件的性能,这就需要修改程序。
    
        由于使用了面向对象的方法开发程序,使用程序的维护比较容易。
    
        因为对象的封装性,修改一个对象对其他的对象影响很小,利用面向对象的方法维护程序,大大提高了软件维护的效率,可扩展性高。
    
     
    
        在面向对象方法中,最早发展的肯定是面向对象编程(OOP),那时OOA和OOD都还没有发展起来,因此程序设计者为了写出面向对象的程序,还必须深入到分析和设计领域,尤其是设计领域,那时的OOP实际上包含了现在的OOD和OOP两个阶段,这对程序设计者要求比较高,许多人感到很难掌握。
    
        现在设计一个大的软件,是严格按照面向对象软件工程的5个阶段进行的,这个5个阶段的工作不是由一个人从头到尾完成的,而是由不同的人分别完成,这样OOP阶段的任务就比较简单了。程序编写者只需要根据OOd提出的思路,用面向对象语言编写出程序既可。
    
        在一个大型软件开发过程中,OOP只是很小的一个部分。
    
        对于全栈开发的你来说,这五个阶段都有了,对于简单的问题,不必严格按照这个5个阶段进行,往往由程序设计者按照面向对象的方法进行程序设计,包括类的设计和程序的设计
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    回到顶部
     
    回到顶部
    六 静态属性、类方法、静态方法
    静态属性
    静态方法
    类方法
    
     
    回到顶部
    8.2 多态
    
    什么是多态:
    
    类的继承有两层意义:1.改变 2.扩展
    
    多态就是类的这两层意义的一个具体的实现机制 即,调用不同的类实例化得对象下的相同的方法,实现的过程不一样
    
    python中的标准类型就是多态概念的一个很好的示范如(str.__len__(),list.__len__(),tuple.__len__可以len(str),len(list),len(tuple))
    多态
    
    正本清源六:有人说,面向对象三大特性,封装,多态,继承--->小傻逼
    
    可能是由于国人的命名习惯,总喜欢说三大特性,一个观点,三个_代表,八项纪律,九九归一,硬要把面向对象分成三大特性,小白们学的一知半解,然后去工作中用,注意了,用跟懂还是两个层次(有些人终其一生也无法走到技术的金字塔顶,就是因为只会用,不懂为什么),关键是大多数人用了以后,反过来拿着结果去验证自己的错误理解,结果就是建立了一套牢不可破的错误体系。
    
    有一天一位朋友兴致勃勃的跑过来跟我说:你猜怎么着,蜘蛛是聋的,它所有的感知都在腿上。
    
    我满脸疑惑,朋友接着说:你看哈,我把蜘蛛的腿都切掉,然后朝着它大声的啊啊啊啊啊啊啊啊啊啊啊啊,蜘蛛纹丝不动,没有跑
    
    我。。。。。。
    
    这确实就是身边很多搞技术的人喜欢的逻辑,你的出发点就是错的,你的理论体系看起来好像是完美的。
    
     
    
    多态实际上是依附于继承的两种含义的:“改变”和“扩展”本身就意味着必须有机制去自动选用你改变/扩展过的版本,故无多态,则两种含义就不可能实现。
    
    所以,多态实质上是继承的实现细节;那么让多态与封装、继承这两个概念并列,显然是不符合逻辑的
    回到顶部
    九 小白容易犯的错误
    
    1.面向对象的程序设计看起来高大上,所以我在编程时就应该保证通篇class,这样写出的程序一定是好的程序(面向对象只适合那些可扩展性要求比较高的场景)
    
    2.很多人喜欢说面向对象三大特性(这是从哪传出来的,封装,多态,继承?漏洞太多太多,好吧暂且称为三大特性),那么我在基于面向对象编程时,我一定要让我定义的类中完整的包含这三种特性,这样写肯定是好的程序
    
    好家伙,我说降龙十八掌有十八掌,那么你每次跟人干仗都要从第一掌打到第18掌这才显得你会了是么,我来一万个人你需要打10000*18掌对么,傻叉
    
    3.类有类属性,实例有实例属性,所以我们在定义class时一定要定义出那么几个类属性,想不到怎么办,那就使劲的想,定义的越多越牛逼
    
    这就犯了一个严重的错误,程序越早面向对象,死的越早,为啥面向对象,因为我们要将数据与功能结合到一起,程序整体的结构都没有出来,或者说需要考虑的问题你都没有搞清楚个八九不离十,你就开始面向对象了,这就导致了,你在那里干想,自以为想通了,定义了一堆属性,结果后来又都用不到,或者想不通到底应该定义啥,那就一直想吧,想着想着就疯了。
    
    你见过哪家公司要开发一个软件,上来就开始写,肯定是频繁的开会讨论计划,请看第八节
    
    4.既然这么麻烦,那么我彻底解脱了,我们不要用面向对象编程了,你啊,你有大才,你能成事啊,傻叉。
    回到顶部
    十 python中关于OOP的常用术语
    
    抽象/实现
    
    抽象指对现实世界问题和实体的本质表现,行为和特征建模,建立一个相关的子集,可以用于 绘程序结构,从而实现这种模型。抽象不仅包括这种模型的数据属性,还定义了这些数据的接口。
    
    对某种抽象的实现就是对此数据及与之相关接口的现实化(realization)。现实化这个过程对于客户 程序应当是透明而且无关的。 
    
    封装/接口
    
    封装描述了对数据/信息进行隐藏的观念,它对数据属性提供接口和访问函数。通过任何客户端直接对数据的访问,无视接口,与封装性都是背道而驰的,除非程序员允许这些操作。作为实现的 一部分,客户端根本就不需要知道在封装之后,数据属性是如何组织的。在Python中,所有的类属性都是公开的,但名字可能被“混淆”了,以阻止未经授权的访问,但仅此而已,再没有其他预防措施了。这就需要在设计时,对数据提供相应的接口,以免客户程序通过不规范的操作来存取封装的数据属性。
    
    注意:封装绝不是等于“把不想让别人看到、以后可能修改的东西用private隐藏起来”
    
    真正的封装是,经过深入的思考,做出良好的抽象,给出“完整且最小”的接口,并使得内部细节可以对外透明
    
    (注意:对外透明的意思是,外部调用者可以顺利的得到自己想要的任何功能,完全意识不到内部细节的存在)
    
    合成
    
    合成扩充了对类的 述,使得多个不同的类合成为一个大的类,来解决现实问题。合成 述了 一个异常复杂的系统,比如一个类由其它类组成,更小的组件也可能是其它的类,数据属性及行为, 所有这些合在一起,彼此是“有一个”的关系。
    
    派生/继承/继承结构
    
    派生描述了子类衍生出新的特性,新类保留已存类类型中所有需要的数据和行为,但允许修改或者其它的自定义操作,都不会修改原类的定义。
    继承描述了子类属性从祖先类继承这样一种方式
    继承结构表示多“代”派生,可以述成一个“族谱”,连续的子类,与祖先类都有关系。
    
    泛化/特化
    
    基于继承
    泛化表示所有子类与其父类及祖先类有一样的特点。
    特化描述所有子类的自定义,也就是,什么属性让它与其祖先类不同。
    
    多态
    
    多态的概念指出了对象如何通过他们共同的属性和动作来操作及访问,而不需考虑他们具体的类。
    
    多态表明了动态(又名,运行时)绑定的存在,允计重载及运行时类型确定和验证。 
    
    举例:
    
    水是一个类
    
    不同温度,水被实例化成了不同的状态:冰,水蒸气,雾(然而很多人就理解到这一步就任务此乃多态,错,fuck!,多态是运行时绑定的存在)
    
    (多态体现在由同一个类实例化出的多个对象,这些对象执行相同的方法时,执行的过程和结果是不一样的)
    
    冰,水蒸气,雾,有一个共同的方法就是变成云,但是冰.变云(),与水蒸气.变云()是截然不同的两个过程,虽然调用的方法都一样
    
    自省/反射
    
    自省也称作反射,这个性质展示了某对象是如何在运行期取得自身信息的。如果传一个对象给你,你可以查出它有什么能力,这是一项强大的特性。如果Python不支持某种形式的自省功能,dir和type内建函数,将很难正常工作。还有那些特殊属性,像__dict__,__name__及__doc__
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
     
    
    
     
    分类: python开发之路
    好文要顶 已关注 收藏该文
    linhaifeng
    关注 - 1
    粉丝 - 71
    我在关注他 取消关注
    1
    0
    » 下一篇:openstack系列介绍
    posted @ 2016-12-15 10:34 linhaifeng 阅读(305) 评论(1)  编辑 收藏
    
    评论列表
      回复引用
    #1楼 2016-12-15 16:45 海瑞PYthon  
    哈哈 人狗大战
    支持(0)反对(0)
    刷新评论刷新页面返回顶部
    发表评论
    
    昵称:
    评论内容:
    引用 粗体 链接 缩进 代码 图片
    
    退出登录 订阅评论
    
    [Ctrl+Enter快捷键提交]
    【推荐】50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
    【推荐】Google+GitHub联手打造前端工程师课程
    【推荐】票选最美云上大数据暨大数据技术峰会
    最新IT新闻:
    · 创业万象中的一种际遇:卖房还债,创业失败后一家三口街头住帐篷
    · QQ TIM版:切入白领人群,为办公痛点提供解决方案
    · 阿里童文红:创业充满不确定,搭建属于自己的独特文化很重要
    · OPPO在MWC上带来黑科技“5 倍无损变焦”,这是个什么样的技术?
    · 豆瓣将推付费音频产品 内容付费市场再添新玩家
    » 更多新闻...
    最新知识库文章:
    · 垃圾回收原来是这么回事
    · 「代码家」的学习过程和学习经验分享
    · 写给未来的程序媛
    · 高质量的工程代码为什么难写
    · 循序渐进地代码重构
    » 更多知识库文章...
    公告
    林海峰的头像
    昵称:linhaifeng
    园龄:4个月
    粉丝:71
    关注:1
    已关注 -取消
    <    2017年3月    >
    日    一    二    三    四    五    六
    26    27    28    1    2    3    4
    5    6    7    8    9    10    11
    12    13    14    15    16    17    18
    19    20    21    22    23    24    25
    26    27    28    29    30    31    1
    2    3    4    5    6    7    8
    搜索
     
     
    常用链接
    
        我的随笔
        我的评论
        我的参与
        最新评论
        我的标签
    
    随笔分类
    
        openstack系列(11)
        编程基础(3)
    
    随笔档案
    
        2017年2月 (6)
        2017年1月 (8)
    
    文章分类
    
        python开发之路(16)
        python全栈之linux基础(1)
        python全栈之操作系统(1)
        python全栈之网络基础(3)
    
    相册
    
        头像(1)
    
    python开发之路
    最新评论
    
        1. Re:openstack系列阅读目录
        厉害了!峰哥! 啥时候给我们讲啊!
        --白日梦想家
        2. Re:openstack系列介绍
        @温柔易淡五年多...
        --linhaifeng
        3. Re:openstack系列介绍
        峰哥威武。想知道峰哥最初来北京的3800薪资到8k,到15k ,到26k,到税后30k花了多长时间?
        --温柔易淡
        4. Re:glance系列二:glance部署及操作
        66666666666
        --如梦dream
        5. Re:openstack系列阅读目录
        可算找到了 峰哥 藏得有点深啊
        --Zgwd_it
    
    阅读排行榜
    
        1. openstack系列阅读目录(241)
        2. keystone系列一:keystone基础(198)
        3. openstack系列介绍(161)
        4. keystone系列四:keystone部署及操作(96)
        5. keystone系列三:网关协议(66)
    
    评论排行榜
    
        1. openstack系列介绍(3)
        2. openstack系列阅读目录(2)
        3. glance系列二:glance部署及操作(1)
    
    推荐排行榜
    
        1. keystone系列一:keystone基础(3)
        2. 操作系统简介(2)
        3. nova系列二:kvm介绍(1)
        4. keystone系列五:keystone源码分析(1)
        5. keystone系列二:HTTP协议(1)
    
    Copyright ©2017 linhaifeng
    View Code

    不用super引发的惨案

    #每个类中都继承了且重写了父类的方法
    class A:
        def __init__(self):
            print('A的构造方法')
    class B(A):
        def __init__(self):
            print('B的构造方法')
            A.__init__(self)
    
    
    class C(A):
        def __init__(self):
            print('C的构造方法')
            A.__init__(self)
    
    
    class D(B,C):
        def __init__(self):
            print('D的构造方法')
            B.__init__(self)
            C.__init__(self)
    
        pass
    f1=D()
    
    print(D.__mro__) #python2中没有这个属性
    View Code

    当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。只要每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次(注意注意注意:使用super调用的所有属性,都是从MRO列表当前的位置往后找,千万不要通过看代码去找继承关系,一定要看MRO列表

    #每个类中都继承了且重写了父类的方法
    class A:
        def __init__(self):
            print('A的构造方法')
    class B(A):
        def __init__(self):
            print('B的构造方法')
            super(B,self).__init__()
    
    
    class C(A):
        def __init__(self):
            print('C的构造方法')
            super(C,self).__init__()
    
    
    class D(B,C):
        def __init__(self):
            print('D的构造方法')
            super(D,self).__init__()
    
    f1=D()
    
    print(D.__mro__) #python2中没有这个属性
    View Code

    五 多态

    生活中处处可见多态

    六 封装

        从封装本身的意思去理解,封装就好像是拿来一个麻袋,把小猫,小狗,小王八,还有alex一起装进麻袋,然后把麻袋封上口子。但其实这种理解相当片面

        首先我们要了解

    6.1 要封装什么

    你钱包的有多少钱(数据的封装)

    你的性取向(数据的封装)

    你撒尿的具体功能是怎么实现的(方法的封装)

    6.2 为什么要封装

    封装数据的主要原因是:保护隐私(作为男人的你,脸上就写着:我喜欢男人,你害怕么?)

    封装方法的主要原因是:隔离复杂度(快门就是傻瓜相机为傻瓜们提供的方法,该方法将内部复杂的照相功能都隐藏起来了,比如你不必知道你自己的尿是怎么流出来的,你直接掏出自己的接口就能用尿这个功能)

    将数据和方法

    6.3 封装分为两个层面

    封装其实分为两个层面,但很多资料中都混在一起去说,很容易让初学者懵逼:

    第一个层面的封装(什么都不用做):创建类和对象会分别创建二者的名称空间,我们只能用类名.或者obj.的方式去访问里面的名字,这本身就是一种封装

    >>> r1.nickname
    '草丛伦'
    >>> Riven.camp
    'Noxus'

    第二个层面的封装:类中把某些属性和方法隐藏起来(或者说定义成私有的),只在类的内部使用、外部无法访问,或者留下少量接口(函数)供外部访问。

    在python中用双下划线的方式实现隐藏属性(设置成私有的)

    类中所有双下划线开头的名称如__x都会自动变形成:_类名__x的形式:

    复制代码
    class A:
        __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
        def __init__(self):
            self.__X=10 #变形为self._A__X
        def __foo(self): #变形为_A__foo
            print('from A')
        def bar(self):
            self.__foo() #只有在类内部才可以通过__foo的形式访问到.
    复制代码

    这种自动变形的特点:

    1.类中定义的__x只能在内部使用,如self.__x,引用的就是变形的结果

    2.这种变形其实正是针对外部的变形,在外部是无法通过__x这个名字访问到的。

    2.在子类定义的__x不会覆盖在父类定义的__x,因为子类中变形成了:_子类名__x,而父类中变形成了:_父类名__x,即双下滑线开头的属性在继承给子类时,子类是无法覆盖的。

         这种变形需要注意的问题是:

    1.这种机制也并没有真正意义上限制我们从外部直接访问属性,知道了类名和属性名就可以拼出名字:_类名__属性,然后就可以访问了,如a._A__N

    复制代码
    >>> a=A()
    >>> a._A__N
    0
    >>> a._A__X
    10
    >>> A._A__N
    0
    复制代码

    2.变形的过程只在类的定义是发生一次,在定义后的赋值操作,不会变形

    3.在继承中,父类如果不想让子类覆盖自己的方法,可以将方法定义为私有的

    复制代码
    #正常情况
    >>> class A: ... def fa(self): ... print('from A') ... def test(self): ... self.fa() ... >>> class B(A): ... def fa(self): ... print('from B') ... >>> b=B() >>> b.test() from B
    复制代码
    复制代码
    #把fa定义成私有的,即__fa
    >>> class A:
    ...     def __fa(self): #在定义时就变形为_A__fa
    ...         print('from A')
    ...     def test(self):
    ...         self.__fa() #只会与自己所在的类为准,即调用_A__fa
    ... 
    >>> class B(A):
    ...     def __fa(self):
    ...         print('from B')
    ... 
    >>> b=B()
    >>> b.test()
    from A
    复制代码

    ps:面向对象的封装有三种方式:
    【public】
    这种其实就是不封装,是对外公开的
    【protected】
    这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
    【private】
    这种封装对谁都不公开
    注意:python并没有在语法上把它们三个内建到自己的class机制中,在C++里一般会将所有的所有的数据都设置为私有的,然后提供set和get方法去设置和获取,在python中通常直接设置,但是新式类引入了大量全新的特征可以让我们按照自己的需要严格地定制访问权限,详见下一篇,面向对象进阶

    python并不会真的阻止你访问私有的属性,模块也遵循这种约定,如果模块名以单下划线开头,那么from module import *时不能被导入,但是你from module import _private_module依然是可以导入的

    其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys._clear_type_cache),这些都是私有的,原则上是供内部调用的,作为外部的你,一意孤行也是可以用的,只不过显得稍微傻逼一点点

    6.4 封装与扩展性

    封装在于明确区分内外,使得类实现者可以修改封装内的东西而不影响外部调用者的代码;而外部使用用者只知道一个接口(函数),只要接口(函数)名、参数不变,使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说,只要接口这个基础约定不变,则代码改变不足为虑。 

    复制代码
    #类的设计者
    class Room:
        def __init__(self,name,owner,width,length,high):
            self.name=name
            self.owner=owner
            self.__width=width
            self.__length=length
            self.__high=high
        def tell_area(self): #对外提供的接口,隐藏了内部的实现细节,此时我们想求的是面积
            return self.__width * self.__length
    复制代码
    #使用者
    >>> r1=Room('卧室','egon',20,20,20)
    >>> r1.tell_area() #使用者调用接口tell_area
    400
    复制代码
    #类的设计者,轻松的扩展了功能,而类的使用者完全不需要改变自己的代码
    class Room:
        def __init__(self,name,owner,width,length,high):
            self.name=name
            self.owner=owner
            self.__width=width
            self.__length=length
            self.__high=high
        def tell_area(self): #对外提供的接口,隐藏内部实现,此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法,但是功能已经变了
            return self.__width * self.__length * self.__high
    复制代码

    对于仍然在使用tell_area接口的人来说,根本无需改动自己的代码,就可以用上新功能

    >>> r1.tell_area()
    8000

    六 静态方法和类方法

    七 特性

    八 面向对象的软件开发

        很多人在学完了python的class机制之后,遇到一个生产中的问题,还是会懵逼,这其实太正常了,因为任何程序的开发都是先设计后编程,python的class机制只不过是一种编程方式,如果你硬要拿着class去和你的问题死磕,变得更加懵逼都是分分钟的事,在以前,软件的开发相对简单,从任务的分析到编写程序,再到程序的调试,可以由一个人或一个小组去完成。但是随着软件规模的迅速增大,软件任意面临的问题十分复杂,需要考虑的因素太多,在一个软件中所产生的错误和隐藏的错误、未知的错误可能达到惊人的程度,这也不是在设计阶段就完全解决的。

        所以软件的开发其实一整套规范,我们所学的只是其中的一小部分,一个完整的开发过程,需要明确每个阶段的任务,在保证一个阶段正确的前提下再进行下一个阶段的工作,称之为软件工程

        面向对象的软件工程包括下面几个部:

    1.面向对象分析(object oriented analysis ,OOA)

        软件工程中的系统分析阶段,要求分析员和用户结合在一起,对用户的需求做出精确的分析和明确的表述,从大的方面解析软件系统应该做什么,而不是怎么去做。面向对象的分析要按照面向对象的概念和方法,在对任务的分析中,从客观存在的事物和事物之间的关系,贵南出有关的对象(对象的‘特征’和‘技能’)以及对象之间的联系,并将具有相同属性和行为的对象用一个类class来标识。

        建立一个能反映这是工作情况的需求模型,此时的模型是粗略的。

    2 面向对象设计(object oriented design,OOD)

        根据面向对象分析阶段形成的需求模型,对每一部分分别进行具体的设计。

        首先是类的设计,类的设计可能包含多个层次(利用继承与派生机制)。然后以这些类为基础提出程序设计的思路和方法,包括对算法的设计。

        在设计阶段并不牵涉任何一门具体的计算机语言,而是用一种更通用的描述工具(如伪代码或流程图)来描述

    3 面向对象编程(object oriented programming,OOP)

        根据面向对象设计的结果,选择一种计算机语言把它写成程序,可以是python

    4 面向对象测试(object oriented test,OOT)

        在写好程序后交给用户使用前,必须对程序进行严格的测试,测试的目的是发现程序中的错误并修正它。

        面向对的测试是用面向对象的方法进行测试,以类作为测试的基本单元。

    5 面向对象维护(object oriendted soft maintenance,OOSM)

        正如对任何产品都需要进行售后服务和维护一样,软件在使用时也会出现一些问题,或者软件商想改进软件的性能,这就需要修改程序。

        由于使用了面向对象的方法开发程序,使用程序的维护比较容易。

        因为对象的封装性,修改一个对象对其他的对象影响很小,利用面向对象的方法维护程序,大大提高了软件维护的效率,可扩展性高。

        在面向对象方法中,最早发展的肯定是面向对象编程(OOP),那时OOA和OOD都还没有发展起来,因此程序设计者为了写出面向对象的程序,还必须深入到分析和设计领域,尤其是设计领域,那时的OOP实际上包含了现在的OOD和OOP两个阶段,这对程序设计者要求比较高,许多人感到很难掌握。

        现在设计一个大的软件,是严格按照面向对象软件工程的5个阶段进行的,这个5个阶段的工作不是由一个人从头到尾完成的,而是由不同的人分别完成,这样OOP阶段的任务就比较简单了。程序编写者只需要根据OOd提出的思路,用面向对象语言编写出程序既可。

        在一个大型软件开发过程中,OOP只是很小的一个部分。

        对于全栈开发的你来说,这五个阶段都有了,对于简单的问题,不必严格按照这个5个阶段进行,往往由程序设计者按照面向对象的方法进行程序设计,包括类的设计和程序的设计

    六 静态属性、类方法、静态方法

    class Room:
        def __init__(self,name,owner,width,length):
            self.name=name
            self.owner=owner
            self.width=width
            self.length=length
    
        @property
        def cal_area(self):
            return self.width * self.length
    
    
    r1=Room('厕所','alex',1000,100)
    print(r1.cal_area)
    
    r1.cal_area=10 #无法设置,会报错
    V静态属性
    '''
    staticmethod静态方法只是名义上的归属类管理,不能使用类变量和实例变量,是类的工具包
    '''
    
    class Room:
        def __init__(self,name,owner,width,length):
            self.name=name
            self.owner=owner
            self.width=width
            self.length=length
    
        @property
        def cal_area(self):
            return self.width * self.length
    
        @staticmethod
        def wash_body():
            print('洗刷刷,洗刷刷')
    
        def test():
            print('这可不是静态方法,用类调用没问题,你用一个实例调用看看')
    
    Room.wash_body()
    
    r1=Room('厕所','alex',10,10)
    r1.wash_body()
    
    
    
    #------
    Room.test()
    r1.test() #会报错,因为如果test不是静态方法,那么r1会吧自己传给test的第一个参数self,test无参所以报错
    静态方法
    '''
    classmethod类方法只是给类使用(不管是否存在实例),只能访问实例变量
    '''
    
    class Room:
        style='欧式豪宅'
        def __init__(self,name,owner,width,length):
            self.name=name
            self.owner=owner
            self.width=width
            self.length=length
    
        @property
        def cal_area(self):
            return self.width * self.length
    
        @staticmethod
        def wash_body():
            print('洗刷刷,洗刷刷')
    
        def test():
            print('这可不是静态方法,用类调用没问题,你用一个实例调用看看')
    
        @classmethod
        def tell_style(cls):
            # print('%s的房间风格是%s' %(self.name,cls.style)) #不能访问实例
            print('房间风格是[%s]' %(cls.style)) #不能访问实例
    
    Room.tell_style() #类方法的定义应该只是为了类去调用
    
    r1=Room('卧室','alex',10,10)
    r1.tell_style() #但其实你非要让实例去调用,也是可以的,不过却违反了我们的初衷:类方法就是专门为类使用
    类方法

    8.2 多态

    什么是多态:

    类的继承有两层意义:1.改变 2.扩展

    多态就是类的这两层意义的一个具体的实现机制 即,调用不同的类实例化得对象下的相同的方法,实现的过程不一样

    python中的标准类型就是多态概念的一个很好的示范如(str.__len__(),list.__len__(),tuple.__len__可以len(str),len(list),len(tuple))

    #_*_coding:utf-8_*_
    __author__ = 'Linhaifeng'
    
    class H2O:
        def __init__(self,name,temperature):
            self.name=name
            self.temperature=temperature
        def turn_ice(self):
            if self.temperature < 0:
                print('[%s]温度太低结冰了' %self.name)
            elif self.temperature > 0 and self.temperature < 100:
                print('[%s]液化成水' %self.name)
            elif self.temperature > 100:
                print('[%s]温度太高变成了水蒸气' %self.name)
    
    class Water(H2O):
        pass
    
    class Ice(H2O):
        pass
    class Steam(H2O):
        pass
    
    
    w1=Water('',25)
    
    i1=Ice('',-20)
    
    s1=Steam('蒸汽',3000)
    
    def func(obj):
        obj.turn_ice()
    
    func(w1)
    func(i1)
    func(s1)
    
    w2=Water('',101)
    func(w2)
    多态

    正本清源六:有人说,面向对象三大特性,封装,多态,继承--->小傻逼

    可能是由于国人的命名习惯,总喜欢说三大特性,一个观点,三个_代表,八项纪律,九九归一,硬要把面向对象分成三大特性,小白们学的一知半解,然后去工作中用,注意了,用跟懂还是两个层次(有些人终其一生也无法走到技术的金字塔顶,就是因为只会用,不懂为什么),关键是大多数人用了以后,反过来拿着结果去验证自己的错误理解,结果就是建立了一套牢不可破的错误体系。

    有一天一位朋友兴致勃勃的跑过来跟我说:你猜怎么着,蜘蛛是聋的,它所有的感知都在腿上。

    我满脸疑惑,朋友接着说:你看哈,我把蜘蛛的腿都切掉,然后朝着它大声的啊啊啊啊啊啊啊啊啊啊啊啊,蜘蛛纹丝不动,没有跑

    我。。。。。。

    这确实就是身边很多搞技术的人喜欢的逻辑,你的出发点就是错的,你的理论体系看起来好像是完美的。

    多态实际上是依附于继承的两种含义的:“改变”和“扩展”本身就意味着必须有机制去自动选用你改变/扩展过的版本,故无多态,则两种含义就不可能实现。

    所以,多态实质上是继承的实现细节;那么让多态与封装、继承这两个概念并列,显然是不符合逻辑的

    九 小白容易犯的错误

    1.面向对象的程序设计看起来高大上,所以我在编程时就应该保证通篇class,这样写出的程序一定是好的程序(面向对象只适合那些可扩展性要求比较高的场景)

    2.很多人喜欢说面向对象三大特性(这是从哪传出来的,封装,多态,继承?漏洞太多太多,好吧暂且称为三大特性),那么我在基于面向对象编程时,我一定要让我定义的类中完整的包含这三种特性,这样写肯定是好的程序

    好家伙,我说降龙十八掌有十八掌,那么你每次跟人干仗都要从第一掌打到第18掌这才显得你会了是么,我来一万个人你需要打10000*18掌对么,傻叉

    3.类有类属性,实例有实例属性,所以我们在定义class时一定要定义出那么几个类属性,想不到怎么办,那就使劲的想,定义的越多越牛逼

    这就犯了一个严重的错误,程序越早面向对象,死的越早,为啥面向对象,因为我们要将数据与功能结合到一起,程序整体的结构都没有出来,或者说需要考虑的问题你都没有搞清楚个八九不离十,你就开始面向对象了,这就导致了,你在那里干想,自以为想通了,定义了一堆属性,结果后来又都用不到,或者想不通到底应该定义啥,那就一直想吧,想着想着就疯了。

    你见过哪家公司要开发一个软件,上来就开始写,肯定是频繁的开会讨论计划,请看第八节

    4.既然这么麻烦,那么我彻底解脱了,我们不要用面向对象编程了,你啊,你有大才,你能成事啊,傻叉。

    十 python中关于OOP的常用术语

    抽象/实现

    抽象指对现实世界问题和实体的本质表现,行为和特征建模,建立一个相关的子集,可以用于 绘程序结构,从而实现这种模型。抽象不仅包括这种模型的数据属性,还定义了这些数据的接口。

    对某种抽象的实现就是对此数据及与之相关接口的现实化(realization)。现实化这个过程对于客户 程序应当是透明而且无关的。 

    封装/接口

    封装描述了对数据/信息进行隐藏的观念,它对数据属性提供接口和访问函数。通过任何客户端直接对数据的访问,无视接口,与封装性都是背道而驰的,除非程序员允许这些操作。作为实现的 一部分,客户端根本就不需要知道在封装之后,数据属性是如何组织的。在Python中,所有的类属性都是公开的,但名字可能被“混淆”了,以阻止未经授权的访问,但仅此而已,再没有其他预防措施了。这就需要在设计时,对数据提供相应的接口,以免客户程序通过不规范的操作来存取封装的数据属性。

    注意:封装绝不是等于“把不想让别人看到、以后可能修改的东西用private隐藏起来”

    真正的封装是,经过深入的思考,做出良好的抽象,给出“完整且最小”的接口,并使得内部细节可以对外透明

    (注意:对外透明的意思是外部调用者可以顺利的得到自己想要的任何功能,完全意识不到内部细节的存在)

    合成

    合成扩充了对类的 述,使得多个不同的类合成为一个大的类,来解决现实问题。合成 述了 一个异常复杂的系统,比如一个类由其它类组成,更小的组件也可能是其它的类,数据属性及行为, 所有这些合在一起,彼此是“有一个”的关系。

    派生/继承/继承结构

    派生描述了子类衍生出新的特性,新类保留已存类类型中所有需要的数据和行为,但允许修改或者其它的自定义操作,都不会修改原类的定义。
    继承描述了子类属性从祖先类继承这样一种方式
    继承结构表示多“代”派生,可以述成一个“族谱”,连续的子类,与祖先类都有关系。

    泛化/特化

    基于继承
    泛化表示所有子类与其父类及祖先类有一样的特点。
    特化描述所有子类的自定义,也就是,什么属性让它与其祖先类不同。

    多态

    多态的概念指出了对象如何通过他们共同的属性和动作来操作及访问,而不需考虑他们具体的类。

    多态表明了动态(又名,运行时)绑定的存在,允计重载及运行时类型确定和验证。 

    举例:

    水是一个类

    不同温度,水被实例化成了不同的状态:冰,水蒸气,雾(然而很多人就理解到这一步就任务此乃多态,错,fuck!,多态是运行时绑定的存在)

    (多态体现在由同一个类实例化出的多个对象,这些对象执行相同的方法时,执行的过程和结果是不一样的)

    冰,水蒸气,雾,有一个共同的方法就是变成云,但是冰.变云(),与水蒸气.变云()是截然不同的两个过程,虽然调用的方法都一样

    自省/反射

    自省也称作反射,这个性质展示了某对象是如何在运行期取得自身信息的。如果传一个对象给你,你可以查出它有什么能力,这是一项强大的特性。如果Python不支持某种形式的自省功能,dir和type内建函数,将很难正常工作。还有那些特殊属性,像__dict__,__name__及__doc__

  • 相关阅读:
    开放源码的对象关系映射工具ORM.NET 插入数据 Insert/Update Data
    开放源码的对象关系映射工具ORM.NET 快档开发入门 Quick Start
    .NET 动态脚本语言Script.NET 开发指南
    开放源码的对象关系映射工具ORM.NET 删除数据 Deleting Records using ORM.NET
    .NET Remoting过时了吗?为什么公司的项目还是选择用.NET Remoting,而不是WCF?
    开放源码的对象关系映射工具ORM.NET 查看和显示数据 View and Display data using ORM.NET
    开放源码的对象关系映射工具ORM.NET 查询表 调用存储过程 增加自定义代码
    技术人生:坚持,每日一博
    CQRS:CQRS + DDD + MDP 实现快速应用程序开发
    NodeJs:Happy代码生成器,重构了代码,更新了文档,完善了示例,欢迎下载使用
  • 原文地址:https://www.cnblogs.com/1qaz/p/6492465.html
Copyright © 2011-2022 走看看