0基础学python-15：封装、继承和多态

吃什么芹菜卷

于 2024-07-17 10:22:32 发布

阅读量472

点赞数 16

分类专栏： 0基础学python 文章标签： python 人工智能笔记

本文链接：https://blog.csdn.net/weixin_65047977/article/details/140484801

版权

0基础学python 专栏收录该内容

15 篇文章 2 订阅

订阅专栏

前言

封装、继承和多态是面向对象编程的三大基本特性，它们与面向对象编程（OOP）密切相关。

一、封装（Encapsulation）

概念：封装指的是将数据（属性）和操作数据的方法（方法）打包在一起，并对对象的内部工作进行保护，使其只能通过受控的方式访问。
关联：封装有助于提高代码的可重用性和安全性，通过限制对内部数据的直接访问，减少了意外错误的发生，并且使对象的实现细节对外部用户透明化。

我的理解是将一些属性和方法放进类，相当于我们自己定义了一个内置的类。想要用类里的属性和方法，在外部调用即可，不用修改或者再自定义。

私有变量：

类里面有个概念叫私有变量，定义的时候在变量名前加两个下划线。私有变量在外部不可直接调用，只能在内部修改或者调用。但因为python可以在类的外部强行调用类内的私有变量（但这是不道德的，不要这样做），所以约定俗成的将私有变量前的下划线变成一个。这样就就告知使用者，这是一个私有变量，当做常数用即可，不要修改。

代码实例：

class Car:
    def __init__(self, make, model, year):
        self.__make = make        # 私有属性
        self.__model = model      # 私有属性
        self.__year = year        # 私有属性
        self.__odometer = 0       # 私有属性

    def display_info(self):
        print(f"Car: {self.__year} {self.__make} {self.__model}")

    def read_odometer(self):
        print(f"This car has {self.__odometer} miles on it.")

    def update_odometer(self, mileage):
        if mileage >= self.__odometer:
            self.__odometer = mileage
        else:
            print("You can't roll back an odometer!")

    def increment_odometer(self, miles):
        self.__odometer += miles

# 创建一个 Car 对象并使用
my_car = Car("Toyota", "Corolla", 2022)
my_car.display_info()   # 输出：Car: 2022 Toyota Corolla
my_car.update_odometer(10000)
my_car.read_odometer()  # 输出：This car has 10000 miles on it.
my_car.increment_odometer(500)
my_car.read_odometer()  # 输出：This car has 10500 miles on it.
print(my_car.__make)    # 尝试在外部直接访问私有变量

输出：

在上述代码中，属性 __make、__model、__year 和 __odometer 被定义为私有属性，只能通过类内部的方法来访问和修改，实现了封装的基本概念。

Car: 2022 Toyota Corolla
This car has 10000 miles on it.
This car has 10500 miles on it.

# 报错，属性错误，显示Car类里找不到__make这个属性
Traceback (most recent call last):
  File "D:\Code\Try\HomeWork3.py", line 192, in <module>
    print(my_car.__make)
          ^^^^^^^^^^^^^
AttributeError: 'Car' object has no attribute '__make'

二、继承（Inherit）

概念：继承允许一个类（子类）基于另一个类（父类）的定义来创建新类，从而继承父类的属性和方法，同时可以添加自己的新功能或修改继承的功能。
关联：继承支持代码的重用和扩展，使得类与类之间可以建立层次关系，提高了代码的组织性和可维护性，同时也促进了代码的灵活性和可扩展性。

代码实例：此段代码有点长，希望能耐心分析

# 继承

class Animal(object):

    def __init__(self, leg, height):
        self.leg = leg
        self.height = height

    def run(self):
        print("Animal is run")


# 在括号里面写入父类的名称
class Dog(Animal):

    def __init__(self, leg, height, bark):
        super().__init__(leg, height) # 直接继承父类里属性

        self.bark = bark  # 子类新加的属性

    def eat_shit(self):   # 子类自己的方法
        print("dog can eat shit")

    # 父类存在  子类有不同的方式方法   方法的重写
    def run(self):
        print("dog is running")


class Cat(Animal):

    def __init__(self, leg, height, jump):
        super().__init__(leg, height)
        self.jump = jump

    def eat_mouse(self):
        print("maomao eat mouse")

    def run(self):
        super().run()  # 调用父类的方法
        print("cat is running")



if __name__ == '__main__':
    animal = Animal(4, 1)

    snoopy = Dog(3, 1.2, "wangwang")

    tom = Cat(2, 1.1, 1.8)

    print(snoopy.leg)
    animal.run()
    snoopy.run()
    snoopy.eat_shit()
    tom.run()
    pass

输出：

在这个例子中，Car 类继承了 Vehicle 类的 make、model 和 year 属性，同时定义了自己的 odometer 和相关方法，实现了继承的概念。

3
Animal is run
dog is running
dog can eat shit
Animal is run
cat is running

三、多态（Polymorphism）

概念：多态指的是同一个方法名可以在不同的类中有不同的实现方式，使得具有不同类型的对象能够对同一消息做出响应。
关联：多态提高了代码的灵活性和可扩展性，允许使用统一的接口来处理不同对象的情况，从而简化了代码的复杂度，增强了代码的可读性和可维护性。

代码实例：

# 父类
class Animal:
    def sound(self):
        pass

# 子类，继承 Animal 类
class Dog(Animal):
    def sound(self):
        print("Woof!")

# 另一个子类，继承 Animal 类
class Cat(Animal):
    def sound(self):
        print("Meow!")

# 多态的应用示例
def make_sound(animal): # 创建一个函数，传入的参数是一个对象
    animal.sound()      # 调用传入对象的相同方法

# 创建不同的动物对象并调用同一方法
dog = Dog()
cat = Cat()

make_sound(dog)  
make_sound(cat)

输出：

在这个例子中，make_sound 函数接受一个 Animal 类型的参数，然后调用参数的 sound 方法。通过传入 Dog 和 Cat 对象，实现了不同类里面的的 sound 方法，展示了多态的特性。