python：类和对象（二）

OO三大特性： 封装 ，继承 ，多态
方法重写(overiding method)： 子类不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。

---

一. 类和对象

1. 继承

1.1构造函数的继承

• 看个例子：

import random as r

class Fish:
    def __init__(self):
        self.x=r.randint(0,10)
        self.y=r.randint(0,10)

    def move(self):
        self.x -= 1
        print("我的位置是:",self.x,self.y)
        
class Salmon(Fish):
    pass

class Shark(Fish):
    def __init__(self):
        self.hungry = True

    def eat(self):
        if self.hungry:
            print("吃货的梦想就是天天有的吃")
            self.hungry=False
        else:
            print("吃不下了")

• 类对象shark调用move()方法时出现异常：

>>> shark=Shark()
>>> shark.move()

Traceback (most recent call last):
  File "<pyshell#12>", line 1, in <module>
    shark.move()
  File "C:/Users/MY/AppData/Local/Programs/Python/Python37/f.py", line 9, in move
    self.x -= 1
AttributeError: 'Shark' object has no attribute 'x'
>>> 

• 原因：子类中与父类方法同名，父类中的构造方法被覆盖

• 解决：
  1.经典类的写法： 父类名称.init(self,参数1，参数2，…)

import random as r
class Fish:
......

class Shark(Fish):
    def __init__(self):
        Fish.__init__(self)   #此处的self是子类Shark的实例对象
        self.hungry = True
#run起来

>>> shark=Shark()    #可理解为Fish.__init__(shark)
>>> shark.move()
我的位置是: -1 9

 ......

2. 使用：super(子类，self).init(参数1，参数2，…)

import random as r
class Fish:
......
class Shark(Fish):
    def __init__(self):
        super().__init__()
        self.hungry = True
......

2. 多重继承

class  C(Base1,Base2,Base3):
......

3. 组合

组合一般就是把横向之间几个没有关系的类放在一个类里面使用
实例化放到新类里。。
先定义两个单独没有关系的类：

class Turtle:
    def __init__(self, x):
        self.num = x

class Fish:
    def __init__(self, x):
        self.num = x

再定义一个组合类：

class Pool:
    def __init__(self,x,y):
        self.Turtle=Turtle(x)   #实例化一个乌龟对象，并且存入变量x
        self.Fish=Fish(y)  #实例化一个鱼的对象，并且存入变量y

    def printNum(self):
        print('水池里共有乌龟 %d 只，小鱼 %d 条'%(self.Turtle.num,self.Fish.num))

调用：

pool=Pool(1,10)
pool.printNum()

4. 类、对象

类
对象

>>> class C:
	count = 0

	
>>> a=C()
>>> b=C()
#改变对象.属性无法改变内部count的值
>>> a.count
0
>>> b.count
0
>>>a.count += 100
>>>a.count
>>>100
>>>b.count
>>>0
#改变类.count的属性，我们发现这改变了内部count的值
>>> C.count += 100
>>> a.count
100
>>> b.count
100
>>> 

5. 绑定

由于既可以通过实例对象也可以通过类对象来访问方法，所以在Python里有两种风格：

未绑定的类方法：没有self
通过类来引用方法返回一个未绑定方法对象。要调用它，你必须显示地提供一个实例作为第一个参数。

>>> class Test:
	def func(message):
		print("%s" % message)
		
>>> Test.func("a")
a		

绑定的实例方法：有self
通过实例访问方法返回一个绑定的方法对象。Python自动地给方法绑定一个实例，所以我们调用它时不用再传一个实例参数。

>>> class Test:
	def func(self,message):
		self.message=message
		print("%s" % self.message)
		
>>> t=Test()
>>> t.func("a")
a