HarmonyOS Next 类的访问修饰符深度实践：封装性与可见性的精准控制

在 HarmonyOS Next 开发中，类的访问修饰符是实现数据封装与模块隔离的核心机制。通过 private、internal、protected 和 public 修饰符，开发者能够精确控制类成员的可见范围，平衡代码的封装性与可扩展性。本文基于《仓颉编程语言开发指南》，解析访问修饰符的规则、应用场景及最佳实践。

一、访问修饰符的作用域规则

HarmonyOS Next 提供四种访问修饰符，控制成员在不同作用域的可见性：

修饰符	作用域描述
private	仅在定义该成员的类内部可见。
internal	在当前包及子包内可见（默认修饰符）。
protected	在当前类及其子类可见，且仅限同一模块内。
public	在所有模块中可见，但需遵循包的导出规则。

示例：包结构与访问权限

package device.core  
public open class Hardware {  
    private var serialNumber: String // 仅Hardware类内部可见  
        internal func reset() { ... }     // device.core包及子包可见  
            protected var firmwareVersion: String // 子类可见（需在同一模块）  
                public var model: String        // 全局可见  
                }  
                ```

## 二、类成员的访问控制实践  

### 1. `private`：严格封装内部实现  
- **适用场景**：禁止外部访问的私有逻辑，如敏感数据、中间计算变量。  
- - **示例**：  
-   ```cj
-   class SecureSensor {  
-       private var rawData: [UInt8] = [] // 私有成员：原始传感器数据  
-       public func processData() {  
-           rawData.decode() // 内部处理逻辑  
-       }  
-       // 外部无法访问rawData，只能通过公开方法操作  
-   }
-   ```
### 2. `internal`：包内可见的模块私有  
- **适用场景**：模块内部协作的工具类或辅助函数，避免污染全局命名空间。  
- - **示例**：  
-   ```cj
-   package network.internal  
-   internal class SocketManager {  
-       func connect() { ... } // 仅在network.internal包及子包可见  
-   }  
-   ```
### 3. `protected`：子类可见的继承扩展  
- **适用场景**：允许子类重写或访问的基类成员，但限制跨模块访问。  
- - **示例**：  
-   ```cj
-   open class BaseDevice {  
-       protected var status: DeviceStatus // 子类可访问，但仅限同一模块  
-       public func getStatus() -> DeviceStatus { status }  
-   }  
-   class WirelessDevice <: BaseDevice {  
-       public func updateStatus() {  
-           status = .Online // 子类可访问protected成员  
-       }  
-   }  
-   ```
### 4. `public`：全局可见的公共接口  
- **适用场景**：需要暴露给其他模块的核心接口或数据。  
- - **注意事项**：`public` 类的成员默认 `internal`，需显式声明 `public` 以全局可见：  
-   ```cj
-   public class PublicAPI {  
-       public var publicField: Int // 必须显式声明public  
-       var internalField: String // 默认为internal，跨模块不可见  
-   }  
-   ```

## 三、构造函数与访问控制  

### 1. 构造函数的访问修饰  
构造函数可通过修饰符控制实例化权限，实现设计模式：  
- **单例模式**：私有构造函数禁止外部实例化  
-   ```cj
-   class Singleton {  
-       public static let instance = Singleton()  
-       private init() { /* 初始化逻辑 */ } // 私有构造函数  
-   }  
-   ```
- - **工厂模式**：包内可见的构造函数配合静态工厂方法  
-   ```cj
-   package database  
-   internal class DatabaseConnection {  
-       internal init(url: String) { ... }  
-       public static func create(url: String) -> DatabaseConnection {  
-           DatabaseConnection(url: url) // 包内创建实例  
-       }  
-   }  
-   ```
### 2. 继承中的构造函数可见性  
子类构造函数的访问修饰符需与父类匹配或更宽松：  
```cj
open class Parent {  
    protected init() { /* 受保护构造函数 */ }  
    }  
    class Child <: Parent {  
        // 子类构造函数默认internal，可访问父类protected构造函数  
            public init() { super.init() }  
            }  
            ```

## 四、跨模块访问与包管理  

### 1. 包导出规则  
- 模块中的 `public` 类需在包声明中导出，否则跨模块不可见：  
-   ```cj
-   // package.json  
-   {  
-     "name": "my.module",  
-     "exports": {  
-       ".": ["public-classes"]  
-     }  
-   }  
-   ```
### 2. 访问修饰符与接口实现  
接口成员默认 `public`，实现类需使用相同或更宽松的修饰符：  
```cj
interface PublicInterface {  
    func publicMethod()  
    }  
    class Implementation <: PublicInterface {  
        // 必须声明public，否则默认internal不满足接口要求  
            public func publicMethod() { ... }  
            }  
            ```

## 五、常见陷阱与最佳实践  

### 1. 避免过度使用`public`  
- 反例：暴露过多实现细节，破坏封装性  
-   ```cj
-   public class BadDesign {  
-       public var internalLogic: Int // 外部可直接修改，违反封装原则  
-   }  
-   ```
- - 正例：通过公共方法间接访问私有成员  
-   ```cj
-   public class GoodDesign {  
-       private var _value: Int = 0  
-       public func getValue() -> Int { _value }  
-       public func setValue(newValue: Int) { _value = newValue }  
-   }  
-   ```
### 2. `protected`的模块限制  
- `protected` 成员在跨模块子类中不可见，需使用 `public` 或通过接口暴露：  
-   ```cj
-   // 模块A  
-   open class Base {  
-       protected func protectedFunc() { ... } // 模块A内子类可见  
-   }  
-   // 模块B  
-   class Child <: Base {  
-       func useProtected() {  
-           protectedFunc() // 编译错误：跨模块不可访问protected成员  
-       }  
-   }  
-   ```
### 3. 接口与访问修饰符的协同  
接口成员的访问级别决定实现类的最低要求：  
```cj
interface RestrictedInterface {  
    internal func restrictedMethod() // 接口成员为internal  
    }  
    class Implementation <: RestrictedInterface {  
        // 实现方法至少为internal（默认），不可声明为private  
            func restrictedMethod() { ... }  
            }  
            ```

## 六、总结：访问修饰符的设计原则  
HarmonyOS Next 的访问修饰符体系遵循以下核心原则：  
1. **最小特权原则**：默认 `internal`，仅暴露必要的公共接口；  
2. 2. **封装优先**：使用 `private` 隐藏实现细节，通过公共方法提供访问入口；  
3. 3. **模块隔离**：利用 `internal` 和 `protected` 控制包内与继承层次的可见性。