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

---

---

一、实验目的

掌握类的封装、多态、继承

二、实验原理

面向对象的三大特性是指：封装、继承和多态。

封装：顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

多态：Pyhon不支持Java和C#这一类强类型语言中多态的写法，但它是原生多态，其Python崇尚“鸭子类型”。

三、实验环境

Python 3.6以上

Ipython

PyCharm

四、实验内容

封装

继承

多态

五、实验步骤

1.封装

在使用面向对象的封装特性时，需要：
1.将内容封装到某处
2.从某处调用被封装的内容

1.将内容封装到某处

self 是一个形式参数，

当执行 obj1 = Foo(‘zhangyu’, 5 ) 时，self 等于 obj1；

当执行 obj2 = Foo(‘apple’, 10 ) 时，self 等于 obj2。

所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。

2.从某处调用被封装的内容

调用被封装的内容时，有两种情况：
1.通过对象直接调用
2.通过self间接调用

通过对象直接调用被封装的内容：对象.属性名

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age

obj1 = Foo('zhangyu', 5)
print(obj1.name)    # 直接调用obj1对象的name属性
print(obj1.age)     # 直接调用obj1对象的age属性

obj2 = Foo('apple', 10)
print(obj2.name)    # 直接调用obj2对象的name属性
print(obj2.age)     # 直接调用obj2对象的age属性

执行以上程序输出结果为：

zhangyu

5

apple

10

通过self间接调用被封装的内容。

执行类中的方法时，需要通过self间接调用被封装的内容：

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def detail(self):
        print(self.name)
        print(self.age)

obj1 = Foo('zhangyu', 5)
# Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 zhangyu ；self.age 是 5
obj1.detail()

obj2 = Foo('apple', 10)
# Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 apple ； self.age 是 10
obj2.detail()

执行以上程序输出结果为：

zhangyu

5

apple

10

综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。

2.继承

Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下所示:

class DerivedClassName(BaseClassName1):
    <statement-1>
    .
    .
    .
    <statement-N>

BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:
class DerivedClassName(modname.BaseClassName):

1.继承实例

#!/usr/bin/python3

# 类定义
class people:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))


# 单继承示例
class student(people):
    grade = ''

    def __init__(self, n, a, w, g):
        # 调用父类的构造函数
        people.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))


s = student('zhangyu', 5, 60, 1)
s.speak()

执行以上程序输出结果为：

zhangyu 说: 我 5 岁了，我在读 1 年级

3.多态

“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”

我们并不关心对象是什么类型，到底是不是鸭子，只关心行为。

比如在python中，有很多file-like的东西，比如StringIO,GzipFile,socket。它们有很多相同的方法，我们把它们当作文件使用。

又比如list.extend()方法中,我们并不关心它的参数是不是list,只要它是可迭代的,所以它的参数可以是list/tuple/dict/字符串/生成器等.

鸭子类型在动态语言中经常使用，非常灵活，使得python不像java那样专门去弄一大堆的设计模式。

1.鸭子类型实例

class F1:
    pass


class S1(F1):
    def show(self):
        return 'S1.show'


class S2(F1):
    def show(self):
        return 'S2.show'


def Func(obj):
    print(obj.show())


s1_obj = S1()
Func(s1_obj)

s2_obj = S2()
Func(s2_obj)

执行以上程序输出结果为：

S1.show

---

总结

面向对象的三大特性是指：封装、继承和多态。

封装：顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

多态：Pyhon不支持Java和C#这一类强类型语言中多态的写法，但它是原生多态，其Python崇尚“鸭子类型”。