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

封装

1 封装概述    

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

2 封装原则

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

3 封装好处      

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

4 代码部分

定义Person类

class Person():
    def __init__(self,id,name):
        self.id=id
        self.name=name
    def 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=id
        self.name=name
    def 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=sno
    def 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=sno
    def 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=sno
    def 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):
    pass

c=C()
c.test()
c.demo()

多态

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

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

class Shape:
    def calculate_area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def calculate_area(self):
        return 3.14 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def calculate_area(self):
        return self.width * self.height

def 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