Python基础之——13_面向对象编程三大特性

目录

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

一、对象和类

1、什么是类？什么是对象？

2、如何定义类和对象

二、封装特性

三、继承特性

1、继承的定义

2、如何实现继承？继承的工作机制是什么？

3、重写父类及调用父类的方法

4、多继承

5、新式类与经典类

6、私有属性和私有方法

四、多态特性

1、多态的定义

2、多态的优势

五、实验操作

5.1 类和对象

5.2 封装特性

5.3 巩固封装特性

5.4 继承的实现

5.5 重写父类方法

5.6 巩固练习——链表的封装

5.7 多继承

5.8 私有属性和私有方法

---

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

一、对象和类

1、什么是类？什么是对象？

       类（Class）是现实或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。

      对象(Object)是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。

类和对象 的区别就是 鱼和三文鱼 的区别; 就是 猫和蓝猫 的区别。

2、如何定义类和对象

1. 如何定义类?   

        class 类():   pass

2. 如何将类转换成对象?

        实例化是指在面向对象的编程中，把用类创建对象的过程称为实例化。是将一个抽象的概念类，具体到该类实物的过程。实例化过程中一般由类名 对象名 = 类名（参数1，参数2...参数n）构成。

类（Class）是是创建实例的模板

对象(Object)是一个一个具体的实例

二、封装特性

1、封装的定义

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

所以，在使用面向对象的封装特性时，需要：

1). 将内容封装到某处

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

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

2). 通过self间接调用被封装的内容：  self.属性名

3). 通过self间接调用被封装的内容:    self.方法名()

构造方法__init__与其他普通方法不同的地方在于，当一个对象被创建后，会立即调用构造方法。自动执行构造方法里面的内容。

    对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过

对象直接或者self间接获取被封装的内容。

三、继承特性

1、继承的定义

         继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、Superclass)。

2、如何实现继承？继承的工作机制是什么？

        问题一: 如何让实现继承?

  子类在继承的时候,在定义类时,小括号()中为父类的名字

       问题二: 继承的工作机制是什么?

        父类的属性、方法,会被继承给子类。 举例如下:  如果子类没有定义__init__方法,父类有,那么在子类继承父类的时候这个方法就被继承了,所以只要创建对象,就默认执行了那个继承过来的__init__方法。

3、重写父类及调用父类的方法

重写父类方法:  就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法。

调用父类的方法:

  1. 父类名.父类的方法名()

  2. super(): py2.2+的功能

4、多继承

多继承,即子类有多个父类,并且具有它们的特征

5、新式类与经典类

定义：

在Python 2及以前的版本中，由任意内置类型派生出的类，都属于“新式类”，都会获得所有“新式类”的特性；反之，即不由任意内置类型派生出的类，则称之为“经典类”。

“新式类”和“经典类”的区分在Python 3之后就已经不存在，在Python 3.x之后的版本，因为所有的类都派生自内置类型object(即使没有显示的继承object类型)，即所有的类都是“新式类”。

 区别：

最明显的区别在于继承搜索的顺序不同，即：

        经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找，然后再返回，开始查找右侧。

        新式类多继承搜索顺序(广度优先算法):先在水平方向查找，然后再向上查找，

6、私有属性和私有方法

默认情况下,属性在 Python 中都是“public”， 大多数 OO 语言提供“访问控制符”来限定成员函数的访问。

在 Python 中,实例的变量名如果以 __ 开头,就变成了一个私有变量/属性(private),实例的函数名如果以 __ 开头,就变成了一个私有函数/方法(private)只有内部可以访问,外部不能访问。

问题: 私有属性一定不能从外部访问吗?

python2版本不能直接访问 __属性名 是因为 Python 解释器对外把  __属性名 改成了  _类名__属性名 ,所以,仍然可以通过 _类名__属性名  来访问 __属性名 。

因为不同版本的 Python 解释器可能会把 __属性名  改成不同的变量名。

