python 面向对象及封装继承和多态

######装饰器######
装饰器的概念

- 装饰器的实现是函数里面嵌套函数;
- 装饰器的本质是一个函数， 它可以让其他函数在不需要做任何代码改动的前提下增加额外的功能;
- 装饰器需要传递一个函数， 返回值也是一个函数对象.
######面向对象#######
一、面向对象的基本概念
 面向过程和面向对象，是两种不同的编程方式
 对比面向过程的特点，可以更好的了解什么是面向对象

 过程和函数(都是对一段功能的代码进行封装)
 过程：是早期的一个编程概念
  过程类似于函数，只能执行，但是没有返回值
 函数：不仅能执行，还可以返回结果(return)
二、面向过程 和 面向对象 的基本概念

面向过程：---侧重于怎么做？
 1.把完成某一个需求的 所有步骤 从头到尾 逐步实现
 2.根据开发要求，将某些功能独立的代码封装成一个又一个函数
 3.最后完成的代码，就是顺序的调用不同的函数
特点：
 1.注重步骤与过程，不注重职责分工
 2.如果需求复杂，代码会变得很复杂
 3.开发复杂项目，没有固定的套路，开发难度很大

相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
 1.在完成某一个需求前，首先确定职责--要做的事(方法)
 2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)
 3.最后完成代码，就是顺序的让不同的对象调用不同的方法
特点：
 1.注重对象和职责，不同的对象承担不同的职责
 2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供的固定套路
 3.需要在面向过程的基础上，再学习一些面向对象的语法

三、面向对象的两个核心概念

1.类和对象的概念
 类和对象是面向对象编程的两个核心概念
 类：是对一群具有相同特征或行为的事物的一个统称，是抽象的，不能直接使用(就好比，飞机图纸不能直接飞上天)
 特征:被称为属性
 行为:被称为方法
 类 就相当于制造飞机时的图纸，是一个模板，是负责创建对象的

 对象：是由类创建出来的一个具体的存在，可以直接使用(图纸创造出来的飞机，可以飞上天)
 由哪一个类创建出来的对象，就拥有哪一个类种法定义的属性和方法
 “对象就相当于用图纸创造出来的飞机”
2.类和对象的关系
 类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象
 类只需要有一个 而对象可以有很多个（一张图纸可以造出很多架飞机）
 不同对象之前属性可以不相同(比如飞机的颜色 等等。。)
 类中定义了什么属性和方法，使用这个类创建出来的对象中就有什么属性和方法，不可能多也不可能少
四、面向对象的基本语法
定义一个只包含方法的类
class 类名：
    def 方法1(self,参数列表):
        pass
    def 方法2(self,参数列表):
        pass
方法的定义格式和之前学的函数几乎一样
区别在于第一个参数必须是self
五、面向对象中的引用概念####
tom = Cat():在等号右侧我们使用cat类创建了一个猫对象，在等号左侧使用tom这个变量接收了这个猫对象
python解释器在执行到此句代码的时候，在内存中为这个猫对象分配了一个内存空间，然后再让tom这个变量记录了猫对象在内存中的地址
在python中使用类创建对象之后，tom变量中仍然记录的是对象在内存中的地址
也就是tom变量引用了新建的猫对象
使用print输出对象变量，默认情况下，是能够输出这个变量引用的对象是由哪一个类创建的象，以及在内存中的地址(十六进制表示)
提示：在计算机中，通常使用十六进制表示内存地址
六、内置方法和属性#####
__del__方法：对象被从内存中销毁前，会被自动调用
__str__方法：返回对象的描述信息，print函数输出使用

__del__方法：
在python中
 当使用类名()创建对象时，为对象分配完空间后，自动调用__init__方法
 当一个对象被从内存中销毁前(把这个对象从内存中删除掉)，会自动调用__del__方法
应用场景
 __init__改造初始化方法，可以让创建对象更加灵活
 __del__如果希望在对象被销毁前，再做一些事情，可以考虑一下__del__方法

生命周期(出生到死亡)
 一个对象从调用类名()创建，生命周期开始
 一个对象的__del__方法一但被调用，生命周期结束
 在对象的生命周期内，可以访问对象属性，或者让对象调用方法

__str__方法：
 在python中，使用python输出对象变量，默认情况下，会输出这个变量引用的对象是由哪>一个类创建的对象，以及在内存中的地址(十六进制表示)
 如果在开发中，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用__str__这个内置方法了
七、私有属性和私有方法
应用场景
 在实际开发中，对象的某些属性或方法可能只希望在对象的内部使用，而不希望在外部被访问到
 私有属性 就是 对象 不希望公开的 属性
 私有方法 就是 对象 不希望公开的 方法
#####封装#######
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步，将属性和方法封装到一个抽象的类中(为什么类是抽象的？)
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部
######继承######
实现代码的重用，相同的代码不需要重复的写
继承的传递性
    1.C 类从B类继承 ，B类又从A类继承
    2.那么C类就具有B类和A类的所有属性和方法
class A:
    def eat(self):
        print 'eat'
class B(A):
    def drink(self):
        print 'drink'
class C(B):
    def sleep(self):
        print 'sleep'
tom =C()
tom.eat()
tom.drink()
tom.sleep()
方法的重写
1.覆盖父类的方法(重写父类方法)
2.对父类方法进行扩展
class A:
    def eat(self):
        print 'eat'
class B(A):
    def drink(self):
        print 'drink'
class C(B):
    def sleep(self):
        print 'sleep'
    def eat(self):
        print '饿'
tom =C()
tom.eat()
tom.drink()
tom.sleep()
---------
饿
drink
sleep
---------

多继承
    子类拥有一个父类叫作单继承
    子类可以拥有多个父类，并且具有所有父类的属性和方法
    例如:孩子会继承自己父亲和母亲的特征
class A:
    def eat(self):
        print 'eat-A'
    def drink(self):
        print 'drink-A'
class B(A):
    def drink(self):
        print 'drink-B'
    def eat(self):
        print 'eat-B'
class C(B,A):
        pass
tom =C()
tom.eat()
tom.drink()
--------
eat-B
drink-B
--------

####.多态#####

不同的子类对象调用相同的方法，产生不同的执行结果

1.多态可以增加代码的灵活度

2.以继承和重写父类的方法为前提

3.调用方法，不会影响到类的内部设计