第十章:类和对象(36-37课时)

向西而笑

           36课时：给大家介绍对象
对象的基本概念封装：把乱七八糟的东西扔到列表里就是数据层面的封装，把常用的代码段打包成一个函数就是语句层面的封装。对象就是两者的合二为一，即把数据和代码封装在一起，是一种更高级别的封装。

对象 = 属性 + 方法
属性即静态的特征，方法即动态的特征。在实际的编程中，属性是变量，方法是函数。

类和对象的关系两者犹如模具和模具制作出来的东西。一个类为他的全部对象给出了统一的定义，而他的每个对象则是符合这个定义的实体。因此类和对象的关系就是抽象和具体的关系。比如我们定义了一个‘猫类’，那么‘猫’实例化的对象有:波斯猫、Tom(猫和老鼠动画片)叮当猫、HelloKitty、黑猫警长......
类的属性定义应该尽可能地抽象，因为这样更符合面向对象的思维。
例子：

1. >>> class Cat:
   
2.     #属性定义
   
3.     legs = 4 #四条腿
   
4.     tail = True #有尾巴
   
5.     skil = ('climb tree','catch rat') #技能有爬树、抓老鼠
   
6.     #方法定义
   
7.     def voice(self):
   
8.         print('喵~喵~')
   
9.     def duty(self):
   
10.         print('那有只老鼠，又是一顿美味的大餐...')
    
11. 
    
12.       
    
13. >>> tom = Cat()
    
14. >>> tom.voice()
    
15. 喵~喵~
    
16. >>> tom.duty()
    
17. 那有只老鼠，又是一顿美味的大餐...
    
18. >>> tom.legs
    
19. 4
    
20. >>> tom.tail
    
21. True

复制代码

上面的例子里先定义了一个类—Cat,这个类有三条属性和两个方法。
然后我在把这个类给实例化，tom也拥有了Cat的属性和方法。



面向对象的几个特征：封装性、继承性和多态性

封装性：对外部隐藏对象的工作细节。
继承性：子类自动共享父类属性和方法的机制。
举例：

1. >>> class My_list(list):
   
2.    pass
   
3. 
   
4. >>> list2 = My_list()
   
5. >>> list2.extend([4,3,6,5,2,1])
   
6. >>> list2
   
7. [4, 3, 6, 5, 2, 1]
   
8. >>> list2.sort()
   
9. >>> list2
   
10. [1, 2, 3, 4, 5, 6]

复制代码

上例中新的子类My_list继承了父类list，所以拥有list所有的属性和方法，所以实例化的list2能够使用list的extend()和sort()方法。
多态性：可以对不同对象调用相同的方法，得到不同的结果。
举例：

1. >>> class Tiger:
   
2.    def run(self):
   
3.           print('随风奔跑自由是方向....')
   
4. >>> class Lion:
   
5.    def run(self):
   
6.           print('追逐闪电和雷的力量...')
   
7. >>> t = Tiger()
   
8. >>> l = Lion()
   
9. >>> t.run()
   
10. 随风奔跑自由是方向....
    
11. >>> l.run()
    
12. 追逐闪电和雷的力量...

复制代码

上例中t和l都调用了run()方法,却得到不同的结果这就是多态性的体现。



               37课时：面向对象编程
类方法中的self参数在类中的方法定义中都要定义一个self参数，这有什么作用呢？相当于C里面的this指针，当类实例化后调用方法使得程序知道是哪个对象调用的。举例：

1. >>> class Ball:
   
2.    def setName(self,name):
   
3.           self.name = name
   
4.    def kick(self):
   
5.           print('我叫%s，卧槽，谁踢我...'%self.name)
   
6. 
   
7.          
   
8. >>> a = Ball()
   
9. >>> a.setName('球A')
   
10. >>> a.kick()
    
11. 我叫球A，卧槽，谁踢我...
    
12. >>> b = Ball()
    
13. >>> b.setName('土豆')
    
14. >>> b.kick()
    
15. 我叫土豆，卧槽，谁踢我...

复制代码

python的魔法方法魔法方法就是可以给你的类增加“魔力”的特殊方法，如果你的对象实现了这些方法中的某一个，那么这个方法就会在特殊的情况下被调用，而这一切是自动发生的......这些魔法方法是被双下划线包围，如__init__,__eq__......
__init__(self):我们把这个特殊方法称作构造方法。实例化对象是可以传入参数的，这些参数会自动的传入到__init__方法中（__init__(self,param1,param2...)）我们可以重写这个方法来自定义对象的初始化操作。例如：

1. >>> class Ball:
   
2.    def __init__(self,name):
   
3.           self.name = name
   
4.    def kick(self):
   
5.           print('我叫%s,该死的,谁踢我...'%self.name)
   
6. 
   
7.          
   
8. >>> b = Ball('土豆')
   
9. >>> b.kick()
   
10. 我叫土豆,该死的,谁踢我...

复制代码

上例实例化对象b时传入了一个参数‘土豆’，所以调用kick()方法时显示了传入的参数。还可以设置默认参数，这样可以直接调用kick()方法，如：

1. >>> class Ball:
   
2.    def __init__(self,name='呃，我是个球'):
   
3.           self.name = name
   
4.    def kick(self):
   
5.           print('我叫%s,该死的,谁踢我...'%self.name)
   
6. 
   
7.          
   
8. >>> c = Ball()
   
9. >>> c.kick()
   
10. 我叫呃，我是个球,该死的,谁踢我...

复制代码

公有和私有
python里的属性和方法默认是公有的。在Python中定义私有变量只要在变量名或函数名前加上’__’两个下划线，那么这个函数或变量就变成私有的了。
例子：

1. >>> class Person:
   
2.    name = '小甲鱼'
   
3. >>> p = Person()
   
4. >>> p.name
   
5. '小甲鱼'
   
6. >>> class Person:
   
7.    __name = '小甲鱼'
   
8. >>> p = Person()
   
9. >>> p.name
   
10. Traceback (most recent call last):
    
11.   File "<pyshell#8>", line 1, in <module>
    
12.     p.name
    
13. AttributeError: 'Person' object has no attribute 'name'

复制代码

上面的例子加上了__就不能访问name这个属性了。但是还是有办法访问的，其实程序是在__变量前面加上了_类名，变成了_类名__变量名

1. >>> class Person:
   
2.         __name = '小甲鱼'
   
3. >>> p = Person()
   
4. >>> p._Person__name
   
5. '小甲鱼’
   

复制代码