python的面向对象的特性（继承封装多态）

Posted 2020-08-19

创建自已对象就python非常核心的概念，事实上，python被称为面向对象语言，本章会介绍如何创建对象。以及面向对象的概念：继承、封装、多态。

多态： 可对不同类的对象使用同样的操作。
封装：对外部世界隐藏对象的工作细节。
继承：以普通的类为基础建立专门的类对象。


多态
面向对象程序设计最有趣的特性是多太，它是是让大多数人犯晕的特性。所以，先来介绍这个。
多态意思是“有多种形式”。多态意味着就算不知道变量所引用的对象类是什么，还是能对它进行操作，而它也会根据对象（或类）类型的不同而表现出不同的行为。

从最简单的开始
　　任何不知道对象到底是什么类型，但是又要对对象“做点什么”的时候，都会用到多态。这不仅限于方法----很多内建运算符和函数都有多态的性质，考虑下面这个例子：

1. >>> 1 + 2
   
2. 3
   
3. >>> ‘fish‘ + ‘license‘
   
4. ‘fishlicense‘

复制代码

这里的加运算符对于数字（本例中为整数）和字符串（以及其他类型的序列）都能起作用。假设有个叫做add的函数，它可以将两个对象相加。那么可以直接将其定义成上面的形式，对于很多类型的参数都可以用，如下：

1. >>> def add(x,y):
   
2.     return x+y
   
3. 
   
4. >>> add(1,2)
   
5. 
   
6. >>> add(‘hello.‘,‘world‘)
   
7. ‘hello.world‘

复制代码

看起来有点傻，但是关键在于参数可以是任何支持加法的对象。

如果需要编写打印对象长度消息的函数，则只需对象具有长度（len函数可用）即可。

1. >>> def length_message(x):
   
2.     print"The length of " , repr(x),"is",len(x)
   
3. 
   
4.    
   
5. >>> length_message(‘chongshi‘)
   
6. The length of  ‘chongshi‘ is 8
   
7. >>> length_message([1,2,3])
   
8. The length of  [1, 2, 3] is 3

复制代码

len函数用于计算长度，repr用于放置函数的内容；repr函数是多态特性的代表之一---可以对任何东西使用。
很多函数和运算符都是多态的，你写的绝大多数程序可能都是，即便你并非有意这样。


封装

封装是对全局作用域中其它区域隐藏多余信息的原则。
封装听起来有些像多态，因为他们都是 抽象的原则---他们都会帮助处理程序组件而不用过多关心多余细节，就像函数做的一样。
但是封装并不等同于多态。多态的可以让用户对于不知道是什么类（或对象类型）的对象进行方法调用，而封装是可以不用关心对象是如何构建的而直接进行使用。
创建一个有对象（通过像调用函数一样调用类）后，将变量c绑定到该对象上。可以使用setName 和 getName 方法（假设已经有）

1. >>> c = closedObject()
   
2. >>> c.setName(‘sir lancelot‘)
   
3. >>> c.getName()
   
4. ‘sir lancelot’

复制代码

继承
我们不想把同一段代码写好几，之前使用的函数避免了这种情况。但现在又有个更微妙的问题。如果已经有了一个类，又想建立一个非常类似的类，只是添加几个方法。
比如有动物类，我们又想在动物类的基础上建立鸟类、鱼类，哺乳动物类。

上面这些特性会根据后面的学习来深入的理解。
================================


创建自己的类

终于可以创建自己的类了，先来看一个简单的类：

1. _metaclass_ = type #确定新式类
   
2. 
   
3. class Person:
   
4.     def setName(self,name):
   
5.         self.name = name
   
6. 
   
7.     def getName(self):
   
8.         return self,name
   
9. 
   
10.     def greet(self):
    
11.         print "Hello, world! I‘m %s" %self.name

复制代码

注意：新式类的语法中，需要在模块或者脚本开始的地方放置赋值语句_metaclass_ = type 。

创建了一个Person的类，这个类包含了三个方法定义，只是那个self看起有点奇怪，它是对于对象自身的引用。
让我们创建实例看看：

1. >>> huhu = Person()
   
2. >>> huhu.setName(‘hu zhiheng‘)
   
3. >>> huhu.greet()
   
4. Hello, world! I‘m hu zhiheng

复制代码

应该能说明self的用处了，在调用huhu的setName 和 greet 函数时，huhu自动将自己作为第一个参数传入函数中----因此形象地命名为self。每个人可能都会有自己的叫法，但是因为它总是对象自身，所以习惯上总是叫做self 。

和之前一样，特性也可以在外部访问：

1. >>> huhu.name
   
2. ‘hu zhiheng‘
   
3. >>> huhu.name = ‘yoda‘
   
4. >>> huhu.greet()
   
5. Hello, world! I‘m yoda

复制代码

特性、函数和方法

self 参数事实上正是方法和函数的区别。方法将它们的第一个参数绑定到所属的实例上，因此这个参数可以不必提供。所以可以将特性绑定到一个普通函数上，这样就不会有特殊的self参数了：

1. >>> class Class:
   
2.     def method(self):
   
3.         print ‘I have a self!‘
   
4. 
   
5.         
   
6. >>> def function():
   
7.     print "I don‘t"
   
8. 
   
9.    
   
10. >>> instance = Class()
    
11. >>> instance.method()
    
12. I have a self!
    
13. >>> instance.method = function
    
14. >>> instance.method()
    
15. I don‘t

复制代码

self参数并不取决于调用方法的方式，目前使用的是实例调用方法，可以随意使用引用同一个方法的其他变量：

1. >>> class Bird:
   
2.     song =  ‘Squaawk!‘
   
3.     def sing(self):
   
4.         print self.song
   
5. 
   
6.         
   
7. >>> bird = Bird()
   
8. >>> bird.sing()
   
9. Squaawk!
   
10. >>> birdsong = bird.sing
    
11. >>> birdsong()
    
12. Squaawk!

复制代码

指定超类

子类可以扩展超类的定义。将其他类名写在class语句后的圆括号内可以指定超类：

1. class Filter:
   
2.     def init(self):
   
3.         self.blocked = []
   
4.     def filter(self , sequence):
   
5.         return [x for x in sequence if x not in self.blocked]
   
6. 
   
7. class SPAMFilter(Filter):  #SPAMFilter是Filter的子类
   
8.     def init(self):        #重写Filter类中的init方法
   
9.         self.blocked = [‘SPAM‘]

复制代码

Filter 是个用于过滤序列的通用类，事实上它不能过滤任何东西：

1. >>> f = Filter()
   
2. >>> f.init()
   
3. >>> f.filter([1,2,3])
   
4. [1, 2, 3]

复制代码

Filter 类的用户在于它可以用作其他类的基类（超类，“java中叫父类”），比如SPAMFilter类，可以将序列中的“SPAM”过滤出来。

1. >>> s = SPAMFilter()
   
2. >>> s.init()
   
3. >>> s.filter([‘SPAM‘,‘SPAMD‘,‘SPAM‘,‘HELLO‘,‘WORLD‘,‘SPAM‘])
   
4. [‘SPAMD‘, ‘HELLO‘, ‘WORLD‘]

复制代码

调查继承

如果想要查看一个类是否是另一个的子类。可以使用内建的issubclass函数：

1. >>> issubclass(SPAMFilter, Filter)
   
2. True
   
3. >>> issubclass(Filter,SPAMFilter)
   
4. False