优势：

     1. 确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护,代码更加健壮。

      2. 如果又要允许外部代码修改属性怎么办?可以给类增加专门设置属性方法。 为什么大费周折?因为在方法中,可以对参数做检查,避免传入无效的参数。

四、多态特性

1、多态的定义

        多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。

通俗来说： 同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

2、多态的优势

        多态的好处就是，当我们需要传入更多的子类，只需要继承父类就可以了，而方法既可以直接不重写（即使用父类的），也可以重写一个特有的。这就是多态的意思。调用方只管调用，不管细节，而当我们新增一种的子类时，只要确保新方法编写正确，而不用管原来的代码。这就是著名的“开闭”原则：

        对扩展开放（Open for extension）：允许子类重写方法函数

        对修改封闭（Closed for modification）：不重写，直接继承父类方法函数

五、实验操作

5.1 类和对象

# 类(Class)
class Cat:
    # 属性：一般是名词，eg: name, age, gender.....
    name = 'name'
    kind = 'kind'
    # 方法: 一般情况是动词, eg: create, delete, eating, run......
    def eat(self):
        print('cat like eating fish.....')

# 对象(Object):对类的实例化(具体化)
fentiao = Cat()
fentiao.name = 'tudou'
fentiao.kind = 'blue'
fentiao.eat()

print(Cat)  # <class '__main__.Cat'>
print(fentiao) # <__main__.Cat object at 0x00E9FD70>

5.2 封装特性

# 类(Class)
class Cat:
    def __init__(self, name, kind):  # 形参
        """
        1. 构造方法，实例化对象时自动执行的方法
        2. self是什么? self实质上是实例化的对象
        3. 类方法中, python解释器会自动把对象作为参数传给self
        """
        print('正在执行__init__构造方法')
        print('self:', self)
        # 属性：一般是名词，eg: name, age, gender.....
        # 封装: self.name将对象和name属性封装/绑定
        self.name = name
        self.kind = kind

    # 方法: 一般情况是动词, eg: create, delete, eating, run......
    def eat(self):
        print('cat %s like eating fish.....' % (self.name))


# 对象(Object):对类的实例化(具体化)
fentiao = Cat("粉条", "美短虎斑")
print(fentiao.name)
print(fentiao.kind)
fentiao.eat()

5.3 巩固封装特性

"""
创建一个类People,
拥有的属性为姓名， 性别和年龄，
拥有的方法为购物,玩游戏,学习;

实例化 对象,执行相应的方法。

显示如下:
小明,18岁,男,去西安赛格购物广场购物
小王,22岁,男,去西安赛格购物广场购物
小红,10岁,女,在西部开源学习

提示:
属性:name,age,gender
方法:shopping(), playGame(), learning()

"""


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

    def shopping(self):
        print(f'{self.name},{self.age}岁,{self.gender},去西安赛格购物广场购物 ')

    def learning(self):
        print(f'{self.name},{self.age}岁,{self.gender},在西部开源学习')


p1 = People('小明', 18, '男')
p2 = People('小王', 22, '男')
p3 = People('小红', 10, '女')

p1.shopping()
p2.shopping()
p3.learning()

5.4 继承的实现

class Student:
    """父类Student"""
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def learning(self):
        print(f'{self.name}正在学习')

class MathStudent(Student):
    """MathStudent的父类是Student"""
    pass

# 实例化
m1 = MathStudent("粉条博士", 8)
print(m1.name)
print(m1.age)
m1.learning()           # 不报错，子类里没有，但父类有该方法
# m1.choice_course()   # 报错, 子类里没有，父类也没有的方法

5.5 重写父类方法

class Student:
    """父类Student"""
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def learning(self):
        print(f'{self.name}正在学习')

    def choice_course(self):
        print('正在选课中'.center(50, '*'))

