Python 面向对象（类）
目录
面向对象理念
面向对象三大特性
定义类
格式
创建对象（实例化一个对象）
创建方法
实例方法
类方法
静态方法
self含义
对象属性
添加获取对象属性
编辑
类里面获取对象属性
继承
单继承
多继承
多态
面向对象理念
面向对象编程（Object-Oriented Programming，简称OOP）是一种常用的编程范式，它将程序中的数据和操作数据的方法组织在一起，形成对象，通过对象之间的交互来实现程序的功能。
类：描述具有相同属性和方法的集合，简单来说就是一个模板，通它来创建对象。
对象：类的实例。
方法：类中定义的函数。
类变量：定义在类中且在函数之外的变量，在所有实例化对象中公用。
局部变量：方法中定义的变量，只作用于当前实例。
面向对象三大特性
封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，提高复用性和安全性。
继承：一个类继承一个基类便可拥有基类的属性和方法，可提高代码的复用性。
多态：父类定义的引用变量可以指向子类的实例对象，提高了程序的拓展性。
设计一个类的三要素：
类名，这类事物的名字，大驼峰命名法，例如CapWords，单词之间不使用下划线
属性，这类事物具有什么样的特征
方法，这类事物具有什么样的行为
__方法名__格式的方法是python提供的内置方法/属性
定义类
面向对象是更大的封装，在一个类中包含多个方法（函数）
格式
class 类名:
pass创建对象（实例化一个对象）
class Person:
pass
tom = Person()
print(tom)定义一个类 Person
创建了一个对象 tom
创建方法
- 实例方法(self): 类和实例的属性和方法都可以访问调用
- 类方法(cls): 只能使用类属性和方法， 不能使用实例属性和方法
- 静态方法(static): 类属性方法和实例属性方法都不能使用， 只是依附于该类，相当于独立函数
实例方法
实例方法中的第一个参数是 self，表示实例本身。def定义方法后，会在括号内自动补全 self
class Person:
def eat(self):
print("吃了冰淇淋")
def run(self):
print("跑了5公里")
tom = Person()
tom.eat()
tom.run()一个 Person 类，包含了两个方法：eat 和 run
对象 tom 调用了 eat 和 run 的方法
类方法
类方法中的第一个参数是 cls，表示类本身，类方法可以通过类对象和实例对象进行调用。
定义方法后，在括号内会自动补全 cls
使用 @classmethod 装饰器
class Car:
@classmethod
def describe(cls, color, brand, city):
print("这是一个类方法", f"这是一辆{city}产的{color}的{brand}轿车")
Car.describe("黑色", "大众", "德国")
静态方法
默认没有第一个参数，什么也不接收。静态方法是定义在类中的方法，它不需要访问类的实例或实例的属性。它可以通过类名直接调用，而无需创建类的实例。静态方法通常用于执行与类相关但独立于实例的操作。
使用 @staticmethod 装饰器
class MathUtils:
@staticmethod
def multiply(x, y):
return x * y
result = MathUtils.multiply(2, 3)
print(result)self含义
self指的是调用该类的对象（是一个实例），是一个python自动会给传值的参数
哪个对象执行方法，self就是谁。例如
obj1.fetch('haha') self就是obj1 obj2.fetch('hehe') self就是obj2
对象属性
添加获取对象属性
对象名.属性名观察下方示例：
class Washer:
def wash(self):
print("洗衣服")
haier = Washer()
haier.wash()
haier.width = 400
haier.height = 600
print(f"洗衣机的长宽是{haier.width}, {haier.height}")
haier.width = 400 和 haier.height = 600 就是定义了一个对象的属性
类里面获取对象属性
观察下方示例：
class Washer:
def info(self):
print(F"洗衣机的宽度是{self.width}， 高度是{self.height}")
haier = Washer()
haier.width = 400
haier.height = 600
haier.info()
self.width 和 self.height 就相当于haier.width 和 haier.height。 即self就是该类的对象
继承
单继承
子类拥有父类的所有属性和方法
代码示例
class Animal:
def eat(self):
return "吃食物---"
def run(self):
return "跑---"
class Dog(Animal):
def bark(self):
return "汪汪叫:wangwang~"
class Cat(Animal):
def mioaomiao(self):
return "喵喵叫"
animal = Animal()
print(f"动物的天性就是: {animal.eat()}, {animal.run()}")
dog = Dog()
print(f"狗的天性除了: {dog.eat()}, {dog.run()}，还会{dog.bark()}")
cat = Cat()
print(f"猫的天性除了: {cat.eat()}, {cat.run()}，还会{cat.mioaomiao()}")定义了一个动物类：Animal，其包含两个方法：eat 和 run
定义了一个狗类：Dog，继承其父类 Animal，这样狗的这个类就拥有了其父类（Aniaml）的eat 和 run 方法
同理定义了一个猫类：Cat，继承其父类 Animal，这样狗的这个类就拥有了其父类（Aniaml）的eat 和 run 方法
多继承
和单继承同理，格式参考如下：
class 类名(父类1，父类2):
pass代码示例
class Man:
def father(self):
print("父亲叫张航")
class Women:
def mother(self):
print("母亲叫王丽")
class Son(Man, Women):
def son(self):
print("我叫张宇")
son_name = Son()
son_name.son()
son_name.father()
son_name.mother()Son 这个类继承了父类 Man 和 Women之后，便拥有了他俩的方法
多态
" 多态 " 指的是 相同类型 的 不同 对象 完成 某个行为时 , 会得到不同的状态 ;
多态是面向对象编程中一个重要的概念，它允许不同类型的实例在调用相同方法时表现出不同的行为，提高了程序的灵活性和可扩展性
" 多态 " 是通过继承关系 实现的
观察下方示例：
class Voice:
def say(self):
print('动物基本的发声频率:', end=' ')
class People(Voice):
def say(self):
super().say()
return '嘤嘤嘤'
class Dog(Voice):
def say(self):
super().say()
return '汪汪汪'
class Cat(Voice):
def say(self):
super().say()
return '喵喵喵'
voice = Voice()
voice.say()
print()
people = People()
print(f"人的发声频率：{people.say()}")
dog = Dog()
print(f"狗的发生频率：{dog.say()}")
cat = Cat()
print(f"猫的发生频率：{cat.say()}")创建了一个父类：
Voice，并调用它的say()方法定义了三个子类：People、Dog、Cat类 ，指定父类 Voice
调用
People、Dog、Cat类的say()方法时，使用super().say()语法同时调用父类Voice类的say()方法输出：
