Python面向对象三大特征封装，继承，多态

封装

封装是指将对象的属性（数据）和方法（操作数据的函数）捆绑在一起，并隐藏对象内部的实现细节，只对外暴露必要的接口供外部使用。

通俗理解：就像一个手机，你只需要用它的按键 / 屏幕（接口）操作，不需要知道内部的电路板、芯片是如何工作的（隐藏细节）。
Python 中没有严格的 "私有" 关键字（如 Java 的private），但约定俗成用 _（单下划线）表示 "受保护"、__（双下划线）表示 "私有"（实际是名称改写，并非绝对隐藏）。

"""
面向对象的特征--封装
1.封装
官方定义：讲公共的属性和方法抽取出来，隐藏具体实现的细节
!!将属性私有化,要想使用私有属性要对外提供暴露接口
2.私有方法
python中使用__属性名定义私有方法
私有属性不能在外部访问。只允许在类的内部进行访问
3.公共方法
私有属性对外提供方法(get和set)

"""

python 复制代码

#1 创建person类
class Person:
    #属性
    name = ""       #公有
    age = 0
    #私有属性
    __nickname = "张三丰" #私有

    #私有方法
    def __testPrivate(self):
        print("这是一个私有方法")

    #构造方法
    def __init__(self, name, age,nickname):
        self.name = name
        self.age = age
        self.nickname = nickname
        self.__testPrivate()

    #魔术方法
    def __str__(self):
        return f"name:{self.name},age:{self.age},nikename:{self.nickname}"

    #对外提供接口get
    def getNickname(self):
        return self.__nickname

    #设置属性接口
    def setNickname(self, nickname):
        self.__nickname = nickname

    def getTestPrivate(self):
        return self.__testPrivate()


person = Person("John", 18,"张三丰")
print(person)
print(person.name)
#print(person.__nickname)
#person.__testPrivate()

#使用get方法获取私有属性
print(person.getNickname())
#设置私有属性
person.setNickname("光头强")
print(person.getNickname())
person.getTestPrivate()

继承与多态

继承含义：

继承允许一个类（子类 / 派生类）继承另一个类（父类 / 基类）的属性和方法，实现代码复用，同时子类可以扩展或重写父类的功能。

父类：被继承的类，包含通用的属性和方法；
子类：继承父类的类，可新增自己的属性 / 方法，或重写父类方法；
Python 支持单继承 和多继承（一个子类继承多个父类）。

多态含义：

多态指同一个方法名，在不同的对象上有不同的实现效果。简单说：调用同一个方法，不同对象表现出不同行为。

多态的前提：继承 + 方法重写；
优势：无需关心对象具体类型，只需调用统一接口，提高代码灵活性。

python 复制代码

"""
    面向对象的特征二 --继承
        1.object: 所有类的父类,自定义的类继承来在object公共父类的所有的非私有成员
        2.继承的概念：子类继承父类，子类可以获取所有父类的非私有成员
        3.继承的格式：
            class  子类(父类名)
        4.特征:
            代码复用性,扩展性
            单一继承:
                子类可以访问父类的非私有成员
                父类不能访问子类的成员
            多继承：一个子类可以拥有多个父类
                子类(父类1，父类2,...父类n)多个父类之间用，隔开
                当父类的成员相同时，子类调用的是靠前的父类属性
            多重继承：   一个儿子有父亲还有爷爷
                子类可以获取继承结构中所有父类的属性和方法

        5.方法的重写
            子类可以重写父类定义的方法，执行时执行的是重写后的方法，且方法定义名必须完全和父类一致
        6.super关键字------指代当前父类
            思考：如何在子类中访问父类的属性
                两种方式：
                    父类名.成员
                    super().成员
                注意：在访问父类的成员函数时，第一种需要传参数self，第二种不用传
                
    面向对象特征三--多态
        Python中不用声明数据类型，天生支持多态
"""

python 复制代码

class Person(object):
    #属性
    name = ""
    age = 0
    salary = 0

    #构造方法
    def __init__(self, name, age, salary):
        self.name = name
        self.age = age
        self.salary = salary

    #魔术方法
    def __str__(self):
        return f"name: {self.name},age: {self.age},salary: {self.salary}"

class Mother():
    name = "母亲的属性name"

    def sing(self):
        print("母亲会唱歌")

class Father(Person):
    name = "父亲的属性name"
    __salary = 2500

    def testFather(self):
        print("testFather......")

class Son(Mother,Father,object):
    age = 0

    def sing(self):     #方法的改写
        print("儿子会唱歌",Mother.name)
        print("儿子会跳舞",super().name)
        Father.testFather(self)
        super().testFather()        #使用super可以不用self关键字

    def print_value(self,value):
        print(value)

class  Daughter(Mother):
    def sing(self):
        print("女儿会琴棋书画")

if __name__ == '__main__':
    person = Person("lisi", 20, 10000)
    print(person)

    father = Father("zhangsan",66,666666)       #实例化父类对象
    son = Son("ww",20,13000)             #实例化子类对象
    print(father.name)
    print(son.name)         #实例化对象后传入参数，引用的是传入后的参数

    # print(father.age)     #父类不能访问子类的成员
    # print(son.__salary)   #子类不能访问父类私有成员

    son.testFather()        #子类可以使用父类的方法
    son.sing()
    son.print_value(6.7777)

总结

封装：隐藏内部细节，只暴露统一接口，保护数据安全，核心是 "属性私有化 + 方法接口化"；
继承：子类复用父类的属性和方法，可扩展 / 重写父类逻辑，核心是 "代码复用 + 功能扩展"；
多态：同一方法在不同子类有不同实现，调用统一接口即可适配不同对象，核心是 "接口统一 + 行为多样"。

这三大特征相辅相成，封装是基础，继承是手段，多态是目的，共同构成了 Python 面向对象编程的核心思想。