Python面向对象的三大特性(封装 、继承、多态)

前言：面向对象的三大特征

1.封装:根据职责将属性和方法封装到一个抽象的类中

2.继承:实现代码的重用，相同的代码不需要重复的写

3.多态:不同的对象调用相同的方法,产生不同的结果,增加代码的灵活度

 

一、封装

1.基本概念

封装是从业务逻辑中抽象对象时，要赋予对象相关数据与操作，将一些数据和操作打包在一起的过程

 封装是面向对象的一大特点,

面向对象编程的第一步 将属性和方法封装到一个抽象的类中

外界使用类创建对象,然后让对象调用方法

对象方法的细节都被封装在类的内部

---

2.实例演示

需求<1>：跑步类型

xx爱跑步
1.xx 的体重是75.0公斤
2.xx 每次跑步之后体重减轻0.5公斤
3.xx 每次吃东西之后体重增加1公斤

 具体代码如下：

class Person:
    def __init__(self, new_name, weight):
        self.name = new_name
        self.weight = weight

    def __str__(self):
        return 'my name is %s weight is %.2f' % (self.name, self.weight)

    def run(self):
        print '%s likes to run ' % self.name
    # 在对象的方法内部,是可以直接访问对象的属性
        self.weight -= 0.5

    def eat(self):
        print '%s likes to eat ' % self.name
        self.weight += 1


tom = Person('tom', 75.0)
tom.run()
tom.eat()
print tom

lily = Person('lily', 50.0)
lily.run()
lily.eat()
print lily

执行结果如下：

需求<2>：摆放家具

1.房子有户型，总面积和家具名称列表
新房子没有任何家具
2.家具有名字和占地面积，其中
床：占4平米
衣柜：占2平米
餐桌：占1.5平米
3.将以上三间家具添加到房子中
4.打印房子时，要求输出：户型，总面积，剩余面积，家具名称列表

 代码如下:

# 先定义家具类
class HouseItem():
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return '[%s] 占地 %.2f ' % (self.name, self.area)


# 定义房子类
class House():
    def __init__(self, house_type, area):
        self.house_type = house_type
        self.area = area
        # 剩余面积
        self.free_area = area
        # 家具列表名称
        self.item_list = []

    def __str__(self):
        return '户型:%s\n总面积:%.2f[剩余:%.2f]\n家具列表:%s' \
               % (self.house_type, self.area, self.free_area, self.item_list)

    def add_item(self, item):
        print '要添加%s' % item
        # 1.判断家具的面积
        if item.area > self.free_area:
            print '%s 面积过大,无法放置' % item
            # 如果不满足,下方代码不执行
            return
        # 2.将家具的名称添加至列表中
        self.item_list.append(item.name)
        # 3.计算剩余面积
        self.free_area -= item.area


# 创建家具对象
bed = HouseItem('bed', 4)
print bed
chest = HouseItem('chest', 2)
print chest
table = HouseItem('table', 1.5)
print table

# 创建房子对象
my_home = House('三室两厅', 100)

# 添加家具
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print my_home

代码执行结果如下:

需求<3>：士兵射击

1.士兵瑞恩有一把AK47

2.士兵可以开火

3.枪能够发射子弹（减少子弹数量 ）

4.枪能够装填子弹 （增加子弹的数量）

代码如下:

lass Gun:
    def __init__(self, model):
        # 枪的型号
        self.model = model
        # 子弹的数量
        self.bullet_count = 0

    def add_bullet(self, count):
        self.bullet_count += count

    def shoot(self):
        # 1.判断子弹的数量
        if self.bullet_count <= 0:
            print '%s 没有子弹了' % self.model
            return
        # 2.发射子弹
        self.bullet_count -= 1
        # 3.提示发射信息
        print '%s biu biu biu %d' % (self.model, self.bullet_count)


class Soldier:
    def __init__(self, name):
        self.name = name
        self.gun = None

    def fire(self):
        if self.gun == None:
            print '%s 没有枪' % self.name
            return
        self.gun.add_bullet(50)
        print 'go ! %s' % self.name
        self.gun.shoot()


# 1.创建枪对象
ak47 = Gun('AK47')
ak47.add_bullet(50)
ak47.shoot()

# 2.创建士兵对象
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
print ryan.gun

二、继承

1.基础概念

继承是为代码复用而设计的，是面向对象的重要特性之一。当设计一个新类的时候，如果可以继承一个已有的设计良好的类然后进行二次开发，无疑会大幅度减少工作量。

