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

一、封装
1.将属性和方法封装到一个抽象的类中
2.外界使用类创建对象，对象调用方法
3.对象方法的细节都被封装在类的内部

需求
1.李雷体重75.0公斤
2.李雷每次跑步会减肥0.5公斤
3.李雷每次吃东西体重会增加1公斤

需求
1.李雷和韩梅梅都爱跑步
2.韩梅梅体重45.0公斤
3.李雷体重75.0公斤
4.每次跑步都会减少0.5公斤
5.每次吃东西都会增加1公斤

“”"

class Person():
def init(self,name,weight):
self.name = name
self.weight = weight
def str(self):
return ‘我的名字叫 %s 体重是 %.2f’ %(self.name,self.weight)
def run(self):
print(’%s爱跑步’ %self.name)
self.weight -= 0.5
def eat(self):
print(’%s吃东西’ %self.name)
self.weight += 1

Lilei = Person(‘李雷’,75.0)
Lilei.run()
print(Lilei)
Lilei.eat()
print(Lilei)

二、继承

继承：实现代码的重用，相同的代码不需要重复的写
子类继承自父类，可以直接享受父类中已经封装好的方法
子类中应该根据职责，封装子类特有的属性和方法
“”"

class Animal():

    def eat(self):
        print('吃')

    def drink(self):
        print('喝')

    def run(self):
        print('跑')

    def sleep(self):
        print('睡')
class Cat(Animal):

    def shout(self):
        print('喵')

fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
fentiao.shout()

运行结果为：
吃
喝
跑
睡
喵

子类可以继承父类的所有属性和方法
继承具有传递性，子类拥有父类的父类的属性和方法

class Animal():

    def eat(self):
        print('吃')

    def drink(self):
        print('喝')

    def run(self):
        print('跑')

    def sleep(self):
        print('睡')

class Cat(Animal):
    def shout(self):
        print('喵')


class Hellokitty(Cat):
    def speak(self):
        print('我会说日语')

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

kt = Hellokitty()
kt.speak()

kt.shout()

kt.eat()
kt.sleep()

运行结果为：
我会说日语
喵
吃
睡

当父类方法不能满足子类的需求时？可以对方法进行重写
1.覆盖父类的方法
2.对父类的方法进行扩展
3.如果子类中，重写了父类的方法
4.在运形时，只会调用在子类中重写的方法
“”"

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

class Cat(Animal):
    def shout(self):
        print('喵')

class Hellokitty(Cat):
    def speak(self):
        print('我可以说日语')
    def shout(self):
        print('@#$%%@$#@#@$')

kt = Hellokitty()

kt.shout()
 
 结果为：
 @#$%%@$#@#@$

多继承：子类拥有多个父类叫多继承，拥有所有父类的属性和方法

class A():
    def test(self):
        print('A --- test方法')
    def demo(self):
        print('A --- demo方法')

class B():
    def test(self):
        print('B --- test 方法')
    def demo(self):
        print('B --- demo方法')

class C(A,B):
    pass

c = C()
c.test()
c.demo()

结果为：
A --- test方法
A --- demo方法

三、多态

子类和父类存在相同方法时，子类会覆盖父类方法
运形时总会调用子类方法–> 多态

class Animal(object):
    def run(self):
        print('running...')
    def cry(self):
        print('crying...')

class Dog(Animal):
    def run(self):
        print('dog running...')

    def eat(self):
        print('dog eating...')

class Cat(Animal):
    def run(self):
        print('cat running...')

cat = Cat()
cat.run()

dog = Dog()
dog.run()

结果为：
cat running...
dog running...

多态(以封装和继承为前提)
不同的子类对象调用相同的方法，产生不同的执行结果
Person()
work(self)

class Dog(object):
    def __init__(self, name):
        self.name = name
    def game(self):
        print('%s 开心的玩～～～' % (self.name))
class Gaofei(Dog):
    # 父类的方法不能满足子类的需求，重写game方法
    def game(self):
        print('%s 和米老鼠一起玩～～～' % (self.name))
class Person(object):
    def __init__(self,name):
        self.name = name
    def game_with_dog(self,dog):
        print('%s 和 %s 玩～～～' %(self.name,dog.name))
        dog.game()
创建一个狗对象
#wangcai = Gaofei('高飞')
wangcai = Dog('大黄')
创建一个人对象
xiaoming = Person('小明')
让小明和狗玩
xiaoming.game_with_dog(wangcai)
 
 运行结果为：
 小明 和 大黄 玩～～～
大黄 开心的玩～～～

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

猜你喜欢