Python 07面向对象的三大特点【封装、继承、多态】

😀前言
在软件开发的过程中，面向对象编程（Object-Oriented Programming，简称 OOP）已经成为了一种不可或缺的编程范式。它允许开发人员创建属于自己的对象，具有其特征和行为，通过将数据和方法绑定到一起来模拟现实世界中的对象。OOP 主要依赖于三大核心特性：封装、继承和多态，来构建可复用、可维护和组织良好的代码。
.
在本篇文章中，我们将深入探讨 Python 中的面向对象编程的三大特性。我们将从封装的基本概念开始，然后讨论继承和多态如何允许我们创建灵活和高效的程序。我们还将介绍类方法、类属性及静态方法的使用，来提供一个全面的视角，理解面向对象编程在 Python 中的实现

🏠个人主页：尘觉主页

🧑个人简介：大家好，我是尘觉，希望我的文章可以帮助到大家，您的满意是我的动力😉😉

在csdn获奖荣誉: 🏆csdn城市之星2名
⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　💓Java全栈群星计划top前5
⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　🤗 端午大礼包获得者
⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　🥰阿里云专家博主
⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　😉亚马逊DyamoDB结营

💕欢迎大家：这里是CSDN，我总结知识的地方，欢迎来到我的博客，感谢大家的观看🥰
如果文章有什么需要改进的地方还请大佬不吝赐教 先在次感谢啦😊

Python 07面向对象的三大特性【封装、继承、多态】

首先我们要了解面向对象程序设计三大特性：

1. 封装------根据职责将属性和⽅法封装到⼀个抽象的类中 ； 增强代码的安全性
2. 继承------实现代码的重⽤，相同的代码不需要重复的编写 ； 增强代码的可重用性
3. 多态------不同的对象调⽤相同的⽅法，产⽣不同的执⾏结果，增加代码的灵活度 。 增强代码的可扩展性

1、封装

1.1 类的私有属性和私有⽅法：

1. 私有属性就是对象不希望公开的属性 ；
2. 私有⽅法就是对象不希望公开的⽅法 。

1.2 定义方式

在定义属性或⽅法时，在属性名或者⽅法名前增加两个下划线，定义的就是私有属性或方法。

# 定义Cat类
class Cat:
    def __init__(self,name = "jack"):
        # __name 为私有属性
        self._name = name

    # __eat 为私有方法
    def __eat(self):
        print(self._name + "吃饭")

    def drink(self):
        self.__eat()
        print(self._name + "喝水")


# 创建Cat 类
cat = Cat();


# 调用Cat 喝水的方法
cat.drink()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

对于私有属性和私有方法，只能在类的内部访问，类的外部无法访问。

2、继承

继承的概念：⼦类拥有⽗类的所有⽅法和属性。

语法：

class 类名(⽗类名):

​ pass

# 定义Cat类
class Cat:
    def __init__(self, name="tom"):
        # __name 为私有属性
        self.__name = name

    # __eat 为私有方法
    def __eat(self):
        print(self.__name + "吃饭")

    def drink(self):
        self.__eat()
        print(self.__name + "喝水")


# 创建cat的子类
class kitten(Cat):
    def run(self):
        pass


kitten = kitten()

kitten.drink()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

⼦类继承⾃⽗类，可以直接享受⽗类中已经封装好的⽅法，不需要再次开发 。

⼦类中应该根据职责，封装⼦类特有的属性和⽅法。

继承的传递性：

其实就是，B继承A，拥有了A的属性和方法，然后C又继承B，就拥有了B和A的所有属性和方法。

方法的重写：

当⽗类的⽅法实现不能满⾜⼦类需求时，可以对⽅法进⾏重写(override)。 重写⽗类⽅法有两种情况：

1、覆盖父类的方法

如果在开发中，⽗类的⽅法实现和⼦类的⽅法实现，完全不同 ，就可以使 ⽤覆盖的⽅式，在⼦类中重新编写⽗类的⽅法实现 。

重写之后，在运⾏时，只会调⽤⼦类中重写的⽅法，⽽不再会调⽤父类封装的方法。

# 定义Cat类
class Cat:
    def __init__(self, name="jack"):
        # __name 为私有属性
        self.__name = name

    # __eat 为私有方法
    def __eat(self):
        print(self.__name + "吃饭")

    def drink(self):
        self.__eat()
        print(self.__name + "喝水")


# 创建cat的子类
class kitten(Cat):
    def run(self):
        pass

    # 覆盖了父类的同名方法
    def drink(self):
        print("喝水")


kitten = kitten()

kitten.drink()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

2、对⽗类⽅法进⾏扩展

如果在开发中，既要使用父类的方法，又想增加功能， 就可以使⽤扩展的⽅式 。

1. 在⼦类中重写⽗类的⽅法 ；
2. 在需要的位置使⽤ super().⽗类⽅法来调⽤⽗类⽅法的执⾏ ；
3. 代码其他的位置针对⼦类的需求，编写⼦类特有的代码实现 。

# 定义Cat类
class Cat:
    def __init__(self, name="小白"):
        # __name 为私有属性
        self.__name = name

    # __eat 为私有方法
    def __eat(self):
        print(self.__name + "吃饭")

    def drink(self):
        self.__eat()
        print(self.__name + "喝水")


