跳到主要内容

Java访问修饰符

在Java编程中，访问修饰符（Access Modifiers）用于控制类、方法、变量和构造函数的可见性和访问权限。通过使用访问修饰符，开发者可以决定哪些部分代码可以被其他类或对象访问，从而实现封装和信息隐藏。

访问修饰符的类型​

Java提供了四种访问修饰符：

  1. public：公共访问权限，任何类都可以访问。
  2. private：私有访问权限，只有定义该成员的类内部可以访问。
  3. protected：受保护的访问权限，同一包内的类以及子类可以访问。
  4. 默认（无修饰符）：包级访问权限，只有同一包内的类可以访问。

1. public 修饰符​

public 是最开放的访问修饰符。被 public 修饰的类、方法或变量可以在任何地方被访问。

java
public class PublicExample {
    public int publicVar = 10;

    public void publicMethod() {
        System.out.println("This is a public method.");
    }
}

在上述代码中，publicVar 和 publicMethod 都可以在任何类中被访问。

2. private 修饰符​

private 是最严格的访问修饰符。被 private 修饰的成员只能在定义它的类内部访问。

java
public class PrivateExample {
    private int privateVar = 20;

    private void privateMethod() {
        System.out.println("This is a private method.");
    }

    public void accessPrivate() {
        System.out.println("Accessing privateVar: " + privateVar);
        privateMethod();
    }
}

在上述代码中，privateVar 和 privateMethod 只能在 PrivateExample 类内部访问。外部类无法直接访问这些成员。

3. protected 修饰符​

protected 修饰符允许同一包内的类以及子类访问。

java
package com.example;

public class ProtectedExample {
    protected int protectedVar = 30;

    protected void protectedMethod() {
        System.out.println("This is a protected method.");
    }
}
java
package com.example;

public class SubClass extends ProtectedExample {
    public void accessProtected() {
        System.out.println("Accessing protectedVar: " + protectedVar);
        protectedMethod();
    }
}

在上述代码中，protectedVar 和 protectedMethod 可以在 ProtectedExample 类的子类 SubClass 中访问。

4. 默认（无修饰符）​

如果没有指定任何访问修饰符，则使用默认的包级访问权限。这意味着只有同一包内的类可以访问这些成员。

java
package com.example;

class DefaultExample {
    int defaultVar = 40;

    void defaultMethod() {
        System.out.println("This is a default method.");
    }
}

在上述代码中，defaultVar 和 defaultMethod 只能在 com.example 包内的类中访问。

实际应用场景​

封装​

访问修饰符是实现封装的关键。通过将类的内部数据设置为 private，可以防止外部代码直接修改这些数据，从而保护数据的完整性。

java
public class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }

    public double getBalance() {
        return balance;
    }
}

在上述代码中，balance 被设置为 private，外部代码无法直接修改 balance，只能通过 deposit 和 withdraw 方法来操作。

继承​

protected 修饰符在继承中非常有用。子类可以访问父类的 protected 成员，而其他类则不能。

java
public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    protected void makeSound() {
        System.out.println("Animal sound");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void bark() {
        System.out.println(name + " is barking.");
        makeSound();
    }
}

在上述代码中，Dog 类可以访问 Animal 类的 protected 成员 name 和 makeSound 方法。

总结​

Java的访问修饰符是控制类、方法和变量可见性的重要工具。通过合理使用 public、private、protected 和默认修饰符，开发者可以实现封装、继承和多态等面向对象编程的核心概念。

提示

提示：在实际开发中，建议尽量使用 private 修饰符来保护类的内部数据，并通过公共方法提供访问接口。

附加资源与练习​

  • 练习：创建一个包含 public、private、protected 和默认修饰符的类，并尝试在不同包和类中访问这些成员。
  • 资源：阅读Java官方文档中关于访问控制的章节，深入了解访问修饰符的更多细节。

通过掌握访问修饰符，你将能够更好地设计和组织你的Java代码，使其更加健壮和易于维护。