python的封装，多态

Python：在 Python 中，封装是通过使用命名约定来实现的。例如，单下划线 _ 前缀表示该成员是受保护的，而双下划线 __ 前缀表示私有成员。然而，这些并不是强制性的，只是约定俗成。Python 并没有像 Java 或 C++ 那样的访问控制修饰符。

class MyClass:
def init(self):
self._protected_attribute = 0 # 受保护的属性
self.__private_attribute = 0 # 私有属性

def protected_method(self):
    return "This is a protected method"

def private_method(self):
    return "This is a private method"

Java：Java 提供了三种访问控制修饰符：public、private 和 protected。此外，还可以使用默认（包级）访问权限。这些修饰符明确地控制了类成员的可见性和访问范围。

public class MyClass {
protected int protectedAttribute = 0; // 受保护的属性
private int privateAttribute = 0; // 私有属性

protected void protectedMethod() {
    System.out.println("This is a protected method");
}

private void privateMethod() {
    System.out.println("This is a private method");
}

}

C++：C++ 也提供了 public、private 和 protected 访问控制修饰符。C++ 的类和对象类似于 Java，但语法略有不同。

class MyClass {
protected:
int protectedAttribute;

private:
int privateAttribute;

protected:
void protectedMethod() {
std::cout << "This is a protected method";
}

private:
void privateMethod() {
std::cout << "This is a private method";
}
};

Python：Python 支持方法覆盖，但不支持方法重载。Python 中的方法签名不是固定的，这意味着你可以定义多个同名的方法，只要它们的参数列表不同，这在 Python 中不会引起冲突。Python 使用动态类型系统，所以方法调用取决于对象的实际类型。

class Animal:
def speak(self):
return "Some sound"

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

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

Java：Java 支持方法重载和方法覆盖。方法重载发生在同一个类中，而方法覆盖发生在子类中。

class Animal {
void speak() {
System.out.println("Some sound");
}
}

class Dog extends Animal {
@Override
void speak() {
System.out.println("Woof!");
}
}

class Cat extends Animal {
@Override
void speak() {
System.out.println("Meow!");
}
}
C++：C++ 同样支持方法重载和方法覆盖。方法覆盖在 C++ 中称为“虚函数”（virtual functions）。

class Animal {
public:
virtual void speak() {
std::cout << "Some sound";
}
};

class Dog : public Animal {
public:
void speak() override {
std::cout << "Woof!";
}
};

class Cat : public Animal {
public:
void speak() override {
std::cout << "Meow!";
}
};