Python面向对象——三大特性

目录

三、三大特性

        封装

封装的定义

封装的好处

封装的实现

结论

        继承

继承的基本概念

继承的特点

继承实现

        多态

多态的定义

多态的好处

多态实现

结论

四、结语

---

三、三大特性

        面向对象编程（OOP）的三大特性是封装、继承和多态。这些特性共同构成了OOP的基础，使得软件设计更加灵活、可维护和可扩展。

        封装

封装的定义

封装是创建对象的过程，这些对象将数据（属性）和行为（方法）组合在一起。封装的目的是：

• 保护数据：防止对象的内部数据被外部代码直接访问和修改。
• 提供接口：只允许外部代码通过对象提供的方法来访问和修改数据。

封装的好处

• 减少耦合：对象之间的依赖关系减少，因为外部代码不直接依赖于内部实现。
• 提高可维护性：对象的内部实现可以独立于外部代码进行修改，只要接口保持不变。
• 增强安全性：通过隐藏内部实现，可以防止外部代码意外破坏对象的状态。

封装的实现

        

class Person:
    def __init__(self, name, age, sex, height):
        self.name = name
        self.__age = age
        self.__sex = sex
        self.__height = height

    # 获取时触发
    @property
    def height(self):
        return self.__height

    # 设置时触发
    @height.setter
    def height(self, height):
        if 0 < int(height) < 300:
            self.__height = height
        else:
            print(f"{height} ??? 你看看你还是人吗")

    def set_age(self, age):
        self.__age = age

    def get_age(self):
        return self.__age

    def __set_sex(self, sex):
        if sex in ["男", "女"]:
            self.__sex = sex
        else:
            print("你看看你是森么")

    def __get_sex(self):
        return self.__sex

    # 通过 property 方法 设置私有属性 以达到 即可方便 访问 又可 过滤设置的一些不合法信息 安全的双重保障
    sex = property(__get_sex, __set_sex)

    def set_name(self, name):
        self.name = name

    def get_name(self):
        return self.name

    def __str__(self):
        return f'姓名：{self.get_name()} 年龄：{self.get_age()} 性别：{self.__get_sex()}'


# 公有属性 方便调用 相较于 私有属性来说 但容易产生不合法数据
p1 = Person("刘备", 20, "男", 175)
p1.name = "曹操"
# 私有属性只能通过 set get 方法设置或调用 过滤设置的一些不合法信息
p1.set_age(25)
print(p1)

print(p1.sex)
p1.sex = "嘿嘿"
print(p1.sex)

# 装饰器 更方便
print(p1.height)
p1.height = "180"
print(p1.height)

print(p1.height)
p1.height = "520"
print(p1.height)

结论

        封装是OOP中的关键概念，它有助于创建模块化、易于维护和安全的代码。通过使用私有属性、属性装饰器、自定义的访问和设置方法，以及__slots__，Python提供了多种机制来实现封装。

        继承

        继承是面向对象编程（OOP）中的一个基本概念，它允许我们基于现有类创建新类，这种新类称为子类或派生类，而现有的类称为基类或父类。继承是一种代码复用机制，它提供了一种方式来扩展或修改现有类的行为。

        

继承的基本概念

• 基类（Base Class）：定义了通用属性和方法的类。
• 子类（Derived Class）：从基类继承并可能添加或修改属性和方法的类。
• 派生类（Subclass）：继承自另一个类的类。
• 超类（Superclass）：被另一个类继承的类。

继承的特点

1. 代码复用：子类可以复用基类的代码，减少重复代码的编写。
2. 扩展性：子类可以扩展基类的功能，添加新的属性和方法。
3. 可维护性：对基类的修改会自动反映到所有子类中，简化了维护工作。
4. 多态性：子类可以重写基类的方法，实现多态性。

继承实现

        

"""
object 是所有 类 的 父类

子类拥有父类的功能方法
.__class__ 判断 类
.__base__ 类 的 父类
.__bases__ 类 的 父类们
"""



# 单继承
class Person(object):

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"人 {self.name} {self.age}"

    def eat(self):
        return print(f'{self.name} eat food')

    def sad(self):
        return print(f"{self.name}：红红上仙好漂亮")