class MathStudent(Student):
    """MathStudent的父类是Student"""
    def choice_course(self):
        # 需求: 先执行父类的choice_course方法， 在个性化执行自己的方法。
        # Student.choice_course(self)  # 解决方法1: 直接执行父类的方法，但不建议
        # 解决方法2： 通过super找到父类，再执行方法(建议且生产环境代码常用的方式)
        super(MathStudent, self).choice_course()

        info = """
                    课程表
            1. 高等数学
            2. 线性代数
            3. 概率论
        """
        print(info)

# 实例化
m1 = MathStudent("粉条博士", 8)
m1.choice_course()

s1 = Student("粉条博士", 8)
s1.choice_course()

5.6 巩固练习——链表的封装

"""
参考链接 https://www.cnblogs.com/klyjb/p/11237361.html
数组: 需要连续的内存空间
链表: 不需要连续的内存空间
                数组              链表
增加元素        O(n)                O(1)
删除元素        O(n)                O(1)
修改元素        O(1)                O(n)
查看元素        O(1)                O(n)
"""
# 封装节点类
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

    def travel(self, head):
        """遍历链表里面的每一个元素"""
        while head:
            print(head.val, end=',')
            head = head.next

def create_l1():
    # l1 = 2,4,3
    # l2 = 5, 6, 4
    l1 = ListNode()
    node1 = ListNode(val=2)
    node2 = ListNode(val=4)
    node3 = ListNode(val=3)
    l1.next = node1
    node1.next = node2
    node2.next = node3
    return  l1.next

def create_l2():
    # l1 = 2,4,3
    # l2 = 5, 6, 4
    l2 = ListNode()
    node1 = ListNode(val=5)
    node2 = ListNode(val=6)
    node3 = ListNode(val=4)
    l2.next = node1
    node1.next = node2
    node2.next = node3
    return  l2.next

def addTwoNumbers(l1: ListNode, l2: ListNode) -> ListNode:
    res = 0
    l3 = ListNode()
    cur = l3
    while(l1 or l2):
        if(l1):
            res += l1.val  # res=2
            l1 = l1.next
        if(l2):
            res += l2.val # res=2+5=7
            l2 = l2.next
        # res=10, val=0, res=>val val=res%10
        # res=14, val=4, 14%10=4
        l3.next = ListNode(res%10)
        l3 = l3.next
        # res=10, 进位为1， 10//10=1
        # res=14, 进位为1， 14//10=1
        res  //= 10
    if res == 1:
        l3.next = ListNode(1)
    return cur.next



# 中午留个作业:查一下它的功能
if __name__ == '__main__':
    l1 = create_l1()
    l2 = create_l2()
    l3 = addTwoNumbers(l1, l2)
    l3.travel(l3)

5.7 多继承

"""
新式类: 广度优先算法
经典类： 深度优先算法(py2中的部分类属于经典类)

python3所有的类都属于新式类。新式类的继承算法是广度优先。

# 分析多继承的相关代码
>pip install djangorestframework
from rest_framework import viewsets
viewsets.ModelViewSet
"""


class D(object):
    def hello(self):
        print('D')


class C(D):
    # def hello(self):
    #     print('C')
    pass


class B(D):
    pass
    # def hello(self):
    #     print('B')


class A(B, C):
    pass
    # def hello(self):
    #     print('A')


a = A()
a.hello()

5.8 私有属性和私有方法

class Student:
    """父类Student"""
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        # 私有属性，以双下划线开头。
        # 工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。
        self.__score = score

    def learning(self):
        print(f'{self.name}正在学习')

    def get_score(self):
        self.__modify_score()
        return  self.__score

    # 私有方法是以双下划线开头的方法,
    #工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。
    def __modify_score(self):
        self.__score += 20

class MathStudent(Student):
    """MathStudent的父类是Student"""
    def get_score(self):
        self.__modify_score()
        return  self.__score

# 报错原因: 子类无法继承父类的私有属性和私有方法。
s1 = MathStudent('张三', 18, 100)
score = s1.get_score()
print(score)