Python全栈开发记录_第九篇（类的基础_封装_继承_多态）

　　有点时间没更新博客了，今天就开始学习类了，今天主要是类的基础篇，我们知道面向对象的三大特性，那就是封装，继承和多态。内容参考该博客https://www.cnblogs.com/wupeiqi/p/4493506.html

　　之前我们写的都是函数，可以说是面向过程的编程，需要啥功能就直接写啥，但是我们在编写程序的过程中会发现如果多个函数有共同的参数或数据时，我们也必须多次重复去写，此时如果用面向对象的编程方式就会好很多，这也是面向对象的适用场景。

面向对象三大特性：

一、封装（顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容，具体看下面的代码）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: Xiaobai Lei


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

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


p1 = Person('xiaobai', 18)
p1.get_msg()    # Python默认会将p1传给self参数，即：p1.get_msg(p1)，所以，此时方法内部的 self ＝ p1

p2 = Person('xiaoming', 88)
p2.get_msg()    # 此处一样将p2传给self参数

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

二、继承（通俗来说就是继承父类的所有东西，与现实一致）

# 2、继承
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print("%s在吃饭" %self.name)


# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class Teacher(Person):
    def teacher(self):
        print("%s在教书" %self.name)


t1 = Teacher("小白", 18)
t1.eat()
t1.teacher()

# 对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

　　除了上面的单继承以外还有多继承，ython的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先，详情往下看：

当类是经典类时，多继承情况下，会按照深度优先方式查找
当类是新式类时，多继承情况下，会按照广度优先方式查找

经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

经典类多继承如下：

class D:

    def bar(self):
        print('D.bar')


class C(D):

    def bar(self):
        print('C.bar')


class B(D):

    def bar(self):
        print('B.bar')


class A(B, C):

    def bar(self):
        print('A.bar')

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> D --> C
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()


# 对于同一个根需要注意
class D:

    def bar1(self):
        print('D.bar')


class C(D):

    def bar1(self):
        print('C.bar')


class B(D):

    def bar(self):
        print('B.bar')


class A(B, C):

    def bar(self):
        print('A.bar')

a = A()
# 执行bar1方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中没有，按理说应该去D类中找了，但是D类是B和C的同一个根类，所以先不找，先找C，C找不到才会最后找D这个共同的根类
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar1方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar1()

新式类多继承如下：

class D(object):

    def bar(self):
        print('D.bar')


class C(D):

    def bar(self):
        print('C.bar')


class B(D):

    def bar(self):
        print('B.bar')


class A(B, C):

    def bar(self):
        print('A.bar')

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

　　经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错

　　新式类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错

　　注意：在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

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

# Python的鸭子类型
class Duck(object):      #Duck类型

    def walk(self):
        print('i am a duck,and i can walk')

    def swim(self):
        print('i am a duck,and i can swim')


class Cat(object):      #Cat类型

    def walk(self):
        print('i am a cat,and i can walk')

    def swim(self):
        print('i am a cat,and i can swim')


# 实现一个动物walk和swim的功能函数
def walk_swim(animal):
    animal.walk()
    animal.swim()

d = Duck()
c = Cat()

walk_swim(d)
walk_swim(c)

以上就是本节对于面向对象初级知识的介绍，总结如下：

面向对象是一种编程方式，此编程方式的实现是基于对类和对象的使用
类是一个模板，模板中包装了多个“函数”供使用
对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
面向对象三大特性：封装、继承和多态

Python全栈开发记录_第九篇（类的基础_封装_继承_多态）

面向对象三大特性：

猜你喜欢