面向对象的三大特征

面向对象编程简单来说就是基于对类和对象的使用，所有的代码都是通过类和对象来实现的编程就是面向对象编程！

面向对象的三大特性：封装、继承、多态

一、封装（Encapsulation）：

　　在类中对数据的赋值、内部调用对外部用户来说是透明不可见的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法。

 1  class Animal:
 2      doc ='This is a example'
 3      def __init__(self, variety, sex):
 4          self.variety = variety
 5          self.sex = sex
 6      def bark(self):
 7          print('%s is barking')
 8  # 创建对象
 9  dog = Animal('DOG','M')
10  cat = Animal('CAT', 'F')

上面的代码实现就是封装的功能，有一个类变量doc，把各自的variety、sex分别封装到self的variety和sex属性中，就等于封装到对象dog和cat中；

类中定义的函数叫做方法，带有__init__()的函数叫做构造方法，在创建dog和cat对象会自动执行。

二、继承

1、继承：派生类（子类）可以继承基类（父类）的方法，我们可以将多个类共有的方法提取到父类当中，这样子类仅需继承父类而不必实现每个方法。

 1 class Animal:
 2     def __init__(self, variety, sex):
 3         self.variety = variety
 4         self.sex = sex
 5     def bark(self):
 6         print('%s is barking' % self.variety)
 7 
 8 class Dog(Animal): # 继承Animal父类
 9     def __init__(self, variety, sex, name):
10         super(Dog, self).__init__(variety, sex) #继承父类变量初始化
11        # Animal.__init__(self,variety, sex) 与上一句等价
12         self.name = name
13     def bark(self):# 重构方法
14         print('Wang, Wang ,Wang!')
15     def run(self):  #增添新功能
16         print('Dog[%s] can run'% self.name)
17 
18 class Bird(Animal): # 继承Animal父类
19     def __init__(self, variety, sex, color):
20         super( Bird, self).__init__(variety, sex) #继承父类变量
21         self.color = color
22     def fly(self):  #增添新功能
23         print('Birds with %s feather  can fly' % self.color)
24 dog =  Dog('TaiDi', 'M', '旺财')
25 bird = Bird('Parrot', 'F', 'Blue')
26 dog.bark()
27 dog.run()
28 bird.bark()

执行结果：

1 Wang, Wang ,Wang!
2 Dog[旺财] can run
3 Parrot is barking
4 Birds with Blue feather  can fly

1）在Python中，如果父类和子类都重新定义了构造方法__init( )__，在进行子类实例化的时候，子类的构造方法不会自动调用父类的构造方法，必须在子类中显示调用（第9，10、11行代码，19，20行代码）。

2）如果需要在子类中调用父类的方法（属于类方法），需要以”父类名.方法“这种方式调用，以这种方式调用的时候，注意要传递self参数过去。

　　对于继承关系，子类继承了父类所有的公有属性和方法，可以在子类中通过父类名来调用，而对于私有的属性和方法，子类是不进行继承的，因此在子类中是无法通过父类名来访问的。

2、多继承

Python同样有限的支持多继承形式。多继承的类定义形如下例：

1 class DerivedClassName(Base1, Base2, Base3):
2     <statement-1>
3     .
4     .
5     .
6     <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找父类中是否包含方法。

多继承中对方法的查找有两种方式：

　　深度优先：类是经典类时，多继承情况下，会按照深度优先方式查找

　　广度优先：类是新式类时，多继承情况下，会按照广度优先方式查找

（在python3.x中）都默认为广度优先，但还是可以了解一下两个的区别，新式类：当前类或者基类继承了objiect类就叫新式类，否者就是经典类

在python 2.7

#python2.7中经典类
class A():
    def name(self):
        print("AAAAAA")
class B(A):
    pass
class C(A):
    def name(self):
        print("CCCCCC")
class D(B,C):
    pass
a1=D()
a1.name()   #输出：AAAAAA
#查找顺序:# 首先去自己D类中查找，如果没有，则继续去B类中找，没有则继续去A类中找，没有则继续去C类中找，如果还是未找到，则报错
#深度优先：D-B-A-C

#python3.7中新式类
class A(object):
    def name(self):
        print("AAAAAA")
class B(A):
    pass
class C(A):
    def name(self):
        print("CCCCCC")
class D(B,C):
    pass
a1=D()
a1.name()   #输出：CCCCCC
#查找顺序:# 首先去自己D类中查找，如果没有，则继续去B类中找，没有则继续去C类中找，没有则继续去A类中找，如果还是未找到，则报错
#广度优先：D-B-C-A

在python3.X之后就没有了上面的这些区别，它的查找顺序都是 广度优先

三、多态

　　多态即多种形态，在运行时确定其状态，在编译阶段无法确定其类型，这就是多态。Python中的多态和Java以及C++中的多态有点不同，Python中的变量是弱类型的，在定义时不用指明其类型，它会根据需要在运行时确定变量的类型（个人觉得这也是多态的一种体现），并且Python本身是一种解释性语言，不进行预编译，因此它就只在运行时确定其状态，故也有人说Python是一种多态语言。在Python中很多地方都可以体现多态的特性，比如内置函数len(object)，len函数不仅可以计算字符串的长度，还可以计算列表、元组等对象中的数据个数，这里在运行时通过参数类型确定其具体的计算过程，正是多态的一种体现。这有点类似于函数重载（一个编译单元中有多个同名函数，但参数不同），相当于为每种类型都定义了一个len函数。这是典型的多态表现。有些朋友提出Python不支持多态，我是完全不赞同的。

　　本质上，多态意味着可以对不同的对象使用同样的操作，但它们可能会以多种形态呈现出结果。len(object)函数就体现了这一点。在C++、Java、C#这种编译型语言中，由于有编译过程，因此就鲜明地分成了运行时多态和编译时多态。运行时多态是指允许父类指针或名称来引用子类对象，或对象方法，而实际调用的方法为对象的类类型方法，这就是所谓的动态绑定。编译时多态有模板或范型、方法重载（overload）、方法重写（override）等。而Python是动态语言，动态地确定类型信息恰恰体现了多态的特征。在Python中，任何不知道对象到底是什么类型，但又需要对象做点什么的时候，都会用到多态。

能够直接说明多态的两段示例代码如下：
1、运算符多态

 1 class Myclass():
 2     def __init__(self, a, b):
 3         self.a = a
 4         self.b = b
 5     def add(self):
 6         print(self.a + self.b)
 7 cls1 = Myclass(1,5)
 8 cls2 = Myclass('hello ', 'world')
 9 cls1.add()
10 cls2.add()

执行结果：

1 6
2 hello world

2、方法多态有一种称为”鸭子类型“的东西，讲的也是多态：

 1 class Duck(object):
 2     def quack(self):
 3         print("Quaaaaaack!")
 4     def feathers(self):
 5         print("The duck has white and gray feathers.")
 6 
 7 class Person:
 8     def quack(self):
 9         print(  "The person imitates a duck.")
10     def feathers(self):
11         print("The person takes a feather from the ground and shows it.")
12 
13 def in_the_forest(duck):
14     duck.quack()
15     duck.feathers()
16 
17 donald = Duck()
18 john = Person()
19 in_the_forest(donald)
20 in_the_forest(john)

执行结果：

Quaaaaaack!
The duck has white and gray feathers.
The person imitates a duck.
The person takes a feather from the ground and shows it.