在继承关系中，已有的、设计好的类称为父类或基类，新设计的类称为子类或派生类，派生类可以继承弗雷的公有成员，但不能继承其私有成员。

Python支持多继承，如果父类中有相同的方法名，而在子类中使用时内有指定父类名，则pyhton解释器将从左向右按顺序进行搜索

2.单继承

子类拥有父类的所有属性和方法（子类只需封装自己特有的方法）

继承的语法： class 类名（父类）

               def  子类特有的方法

# 继承的传递性,子类可以继承父类和父类的父类的所有属性和方法

实例<1>:单继承以及继承的传递

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 'miaomiao~'


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


cat = Hellokitty()
cat.call()
cat.drink()
cat.eat()
cat.run()
cat.sleep()
cat.speak()

实例<2>:重写父类方法

重写父类方法有两种情况：

1.覆盖父类的方法；

在开发中，父类的方法的实现和子类方法的实现完全不同，就可以用覆盖的方式

具体实现方式，就相当于在子类中定义了一个和父类同名的方法并且实现

重写之后，在运行时候，只会调用子类的重写方法，而不会再调用父类封装的办法

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 'miaomiao~'


class Hellokitty(Cat):
    def speak(self):
        print '我会说日语'
    def call(self):
        print '你好！'
        #覆盖原本在父类中封装的方法

cat = Hellokitty()
cat.call()

2.对父类的方法进行扩展

如果在开发中，子类的方法实现包含有父类的方法实现

（父类原本封装的方法实现是子类方法的一部分就可以使用扩展方法）

<1>在子类中重写父类的方法

<2>在需要的位置使用父类名.方法(self) 来调用父类方法的执行(使用父类名称调用父类方法)

<3>代码其他的位置根据子类的需求,编写子类特有的代码实现

代码如下：

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 'miaomiao~'


class Hellokitty(Cat):
    def speak(self):
        print '我会说日语'
    def call(self):
        print '你好！'
        #调用原本在父类中封装的方法
        Cat.call(self)
cat = Hellokitty()
cat.call()

运行结果：

实例<3>：对初始化方法的重写

 

class Bird():
    def __init__(self):
        self.hunger = True

    def eat(self):
        if self.hunger:
            print '嗝!~~'
            self.hunger = False
        else:
            print 'no,thanks !'


class SongBird(Bird):
    def __init__(self):
        self.sound = 'jijizhazha!'
        Bird.__init__(self)

    def sing(self):
        print self.sound


Vbird = SongBird()
Vbird.eat()
Vbird.sing()

3.多继承

子类拥有一个父类叫做单继承
子类可以拥有多个父类,并且具有所有父类的属性和方法
语法：
class 子类名称 (父类名1,父类名2...)
    pass

实例1：

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


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

class C(A,B):
    pass


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

实例2：

当两个父类同时拥有相同的方法名，只执行子类继承中先出现的父类的方法

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

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


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

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


class C(B,A):
    """多继承可以让子类对象同时具有多个父类的属性和方法"""

    pass


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

三、多态

1.基础概念

不同的子类对象调用相同的方法，产生不同的执行结果

多态意味着多种形式，当用面向对象时，它是指对象是怎么回应一个依赖于对象类型或种类的消息。多态的作用是让程序在不同情况下用一个函数名启用不同的方法

2.实例演示

class Dog(object):
    def __init__(self, name):
        self.name = name

    def game(self):
        print '%s 蹦蹦跳跳' % self.name


class Xtdog(Dog):
    def game(self):
        print '%s 欢欢乐乐' % self.name


class Person(object):
    def __init__(self, name):
        self.name = name

    def play_with(self, dog):
        print '%s 和 %s 欢乐的玩' % (self.name, dog.name)
        dog.game()


# 1.创建一个DOG对象
dog = Xtdog('中华田园犬')
# 2.创建一个person对象
lee = Person('lee')
# 让lee和dog玩耍
lee.play_with(dog)

另一个状态：

四、新式类、旧式类

1.新式类[object为基类]
 

In [1]: class A(object):
   ...:     pass
   ...:

In [2]: a = A()
# dir可以查看调用的方法有哪些
In [3]: dir(a)

 

2.旧式类[经典类]
 

In [5]: class B():
   ...:     pass
   ...:

In [6]: b = B()

In [7]: dir(b)