python 面向对象(封装、继承、多态)

封装

1 封装概述

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

2 封装原则

将不需要对外提供的内容都隐藏起来把属性隐藏，提供公共方法对其访问。

3 封装好处

隐藏实现细节，提供公共的访问方式提高了代码的复用性提高安全性。

4 代码部分

定义Person类

class Person():def __init__(self,id,name):self.id=idself.name=namedef print_info(self):print('%d %s' % (self.id,self.name))alex=Person(1,'alex')
alex.print_info()
xiao=Person(2,'xiaoming')
xiao.print_info()

在class内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据，这样，就隐藏了内部的复杂逻辑。

继承

介绍

对于若干个相同或者相识的类，我们可以抽象出他们共有的行为或者属性并将其定义成一个父类，然后用这些类继承该父类。

通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类。

子类不仅可以拥有父类的属性、方法还可以定义自己独有的属性或者方法。

继承的语法

class 类名(父类名):pass

特点

1. 子类继承父类中的非私有化的属性和方法；

2. 子类继承自父类，可直接享受父类已封装好的方法，不需再次开发；

3. 子类中应根据职责，封装子类特有的属性和方法。

4. 如果在类定义中未指定基类，则默认其基类为object:

class Person:pass等同于：class Person(object):pass注：object是所有对象的根基类

在Python中，object 是所有类的基类。如果在类定义中未指定基类，Python会默认将其基类设置为object类。object类是Python中所有类的根类，它定义了所有Python类共有的基本行为，如对象的创建和销毁、属性访问、比较操作等。
因此，即使在类定义中未显式指定基类，在Python中定义的每个类都会隐式继承自object类，从而获得object类提供的默认行为。这种默认继承关系确保了Python中类的一致性和统一性，使得所有的类都能够共享基本的对象模型和行为。

代码部分

定义Person类、Student类

class Person():def __init__(self,id,name):self.id=idself.name=namedef print_info(self):print('%d %s' % (self.id,self.name))class Student(Person):def __init__(self,id,name,sno):Person.__init__(self,id,name)self.sno=snodef print_info(self):Person.print_info(self)print('我的学号是：',self.sno)p1=Person(1,'张三')
p1.print_info()
s1=Student(2,'王五',150001)
s1.print_info()

重写

当父类方法的实现不能满足子类需求时，可对方法进行重写。

重写父类方法有两种情况：

1.覆盖父类的方法。

2.子类对父类进行扩展。

覆盖

即在子类中定义一个同父类同名的方法且实现重写之后，在运行时，只会调用子类中重写的方法，而不再调用父类封装的方法。

class Student(Person):def __init__(self,id,name,sno):Person.__init__(self,id,name)self.sno=snodef print_info(self):print('我是一名学生，我的学号是：',self.sno)s1=Student(2,‘王',150001)
s1.print_info()

扩展

父类原本封装的方法实现是子类方法的一部分

具体实现步骤：

1.在子类中重写父类的方法

2.在需要调用父类方法时用：父类名.父类方法或super().父类方法

3.代码其他的位置针对子类需求，编写子类特有的代码

class Student(Person):def __init__(self,id,name,sno):Person.__init__(self,id,name)self.sno=snodef print_info(self):super().print_info()print('我的学号是：',self.sno)s1=Student(2,‘王',150001)
s1.print_info()

父类的私有属性和私有方法

子类不能在自己的方法内部，直接访问父类的私有属性和方法；

子类对象不能直接访问父类的私有属性和方法，可通过父类公有方法间接访问到私有属性和方法。

class Person():def __init__(self):self.p='公开'self.__s='秘密'def __test(self):print('私有方法%s %s' % (self.p,self.__s))class Student(Person):def fun(self):print(self.p)# print(self.__s) # 出错# self.__test() # 出错# 子类不能在自己方法内部，直接访问父类的私有属性和方法
# 子类对象
s1=Student()
s1.fun()
# s1.__test()  出错
# print(s1.__s) 出错
# 子类对象不能直接访问父类的私有属性和方法

多继承

继承多个父类。

语法

class 类名(父类名1，父类名2……):pass

代码部分

class A:def test(self):print('test方法')
class B:def demo(self):print('demo方法')class C(A,B):passc=C()
c.test()
c.demo()

多态

不同的子类对象调用相同的父类方法，产生不同的执行结果。换句话说，通过多态性，可以使用统一的接口来调用不同类的方法，而具体执行的方法取决于对象的实际类型。

例如，假设有一个Shape基类和它的子类Circle和Rectangle，它们都实现了calculate_area()方法。使用多态性，可以编写一个统一的函数来计算不同形状的面积，而不需要关心具体是哪种形状：

class Shape:def calculate_area(self):passclass Circle(Shape):def __init__(self, radius):self.radius = radiusdef calculate_area(self):return 3.14 * self.radius ** 2class Rectangle(Shape):def __init__(self, width, height):self.width = widthself.height = heightdef calculate_area(self):return self.width * self.heightdef print_area(shape):print("Area:", shape.calculate_area())circle = Circle(5)
rectangle = Rectangle(4, 6)print_area(circle)  # 输出：Area: 78.5
print_area(rectangle)  # 输出：Area: 24