p = Person("权贵", 20)
print(p)
p.sad()
p.eat()


# Person 子类
class SuperPerson(Person):
    def __init__(self, name, age, skill):
        super().__init__(name, age)
        self.skill = skill

    def __str__(self):
        return f"超{super().__str__()} 技能 {self.skill}"

    def sad(self):
        return print(f"{self.name}：红红好漂亮")

    def work(self):
        return print(f"{self.name}  修炼")


sp = SuperPerson("月初", 999, "虚空之泪")
print(sp)
sp.sad()
sp.work()


class SuperMan(Person):
    def __init__(self, name, age, sex):
        super().__init__(name, age)
        self.sex = sex


sm = SuperMan('光头强', 20, "男")
print(sm)


#  多继承

class MoveAble:
    def __init__(self, speed):
        self.speed = speed

    def move(self):
        return print(f"{self.speed} km/h")


class EatAble:
    def __init__(self, eat):
        self.eat = eat

    def eat_good(self):
        return print(f"{self.eat} lead me strong")

    def __str__(self):
        return f"EarAble 类"


class Attack:
    def __init__(self, ack):
        self.ack = ack


class Person(MoveAble, EatAble):
    def __init__(self, name, speed, eat):
        self.name = name
        MoveAble.__init__(self, speed)
        EatAble.__init__(self, eat)

    def sad(self):
        return print(f"{self.name} have {self.speed} km/h go to eat {self.eat} ")

    def __str__(self):
        return f"Person 类"


p = Person("aa", 30, "炒鸡")
p.sad()
p.eat_good()
p.move()

e = EatAble("炒鸡")
e.eat_good()


class PersonSon(Person, Attack):
    def __init__(self, name, speed, eat, ack):
        Person.__init__(self, name, speed, eat)
        Attack.__init__(self, ack)

    def __str__(self):
        return f'{self.name} {self.eat} milk'


ps = PersonSon("海尔", 1, "eat", "100")
print(ps)

# 多继承 mro()：method(方法) retrieval(检索) order(顺序)
# Method Resolution Order，简称MRO
# Python3 使用 C3线性化算法
# 通过一个类的.__mro__属性或者.mro()方法来查看类的MRO
print(PersonSon.mro())

        多态

多态的定义

多态性意味着“多种形式”。在编程中，多态性主要体现在以下几个方面：

• 编译时多态：通过函数重载（在某些语言中）实现，即同一个函数名可以有多个实现，根据不同的参数类型来调用不同的版本 python通过*args 形参来实现
• 运行时多态：通过方法重写（子类重写父类的方法）和动态绑定实现，即在运行时根据对象的实际类型来调用相应的方法。

多态的好处

• 提高代码的灵活性：可以使用统一的接口来处理不同类型的对象。
• 减少代码冗余：避免了为每种类型编写特定的代码。
• 提高代码的可扩展性：新增对象类型时，不需要修改现有的代码，只需要确保它们遵循相同的接口。

多态实现

class Animal:
    def walk(self):
        print("走")


class Cat(Animal):
    def walk(self):
        print("窜来窜去")


class Chicken(Animal):
    def walk(self, speed):
        speed = speed
        print("唱跳rap", speed)

    def attack(self, *args):
        return print(*args)


# 父子类多态，函数名参数都相同，但是实现不同
c = Chicken()
c.walk(2.5)
# 通过*args实现
c.attack("击 击 击 ")
c.attack("坤拳", "铁山靠")

结论

        多态是OOP中的一个重要特性，它提高了代码的灵活性和可扩展性。在Python中，多态性主要通过方法重写和动态绑定实现，这使得我们可以使用统一的接口来处理不同类型的对象。鸭子类型的概念进一步强化了Python中多态性的应用，使得我们更加关注对象的行为而非类型。

四、结语

        面向对象编程是一种强大的工具，它可以帮助我们以一种更加模块化和可重用的方式来构建软件。Python的OOP特性使得它成为实现面向对象设计的优选语言之一。通过掌握类、继承、封装和多态，你可以编写更加灵活和可维护的代码。