java-权限修饰符

## Java中的权限修饰符

Java中的权限修饰符（Access Modifiers）用于控制类、方法和变量的访问级别。通过权限修饰符，可以在一定范围内保护类的成员，确保数据的封装和安全性。Java提供了四种主要的权限修饰符：`private`、`default`（也称为包级私有）、`protected`和`public`。每种修饰符都有不同的访问权限范围，下面将详细解释每种修饰符的使用和特点。

### 1. `private`

`private`修饰符是最严格的权限修饰符，表示该成员只能在它所在的类中访问。其他类，包括它的子类和同一个包中的其他类，均无法访问它。使用`private`修饰符可以有效地隐藏类的内部实现，保护数据的私密性。

#### 示例

```java
class Person {
private String name;
private int age;

public Person(String name, int age) {
this.name = name;
this.age = age;
}

private void displayInfo() {
System.out.println("Name: " + name + ", Age: " + age);
}

public void showInfo() {
displayInfo(); // 只能在同一个类中调用
}
}

public class Main {
public static void main(String[] args) {
Person person = new Person("Alice", 30);
person.showInfo(); // 通过公有方法访问私有方法
// person.displayInfo(); // 错误，无法访问私有方法
}
}
```

在上述代码中，`Person`类的成员变量`name`和`age`以及方法`displayInfo`都被声明为`private`，只能在`Person`类内部访问。通过`showInfo`方法，外部类可以间接访问这些私有成员。

### 2. `default`（包级私有）

`default`修饰符，也称为包级私有，是不加任何修饰符的默认访问级别。表示该成员在同一个包中的其他类可以访问，但在不同包中的类无法访问。`default`修饰符用于限制类的成员在包内的可见性，通常用于包内协作的类。

#### 示例

```java
class Person {
String name; // 包级私有
int age; // 包级私有

Person(String name, int age) {
this.name = name;
this.age = age;
}

void displayInfo() {
System.out.println("Name: " + name + ", Age: " + age);
}
}

public class Main {
public static void main(String[] args) {
Person person = new Person("Bob", 25);
person.displayInfo(); // 同一个包中的类可以访问包级私有成员
}
}
```

在上述代码中，`Person`类的成员变量`name`和`age`以及方法`displayInfo`都没有显式的权限修饰符，因此它们是包级私有的。同一个包中的`Main`类可以访问这些成员。

### 3. `protected`

`protected`修饰符表示该成员可以在同一个包中的类和不同包中的子类中访问。`protected`修饰符提供了包级访问权限，并允许继承关系中的子类访问父类的受保护成员。

#### 示例

```java
class Person {
protected String name;
protected int age;

protected Person(String name, int age) {
this.name = name;
this.age = age;
}

protected void displayInfo() {
System.out.println("Name: " + name + ", Age: " + age);
}
}

class Employee extends Person {
private String position;

public Employee(String name, int age, String position) {
super(name, age);
this.position = position;
}

public void showEmployeeInfo() {
displayInfo(); // 子类可以访问父类的受保护方法
System.out.println("Position: " + position);
}
}

public class Main {
public static void main(String[] args) {
Employee employee = new Employee("Charlie", 40, "Manager");
employee.showEmployeeInfo(); // 访问受保护方法
}
}
```

在上述代码中，`Person`类的成员变量`name`和`age`以及方法`displayInfo`被声明为`protected`，因此`Employee`类可以访问这些成员。

### 4. `public`

`public`修饰符表示该成员可以在任何地方访问，不受包或继承关系的限制。`public`修饰符提供了最大的访问权限，用于那些需要广泛访问的类和成员。

#### 示例

```java
public class Person {
public String name;
public int age;

public Person(String name, int age) {
this.name = name;
this.age = age;
}

public void displayInfo() {
System.out.println("Name: " + name + ", Age: " + age);
}
}

public class Main {
public static void main(String[] args) {
Person person = new Person("David", 35);
person.displayInfo(); // 访问公有方法
}
}
```

在上述代码中，`Person`类的成员变量`name`和`age`以及方法`displayInfo`被声明为`public`，因此任何地方都可以访问这些成员。

### 5. 权限修饰符的访问级别总结

为了更好地理解各权限修饰符的访问级别，可以参考下表：

| 修饰符 | 同一个类 | 同一个包 | 不同包中的子类 | 不同包中的非子类 |
| ----------- | -------- | -------- | ------------- | --------------- |
| `private` | 是 | 否 | 否 | 否 |
| `default` | 是 | 是 | 否 | 否 |
| `protected` | 是 | 是 | 是 | 否 |
| `public` | 是 | 是 | 是 | 是 |

### 6. 使用权限修饰符的最佳实践

在实际开发中，合理使用权限修饰符可以提高代码的安全性和可维护性。以下是一些最佳实践：

#### 1. 封装

优先考虑将成员变量声明为`private`，通过公共方法（如getter和setter）来访问和修改它们的值。这种方式有助于封装类的内部实现，防止外部直接修改对象的状态。

```java
class Person {
private String name;
private int age;

public Person(String name, int age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
}
```

#### 2. 限制访问范围

根据需要限制成员的访问范围。不要随意将成员声明为`public`，而是根据实际需求选择合适的权限修饰符。