python 面向对象编程

面向对象编程（OOP）是一种编程范式，它专注于创建包含数据和方法的对象。Python是一种面向对象的语言，这意味着它支持封装，继承和多态等OOP概念。面向对象的三大特性「封装」，「继承」和「多态」

1.什么是封装

「封装」是面向对象编程中的一个概念，它指的是将数据和方法包装在一个单独的单元中，以便在外部无法直接访问或修改内部数据。这种数据保护的方式可以防止外部代码意外地修改或破坏内部数据，从而提高了代码的可靠性和安全性。

在Python中，封装通常通过使用类和访问修饰符来实现。访问修饰符是一种关键字，用于控制类中的属性和方法的可见性。Python中有两种访问修饰符：公共修饰符和私有修饰符。公共修饰符表示属性或方法可以从类的任何地方访问，而私有修饰符表示属性或方法只能从类内部访问。

以下是一个简单的示例，演示了如何在Python中使用封装：

class MyClass:
    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if age > 0:
            self.__age = age

my_object = MyClass("Alice", 25)
print(my_object.name)  # 打印 "Alice"
print(my_object.get_age())  # 打印 "25"
my_object.set_age(-10)  # 年龄不能为负数
print(my_object.get_age())  # 打印 "25"
my_object.set_age(30)
print(my_object.get_age())  # 打印 "30"

#在这个例子中，MyClass类有两个属性：name和__age。name是公共属性，可以从类的任何地方访问。__age是私有属性，只能从类内部访问。MyClass类还有两个方法：get_age和set_age

2.什么是继承

继承是面向对象编程中的一个重要概念，它指的是一个类可以从另一个类中继承属性和方法。被继承的类称为父类或超类，继承的类称为子类或派生类。子类可以使用父类中的属性和方法，也可以添加自己的属性和方法。

在Python中，使用关键字class来定义一个类，并使用括号指定父类。如果没有指定父类，则默认继承自object类。以下是一个简单的示例，演示了如何在Python中使用继承：

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def speak(self):
        return"Woof"

class Cat(Animal):
    def speak(self):
        return"Meow"

my_dog = Dog("Rufus")
my_cat = Cat("Fluffy")
print(my_dog.name + " says " + my_dog.speak())  # 打印 "Rufus says Woof"
print(my_cat.name + " says " + my_cat.speak())  # 打印 "Fluffy says Meow"

python中的类允许多继承，它允许一个类从多个类中继承属性和方法。在Python中，可以通过创建一个新的类来实现多继承，这个新的类是多个现有类的组合。新的类称为子类或派生类，现有类称为超类或基类。

3.什么是多态

多态是指一类事物有多种形态，比如动物类，可以有猫，狗，猪等等。（一个抽象类有多个子类，因而多态的概念依赖于继承）

import abc
class Animal(metaclass=abc.ABCMeta):#同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class Cat(Animal):#动物的形态之一:猫
    def talk(self):
        print('say miaomiao')

class Dog(Animal):#动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal):#动物的形态之三:猪
    def talk(self):
        print('say aoao')

4.多态与多态性是两种概念

多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

import abc
class Animal(metaclass=abc.ABCMeta):#同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class Cat(Animal):#动物的形态之一:猫
    def talk(self):
        print('say miaomiao')

class Dog(Animal):#动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal):#动物的形态之三:猪
    def talk(self):
        print('say aoao')

c = Cat()
d = Dog()
p = Pig()

def func(obj):
    obj.talk()

func(c) #say miaomiao
func(d) #say wangwang
func(p) #say aoao

综上可以说，多态性是 : 「一个接口,多种实现」

5.多态性的好处

1. 增加了程序的灵活性,以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(obj)

2. 增加了程序额可扩展性,通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(obj)去调用