目录
前言
封装、继承和多态是面向对象编程的三大基本特性，它们与面向对象编程（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 方法，展示了多态的特性。
Woof!
Meow!
总结
这三个概念共同构成了面向对象编程的基础，并且它们相互交织、相辅相成，使得面向对象的代码能够更加灵活、可靠和易于扩展。
标签：__,.__,15,python,self,多态,odometer,make,def From： https://blog.csdn.net/weixin_65047977/article/details/140484801