【面向对象】对比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 main

import (
    "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 is
    procedure Public_Procedure;
private
    procedure Private_Procedure;
end Example;

package body Example is

    procedure Public_Procedure is
    begin
        -- implementation
    end Public_Procedure;

    procedure Private_Procedure is
    begin
        -- implementation
    end Private_Procedure;

end Example;

-- 另一个文件或包使用 Example
with Example;
procedure Use_Example is
begin
    Example.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 mangling
        print(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;
    }
}