类与对象小结
类的概念:
类是对⼀系列具有相同特征和⾏为的事物的统称，是⼀个抽象的概念，不是真实存在的事物。就像车类里面所有具体的车的集合(车包含大众，本田，路虎...)
类的三大特性:
封装:
1、定义：
封装是一种将数据和方法（函数）打包并保护其状态的机制。在类中，封装通过将数据和方法绑定到类中实现。通过封装，可以限制外部对类内部数据的直接访问，并通过公共接口提供对数据的控制和操作。
2、实现
用类的成员变量和成员方法，通过访问控制修饰符（如public、private、protected）来控制成员的可见性和访问权限
代码演示：
class MyClass():
def __init__(self, public_data, private_data):
self.public_data = public_data
self.__private_data = private_data # 双下划线表示私有变量
def public_method(self):
print("This is a public method.")
def __private_method(self): # 双下划线表示私有方法
print("This is a private method.")
def get_private_data(self):
return self.__private_data
def access_private_method(self):
self.__private_method()
stu=MyClass(public_data='公共',private_data='私有')
# 访问公共成员和方法
print(stu.public_data)
stu.public_method()
# 访问私有的成员和方法会报错，私有的成员变量或方法不能在外部直接访问
# print(stu.private_data) #报错
# stu.private_method() #报错
# 通过公共方法访问私有成员变量
print(stu.get_private_data()) # 输出:私有
# 直接访问私有成员变量（不推荐，不建议这样做）
print(stu._MyClass__private_data) # 输出: 私有
# 通过公共方法访问私有成员方法
stu.access_private_method() # 输出: This is a private method.
# 直接访问私有成员方法（不推荐，不建议这样做）
stu._MyClass__private_method() # 输出: This is a private method.
#虽然直接访问私有成员变量的方法存在，但是不建议这样做。Python的私有成员是一种约定而非强制，通过添加类名作为前缀的方式来访问私有变量，但这并不是一种良好的实践，因为它破坏了封装的概念。
3、作用
封装数据的主要原因是保护隐私；封装方法的主要原因是隔离复杂度
继承:
单继承和多继承
继承是一种通过建立一个新的类来重用现有类的属性和方法的机制。子类可以继承父类的属性和方法，并可以在需要时扩展或修改它们。(Object类是所有类的父类) 代码演示：
#单继承
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
return "Woof!"
# 创建对象
dog = Dog()
# 调用继承的方法
print(dog.speak()) # 输出: Woof!
#多继承
class Flyable:
def fly(self):
return "I can fly!"
class Swimmable:
def swim(self):
return "I can swim!"
class FlyingFish(Flyable, Swimmable):
pass
# 创建对象
fish = FlyingFish()
# 调用多继承的方法
print(fish.fly()) # 输出: I can fly!
print(fish.swim()) # 输出: I can swim!
定义：
即子类继承父类的属性或方法并在需要的时候修改它们
实现：
使用class SubClass(BaseClass):语法，其中SubClass是子类，BaseClass是父类。子类继承了父类的属性和方法，并可以添加新的属性和方法
多态:
定义：
多态是一种允许使用相同的接口来处理不同类型对象的能力。在多态中，同一个方法名可以在不同的类中具有不同的实现，而通过使用相同的方法名，可以在不同的对象上调用相同的方法
实现：
多态通常通过方法重写（override）和方法重载（overload）来实现。方法重写是在子类中重新定义父类中已有的方法，而方法重载是在一个类中定义多个同名方法，但参数类型和个数不同。 代码演示：
class Bird:
def fly(self):
pass
class Sparrow(Bird):
def fly(self):
return "Sparrow flying"
class Penguin(Bird):
def fly(self):
return "Penguin can't fly"
# 函数接受 Bird 对象，调用其 fly 方法
def make_bird_fly(bird):
return bird.fly()
# 创建对象
sparrow = Sparrow()
penguin = Penguin()
# 即不同对象调用相同的方法有不同的实现
print(make_bird_fly(sparrow)) # 输出: Sparrow flying
print(make_bird_fly(penguin)) # 输出: Penguin can't fly
class Teacher1(object):
def c_skill(self):
print("语文是我的强项")
def hob(self):
print('我的爱好是古诗文')
class Teacher2(object):
def m_skill(self):
print('数学是我的强项')
def hob(self):
print('我的爱好是奥数')
class Student(Teacher1, Teacher2):
def __init__(self, name):
self.name = name
def info(self):
print(f'我是学生{self.name}')
def skill(self):
print('我的技能是python')
def hob(self):
print('我的爱好是编程')
# 出现同样方法的调用的多继承的处理
super(Student,self).hob()
Teacher2.hob(self)
if __name__ == '__main__':
student1 = Student('张三')
student1.info()
# student1.skill()
# student1.c_skill()
student1.hob()
# 多态：不同的对象调用相同的方法呈现不同的效果
