Java中的private访问修饰符

悠悠 2024-03-16 20:10 47阅读 0赞

### 1. 概述 ###

在 Java 编程语言中，字段、构造函数、方法和类可以使用[访问修饰符][Link 1]进行标记。在本教程中，我们将讨论 Java 中的*私有*访问修饰符。

### 2. 关键词 ###

*私有*访问修饰符很重要，因为它允许封装和信息隐藏，这是面向对象编程的核心原则。封装负责捆绑方法和数据，而信息隐藏是封装的结果——它隐藏了对象的内部表示。

首先要记住的是，声明为*私有*的元素只能由声明它们的类访问。

### 3. 字段 ###

现在，我们将看到一些简单的代码示例，以更好地理解该主题。

首先，让我们创建一个包含几个*私有*实例变量的 *Employee* 类：

public class Employee {
        private String privateId;
        private boolean manager;
        //...
    }

在此示例中，我们将 *privateId* 变量标记为*私有*，因为我们想向 id 生成添加一些逻辑。而且，正如我们所看到的，我们对 *manager* 属性做了同样的事情，因为我们不想允许直接修改这个字段。

### 4. 构造函数 ###

现在让我们创建一个*私有*构造函数：

private Employee(String id, String name, boolean managerAttribute) {
        this.name = name;
        this.privateId = id + "_ID";
    }

通过将构造函数标记为*私有*，我们只能从类内部使用它。

让我们添加一个*静态*方法，这将是我们在 *Employee* 类外部使用此*私有*构造函数的唯一方法：

public static Employee buildManager(String id, String name) {
        return new Employee(id, name, true);
    }

现在，我们可以通过简单地编写以下命令来获取 *Employee* 类的管理器实例：

Employee manager = Employee.buildManager("123MAN","Bob");

当然，在幕后，*buildManager* 方法调用我们的*私有*构造函数。

### 5. 方法 ###

现在让我们向类添加一个*私有*方法：

private void setManager(boolean manager) {
        this.manager = manager;
    }

假设出于某种原因，我们公司有一条任意规则，只有名叫“Carl”的员工才能晋升为经理，尽管其他人并不知道这一点。我们将创建一个*具有*一些逻辑的公共方法来处理*调用私有方法*：

public void elevateToManager() {
        if ("Carl".equals(this.name)) {
            setManager(true);
        }
    }

### 6. private方法 ###

让我们看看如何从外部使用我们的 *Employee* 类的示例：

public class ExampleClass {
    
        public static void main(String[] args) {
            Employee employee = new Employee("Bob","ABC123");
            employee.setPrivateId("BCD234");
            System.out.println(employee.getPrivateId());
        }
    }

执行 *ExampleClass* 后，我们将在控制台上看到它的输出：

BCD234_ID

在这个例子中，我们使用了公共构造函数和*公共*方法 `setPrivateId(`*Id），*因为我们无法直接访问*私有*变量 *privateId*。

看看如果我们尝试从 *Employee* 类外部访问*私有*方法、构造函数或变量会发生什么：

public class ExampleClass {
    
        public static void main(String[] args) {
            Employee employee = new Employee("Bob","ABC123",true);
            employee.setManager(true);
            employee.privateId = "ABC234";
        }
    }

我们将收到每个非法语句的编译错误：

The constructor Employee(String, String, boolean) is not visible
    The method setManager(boolean) from the type Employee is not visible
    The field Employee.privateId is not visible

### 7. private 类 ###

在特殊情况下，我们可以创建一个*私有*类 — 作为其他类的内部类。否则，如果我们要将一个外部类声明为*私有*类，将禁止其他类访问它，使其无用：

public class PublicOuterClass {
    
        public PrivateInnerClass getInnerClassInstance() {
            PrivateInnerClass myPrivateClassInstance = this.new PrivateInnerClass();
            myPrivateClassInstance.id = "ID1";
            myPrivateClassInstance.name = "Bob";
            return myPrivateClassInstance;
        }
    
        private class PrivateInnerClass {
            public String name;
            public String id;
        }
    }

在此示例中，我们通过指定*私有*访问修饰符在 *PublicOuterClass* 中创建了一个*私有*内部类。

因为我们使用了 *private* 关键字，如果我们出于某种原因尝试从 *PublicOuterClass* 外部实例化我们的 *PrivateInnerClass*，代码将无法编译，我们将看到错误：

PrivateInnerClass cannot be resolved to a type

### 8. 结论 ###

在本快速教程中，我们讨论了 Java 中的*私有*访问修饰符。这是实现封装的好方法，这会导致信息隐藏。因此，我们可以确保仅向其他类公开我们想要的数据和行为。

[Link 1]: https://www.cnblogs.com/BlogNetSpace/p/17265824.html