# 创建cat的子类
class kitten(Cat):
    def run(self):
        pass

    # 对父类的 sleep 方法进行了扩展
    def drink(self, name):
        super().drink()
        print(name + "喝水")


kitten = kitten()

kitten.drink("jack")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

⽗类的私有属性和私有⽅法

1. ⼦类对象不能在⾃⼰的⽅法内部，直接访问⽗类的私有属性或私有⽅法；
2. ⼦类对象 可以通过⽗类的公有⽅法间接访问到私有属性或私有⽅法；
3. 私有属性、⽅法是对象的隐私，不对外公开，外界以及⼦类都不能直接访问。
4. 私有属性、⽅法通常⽤于做⼀些内部的事情 。

object 类

• 在 Python 3 中定义类时，如果没有指定⽗类，会默认使⽤ object 作为该类的基类 —— Python 3 中定义的类都是新式类 。
• 在 Python 2 中定义类时，如果没有指定⽗类，则不会以 object 作为基类 。新式类和经典类在多继承时 —— 会影响到⽅法的搜索顺序 。
• 为了保证编写的代码能够同时在 Python 2 和 Python 3 运⾏！今后在定义类时，如果没有父类,建议统一继承自 object。

3、多态

不同的⼦类对象调⽤相同的⽗类⽅法，产⽣不同的执⾏结果

# 定义Cat类
class Cat:
    def __init__(self, name="小白"):
        # __name 为私有属性
        self.__name = name

    # __eat 为私有方法
    def __eat(self):
        print(self.__name + "吃饭")

    def drink(self):
        self.__eat()
        print(self.__name + "喝水")


# 创建cat的子类
class kitten(Cat):
    def run(self):
        pass

    # 对父类的 sleep 方法进行了扩展
    def drink(self, name):
        super().drink()
        print(name + "喝水")


class dog(Cat):
    def drink(self):
        print("我是一只可爱的小狗狗")


kitten = kitten()
# 调用父类的 drink 方法
kitten.drink("小小白")

dog = dog()
# 调用父类的 drink 方法
dog.drink()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

4、类属性和类方法

不需要创建类的对象，通过 类名. 的⽅式就可以访问类的属性或者调用类的方法 。

1、类属性

# 定义Cat类
class Cat:
    # name 为类属性，通过 Cat.name 访问
    name = "小黄"

    def __init__(self, name="小白"):
        # __name 为私有属性
        self.__name = name
        print(self.__name)


cat=Cat()
print(Cat.name)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2、类方法

1. 用@classmethod 修饰的方法为类方法；
2. 类方法的参数为 cls，在类方法内部通过 cls.类属性 或者 cls.类方法 来访问同一个类中的其他类属性和类方法；
3. 类方法不需要实例化就可以调用，类方法只能访问同一个类中的类属性和类方法

# 定义Cat类
class Cat:
    # name 为类属性，通过 Cat.name 访问
    name = "小黄"

    def __init__(self, name="小白"):
        # _name 为私有属性
        self._name = name

    # drink 为类方法
    @classmethod
    def drink(cls):
        print(cls.name + "喝水")


print(Cat.name)
Cat.drink()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

注：在普通方法中通过 类名.类属性 或者 类名.类方法 来访问类属性和类方法

6、静态方法

如果需要在类中封装⼀个⽅法，这个⽅法既不需要访问实例属性 或者调⽤实例⽅法也不需要访问类属性或者调⽤类⽅法, 这个时候，可以把这个⽅法封装成⼀个静态⽅法。

• 用@staticmethod 修饰的方法为静态方法；
• 静态方法是独立存在的，不能访问类或者实例的任何属性和方法；
• 通过 类名.静态方法 调⽤静态⽅法 。

语法：

@staticmethod

def 静态⽅法名():

​ pass

# 定义Cat类
class Cat:
    # drink 为类的静态方法
    @staticmethod
    def drink():
        print("记得喝水哦")


Cat.drink()
1
2
3
4
5
6
7
8
9

😄总结

通过本文的学习，我们不仅掌握了 Python 中面向对象的三大特性——封装、继承和多态的基本理论和实现方式，还深入了解了类属性、类方法和静态方法的使用和意义。

封装帮助我们保护了对象的内部状态，同时提高了代码的可读性和安全性；继承则允许我们创建子类来重用和扩展父类的功能，极大地增强了代码的可重用性；而多态则提供了一个接口来访问一个类中的多个形式，使我们的代码更具灵活性和可扩展性。

此外，我们还学会了如何通过类属性和类方法来操作与类本身相关联的数据，以及如何使用静态方法来创建与类无关的方法。

通过掌握这些基本概念和技巧，我们已经具备了使用 Python 进行面向对象编程的基本知识，为我们未来的编程之路打下了坚实的基础。希望通过不断的练习和实践，我们能更好地运用这些理论知识到实际的项目开发中，编写出更高效、更灵活的代码。

😁热门专栏推荐
想学习vue的可以看看这个

java基础合集

数据库合集

redis合集

nginx合集

linux合集

手写机制

微服务组件

spring_尘觉

springMVC

mybits

等等等还有许多优秀的合集在主页等着大家的光顾感谢大家的支持

🤔欢迎大家加入我的社区 尘觉社区

文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁
希望能和诸佬们一起努力，今后我们一起观看感谢您的阅读🍻
如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