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

封装

例题：
1.小明体重75.0公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西会增重1公斤
class Person:
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
        print('%s 的体重是 %.2f' %(self.name,self.weight))
    def run(self):
        self.weight -= 0.5
        return '%s 每次跑步体重会减少' %(self.name)
    def eat(self):
        self.weight += 1
        return  '%s 吃东西体重增加' %(self.name)

xiaoming  = Person('小明',75)
print(xiaoming.eat())

结果:
小明 的体重是 75.00
小明 吃东西体重增加

1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量
class Gun:
    def __init__(self,model):
        self.model = model
        self.bulletcount = 0
    def addbllet(self,count):
        self.bulletcount +=count
    def shot(self):
        if self.bulletcount <= 0 :
            print('%s 没有子弹了' %s(self.model))
            return
        self.bulletcount -=1
        print('%s还有%d个子弹' %(self.model,self.bulletcount))


class Soldir:
    def __init__(self,name):
        self.name = name
        self.gun = None
    def fire(self):
        if self.gun ==None:
            print('%s 没有枪' %(self.name))
            return
        self.gun.addbllet(50)
        self.gun.shot()

ak47 = Gun('ak47')
ryan = Soldir('ryan')
ryan.gun = ak47
ryan.fire()

结果：
ak47还有49个子弹

继承

class Animal():
    def eat(self):
        print('吃~~~~~')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')

class Cat(Animal):
    def call(self):
        print('喵～')

fentiao = Cat()
fentiao.eat()
fentiao.run()
fentiao.call()

结果：
吃~~~~~
跑
喵～

如果子类重写了父类的方法
在运行中，只会调用在子类中重写的方法而不会调用父类方法
class Cat():
    def call(self):
        print('喵～')

class HelloKitty(Cat):
    def speak(self):
        print('我能说英语')
    def call(self):
        print('@#@$@$@#@!#')

kt = HelloKitty()
kt.call()

结果：
@#@$@$@#@!#

如果子类重写父类的方法后，还想调用父类的方法
class Animal:
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def call(self):
        print('$$$$$')
class Cat(Animal): #继承
    def call(self):
        super().call() #调用原本在父亲类的封装方法,如果没有这一行那么.call只有喵，会覆盖之前父类的
        print('喵')

kt=Cat()
kt.eat()
kt.drink()
kt.call()

结果：
吃
喝
$$$$$
喵

子类可以继承父类的所有属性和方法
继承具有传递性，子类拥有父类的父类的属性和方法
class Animal():
    def eat(self):
        print('吃~~~~~')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')

class Cat(Animal):
    def call(self):
        print('喵～')

class HelloKitty(Cat):
    def speak(self):
        print('我能说英语')

class Dog(Animal):
    def bark(self):
        print('汪～')

kt = HelloKitty()
kt.eat()
kt.speak()

结果:
吃~~~~~
我能说英语

多态

class Dog(object):
    def __init__(self,name):
        self.name=name
    def game(self):
        print('%s 开心的玩' %(self.name))

class Gaofei(Dog):
    def game(self):
        print('%s 和米老鼠一起玩'%(self.name))

class Person(object):
    def __init__(self,name):
        self.name=name
    def gamewith_dog(self,dog): #dog作为一个变量，而不是名称
       # self.dog=dog
        print('%s和%s玩' %(self.name,dog.name))

wangcai = Gaofei('高飞')
dabai = Dog('大白')
xiaoming = Person('小明')
xiaoming.gamewith_dog(wangcai)
xiaoming.gamewith_dog(dabai)

结果：
小明和高飞玩
小明和大白玩