【面向对象】对比JavaScript、Go、Ada、Python、C++、Java、PHP的访问限制。

在不同编程语言中，控制成员（变量、方法、类等）可见性的机制不尽相同。以下是对比JavaScript、Go、Ada、Python、C++、Java、PHP所使用的访问限制关键字和约定：

一、JavaScript

### JavaScript访问限制

早期的JavaScript并没有类似其他语言的访问限制。ES6之后的JavaScript引入了类，但是没有内置的`public`、`private`或`protected`关键字。

- **public**: 默认情况下，所有JavaScript对象属性和方法都是公共的。
- **private**: 通过闭包可以实现私有性。ES2020 引入了用 # 前缀来定义私有字段的特性。
- **protected**: JavaScript不提供原生的protected关键字或类似机制。

### JavaScript示例

在ES6及其以后版本中，可以用类的语法，并通过闭包或者`#`前缀实现私有属性和方法。

class Example {constructor() {this.publicProperty = "I am public";this._protectedProperty = "I am protected";  // 没有语言层面的保护，只是一个命名约定。this.#privateProperty = "I am private";      // ES2020引入的私有字段。}publicMethod() {console.log(this.publicProperty);}_protectedMethod() {console.log(this._protectedProperty);}#privateMethod() {console.log(this.#privateProperty);}
}const example = new Example();
example.publicMethod(); // 正常工作
example._protectedMethod(); // 可以工作，但不被推荐，因为它违反了命名约定
//example.#privateMethod();  // 会抛出语法错误，私有方法不能在类的外部被访问

二、Go

### Go访问限制

Go 语言有一个独特的访问控制模型。

- **public**（可导出的）: 如果标识符的首字母是大写字母，则该标识符可从其他包访问。
- **private**（不可导出的）: 小写字母开头的标识符在其所在的包之外是不可见的。Go没有`protected`或`friend`关键字。

### Go示例

在Go里面，公开（Public）和私有（Private）是通过标识符的首字母是否大写来区分的。

package mainimport ("fmt"
)type Example struct {PublicProperty string  // 公开属性privateProperty string // 私有属性
}func (e *Example) PublicMethod() {fmt.Println(e.PublicProperty)
}func (e *Example) privateMethod() {fmt.Println(e.privateProperty)
}func main() {example := Example{"I am public", "I am private"}example.PublicMethod()    // 正常工作//example.privateMethod() // 无法访问，因为它是私有方法
}

三、Ada

### Ada访问限制

Ada使用包（packages）进行模块化管理，其访问控制机制基于包的规范和体（specification 和 body）。

- **public**: 包规范中声明的实体默认为公共的。
- **private**: 可以在包规范的私有部分声明私有类型或子程序。
- **protected**: Ada提供了受保护类型（protected types）来支持同步并发访问。

Ada语言中没有直接对应于`friend`关键字的概念。

### Ada示例

在Ada中，包规范中声明的是公开的，而在包体中实现但不在规范中声明的是私有的。

-- 假设该文件名为 example.adb
package Example isprocedure Public_Procedure;
privateprocedure Private_Procedure;
end Example;package body Example isprocedure Public_Procedure isbegin-- implementationend Public_Procedure;procedure Private_Procedure isbegin-- implementationend Private_Procedure;end Example;-- 另一个文件或包使用 Example
with Example;
procedure Use_Example is
beginExample.Public_Procedure;  -- 正常工作-- Example.Private_Procedure; -- 将引发编译错误，因为这是私有程序
end Use_Example;

四、Python

### Python访问限制

Python通过命名约定来区分成员的访问级别，没有严格的访问控制关键字。

- **public**: 默认情况下，所有成员都是公共的。
- **protected**: 遵循约定，以一个下划线(_)开头的成员被视为保护成员。
- **private**: 以双下划线(__)开头的成员被视为私有的，Python会对其名称进行改写以防止外部直接访问。

在Python中，没有`friend`类似的机制，但由于私有性是基于名称改写实现的，严格意义上并不是绝对的私有。

### Python示例

Python中，以单下划线开头的属性或方法约定为受保护的，以双下划线开头的属性或方法为私有的。

class Example:def __init__(self):self.public_property = "I am public"self._protected_property = "I am protected"self.__private_property = "I am private"def public_method(self):print(self.public_property)def _protected_method(self):print(self._protected_property)def __private_method(self):  # Private method with name manglingprint(self.__private_property)example = Example()
example.public_method()         # 正常工作
example._protected_method()     # 工作，但不建议外部直接调用
#example.__private_method()    # 将导致 AttributeError，因为方法名已改写
#example._Example__private_method() # 这样是可以通过改写的名字访问私有方法

五、C++

### C++访问限制

C++支持详细的访问控制机制，包括朋友类和友元函数。

- **public**: 成员在任何地方都可以被访问。
- **private**: 成员只能在定义它们的类中被访问。
- **protected**: 成员不能在类的外部访问，但可以在派生类中访问。
- **friend**: 可以让某个独立的函数或其他类的成员访问类的私有或受保护成员。

### C++示例

C++支持public、private和protected访问限制，以及friend关键字。

class MyClass {
public:MyClass(int value) : publicProp(value) {}int publicMethod() {return publicProp;}protected:int protectedProp;private:int privateProp;int privateMethod() {return privateProp;}friend class FriendClass; // FriendClass has access to private members of MyClass
};class FriendClass {
public:int accessPrivateMethod(MyClass &myClass) {return myClass.privateMethod();}
};

六、Java

### Java访问限制

Java的访问控制修饰符较为直观，与C++相似，但没有`friend`关键字。

- **public**: 类、方法、字段对所有类可见。
- **private**: 类、方法、字段仅在定义它们的类内部可见。
- **protected**: 方法和字段可以在同一个包的所有类中访问，并且在其他包的子类中也是可访问的。
- **默认**（无修饰符）: 如果成员没有访问修饰符，则它在同一个包中的类可以访问，但不能被不同包中的类访问。

不同的访问限制策略为不同的编程场景提供了灵活性和封装性，帮助程序员编写结构良好并且安全的代码。在实际开发中，选择合适的访问控制层级可以减少意外的错误和降低维护成本

### Java示例

Java中也使用 public、private 和 protected关键字，没有 friend 关键字。

public class Person { // 公有类，可以在其他类中访问（public修饰符）  private String name = "Alice"; // 私有成员，只能在Person类内部访问（private修饰符）  protected int age = 25;       // 保护成员，只能在Person类内部和继承该类的子类中访问（protected修饰符）  public void sayHello() {      // 公有方法，可以在类外部和内部访问（public修饰符）  System.out.println("Hello, my name is " + name); // 可以访问name字段，因为它是公有成员（虽然声明为private，但在sayHello()方法中可访问）  System.out.println("I'm " + age + " years old."); // 可以访问age字段，因为它是保护成员（protected修饰符）或公有成员（public修饰符）  }  
}

七、PHP

### PHP访问限制

PHP是一种服务端的脚本语言，在面向对象编程方面提供了以下访问修饰符：
- public：成员变量和方法对所有类都是可访问的。
- protected：成员变量和方法对当前类和继承该类的子类是可访问的。
- private：成员变量和方法仅对定义它们的类是可访问的。PHP没有`friend`关键字或双下划线开头的约定。

### PHP示例

PHP中的类成员可以被标记为public、private或protected。此外，PHP 5引入了final关键字和__construct()魔法方法。

class ExampleClass {private $privateVar;  // 只在此类内部可访问protected $protectedVar;  // 在此类及其子类内部可访问public $publicVar;  // 任何地方可访问public function __construct() {$this->privateVar = 0;$this->protectedVar = 0;$this->publicVar = 0;}
}