跳到主要内容

Java 访问修饰符

提示
  1. 访问修饰符的定义和作用：Java中的访问修饰符用于设置类、接口、变量、方法等的可访问性或可见性。例如，public 和 private 关键字分别设置成员的公共和私有访问级别。
  2. Java访问修饰符的类型：Java提供了四种访问修饰符：
    • 默认（包私有）：没有显式修饰符，限制访问范围在同一包内。
    • 私有（private）：只在声明它们的类内部可见。
    • 受保护（protected）：在同一包内或子类中可见。
    • 公共（public）：在任何地方都可见。
  3. 访问修饰符的应用举例：
    • 默认访问修饰符：类默认可见性限于同一包内。
    • 私有访问修饰符：私有成员仅在其类内部可见，通常通过getter和setter方法访问。
    • 受保护访问修饰符：可在相同包内或所有子类中访问。
    • 公共访问修饰符：无限制地在任何地方访问。

什么是访问修饰符？​

在 Java 中，访问修饰符用于设置类、接口、变量、方法、构造函数、数据成员和 setter 方法的可访问性（可见性）。例如，

class Animal {
    public void method1() {...}

   private void method2() {...}
}

在上面的示例中，我们声明了两个方法：method1() 和 method2()。这里，

  • method1 是 public 的 - 这意味着它可以被其他类访问。
  • method2 是 private 的 - 这意味着它不能被其他类访问。

注意关键字 public 和 private。这些是 Java 中的访问修饰符。它们也被称为可见性修饰符。

注意：你不能为 getter 方法设置访问修饰符。

访问修饰符的类型​

在了解访问修饰符的类型之前，请确保你了解了Java 包。

Java 中有四种访问修饰符关键字，它们是：

| 修饰符 | 描述 | | 默认 | 声明仅在包内可见（包私有） | | 私有 | 声明仅在类内部可见 | | 受保护 | 声明在包内或所有子类中可见 | | 公共 | 声明在任何地方都可见 |

默认访问修饰符​

如果我们没有为类、方法、变量等明确指定任何访问修饰符，则默认情况下会考虑默认访问修饰符。例如，

package defaultPackage;
class Logger {
    void message(){
        System.out.println("这是一条信息");
    }
}

这里，Logger 类具有默认访问修饰符。并且该类对属于 defaultPackage 包的所有类都可见。然而，如果我们尝试在 defaultPackage 外的另一个类中使用 Logger 类，我们将得到编译错误。

私有访问修饰符​

当变量和方法被声明为 private 时，它们不能在类的外部被访问。例如，

class Data {
    // 私有变量
    private String name;
}

public class Main {
    public static void main(String[] main){

        // 创建 Data 的对象
        Data d = new Data();

        // 从另一个类访问私有变量和字段
        d.name = "mashangxue123";
    }
}

在上面的示例中，我们声明了一个名为 name 的私有变量。当我们运行程序时，我们将得到以下错误：

Main.java:18: error: name 在 Data 中有私有访问权限
        d.name = "mashangxue123";
         ^

产生错误的原因是我们试图从 Main 类访问 Data 类的私有变量。

你可能想知道如果我们需要访问这些私有变量该怎么办。在这种情况下，我们可以使用 getter 和 setter 方法。例如，

class Data {
    private String name;

    // getter 方法
    public String getName() {
        return this.name;
    }
    // setter 方法
    public void setName(String name) {
        this.name= name;
    }
}
public class Main {
    public static void main(String[] main){
        Data d = new Data();

        // 使用 getter 和 setter 访问私有变量
        d.setName("mashangxue123");
        System.out.println(d.getName());
    }
}

输出：

名字是 mashangxue123

在上面的示例中，我们有一个名为 name 的私有变量。为了从外部类访问这个变量，我们使用了方法：getName() 和 setName()。这些方法在 Java 中被称为 getter 和 setter。

这里，我们使用了 setter 方法 (setName()) 来为变量赋值，以及 getter 方法 (getName()) 来访问变量。

我们在 setName() 内部使用了 this 关键字来指代类的变量。要了解更多关于这个关键字的信息，请访问 Java this 关键字。

注意：我们不能在 Java 中将类和接口声明为私有的。然而，嵌套类可以声明为私有的。要了解更多，请访问 Java 嵌套和内部类。

受保护的访问修饰符​

当方法和数据成员被声明为 protected 时，我们可以在相同的包中以及从子类中访问它们。例如，

class Animal {
    // 受保护的方法
    protected void display() {
        System.out.println("我是一只动物");
    }
}

class Dog extends Animal {
    public static void main(String[] args) {

        // 创建 Dog 类的对象
        Dog dog = new Dog();
        // 访问受保护的方法
        dog.display();
    }
}

输出：

我是一只动物

在上面的示例中，我们在 Animal 类内部有一个名为 display() 的受保护方法。Animal 类被 Dog 类继承。要了解更多关于继承的信息，请访问 Java 继承。

然后我们创建了 Dog 类的一个对象 dog。使用这个对象，我们尝试访问父类的受保护方法。

由于受保护的方法可以从子类中访问，我们能够从 Dog 类访问 Animal 类的方法。

注意：我们不能在 Java 中将类或接口声明为 protected。

公共访问修饰符​

当方法、变量、类等被声明为 public 时，我们可以从任何地方访问它们。公共访问修饰符没有范围限制。例如，

// Animal.java 文件
// 公共类
public class Animal {
    // 公共变量
    public int legCount;

    // 公共方法
    public void display() {
        System.out.println("我是一只动物。");
        System.out.println("我有 " + legCount + " 条腿。");
    }
}

// Main.java
public class Main {
    public static void main( String[] args ) {
        // 访问公共类
        Animal animal = new Animal();

        // 访问公共变量
        animal.legCount = 4;
        // 访问公共方法
        animal.display();
    }
}

输出：

我是一只动物。
我有 4 条腿。

这里，

  • 公共类 Animal 被 Main 类访问。
  • 公共变量 legCount 被 Main 类访问。
  • 公共方法 display() 被 Main 类访问。

用一张图总结访问修饰符​

Java 中所有访问修饰符的可访问性

访问修饰符主要用于封装。它可以帮助我们控制程序的哪一部分可以访问类的成员。这样就可以防止数据被滥用。要了解更多关于封装的信息，请访问 [Java 封装](/tutorials/java-program

ming/encapsulation)。

最后于 更新