Java 中的访问修饰符

最新推荐文章于 2025-03-04 11:41:46 发布

需要重新演唱

最新推荐文章于 2025-03-04 11:41:46 发布

阅读量1k

点赞数 20

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/xycxycooo/article/details/143484782

版权

Java 中的访问修饰符

在 Java 中，访问修饰符（Access Modifiers）用于控制类、方法、变量和构造方法的访问权限。通过使用不同的访问修饰符，我们可以限制或允许其他类对这些成员的访问。Java 提供了四种访问修饰符：public、protected、private 和默认（无修饰符）。理解这些访问修饰符的作用和使用场景，对于编写安全、可维护的代码至关重要。

1. 访问修饰符的类型

1.1 `public`

作用：public 修饰符表示该成员可以被任何类访问，无论这些类是否在同一个包中。
适用范围：类、方法、变量、构造方法。

public class PublicExample {
    public String name;

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

    public void display() {
        System.out.println("Name: " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        PublicExample example = new PublicExample("John");
        example.display(); // 输出: Name: John
    }
}

代码解释：

public class PublicExample：PublicExample 类可以被任何类访问。
public String name：name 变量可以被任何类访问。
public PublicExample(String name)：构造方法可以被任何类访问。
public void display()：display 方法可以被任何类访问。

1.2 `protected`

作用：protected 修饰符表示该成员可以被同一个包中的所有类访问，也可以被不同包中的子类访问。
适用范围：方法、变量、构造方法。

package com.example.package1;

public class ProtectedExample {
    protected String name;

    protected ProtectedExample(String name) {
        this.name = name;
    }

    protected void display() {
        System.out.println("Name: " + name);
    }
}

package com.example.package2;

import com.example.package1.ProtectedExample;

public class SubClass extends ProtectedExample {
    public SubClass(String name) {
        super(name);
    }

    public void showInfo() {
        System.out.println("SubClass Name: " + name);
        display(); // 可以访问父类的 protected 方法
    }
}

public class Main {
    public static void main(String[] args) {
        SubClass subClass = new SubClass("John");
        subClass.showInfo(); // 输出: SubClass Name: John
    }
}

代码解释：

protected String name：name 变量可以被同一个包中的类访问，也可以被不同包中的子类访问。
protected ProtectedExample(String name)：构造方法可以被同一个包中的类访问，也可以被不同包中的子类访问。
protected void display()：display 方法可以被同一个包中的类访问，也可以被不同包中的子类访问。

1.3 `private`

作用：private 修饰符表示该成员只能被同一个类中的其他成员访问，不能被其他类访问。
适用范围：方法、变量、构造方法。

public class PrivateExample {
    private String name;

    private PrivateExample(String name) {
        this.name = name;
    }

    private void display() {
        System.out.println("Name: " + name);
    }

    public static void main(String[] args) {
        PrivateExample example = new PrivateExample("John");
        example.display(); // 输出: Name: John
    }
}

代码解释：

private String name：name 变量只能被 PrivateExample 类中的其他成员访问。
private PrivateExample(String name)：构造方法只能被 PrivateExample 类中的其他成员访问。
private void display()：display 方法只能被 PrivateExample 类中的其他成员访问。

1.4 默认（无修饰符）

作用：如果没有指定访问修饰符，则该成员的访问权限为默认（包级私有），即只能被同一个包中的类访问。
适用范围：类、方法、变量、构造方法。

package com.example.package1;

class DefaultExample {
    String name;

    DefaultExample(String name) {
        this.name = name;
    }

    void display() {
        System.out.println("Name: " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        DefaultExample example = new DefaultExample("John");
        example.display(); // 输出: Name: John
    }
}

代码解释：

class DefaultExample：DefaultExample 类只能被同一个包中的类访问。
String name：name 变量只能被同一个包中的类访问。
DefaultExample(String name)：构造方法只能被同一个包中的类访问。
void display()：display 方法只能被同一个包中的类访问。

2. 访问修饰符的实际应用

2.1 封装（Encapsulation）

封装是面向对象编程中的一个重要概念，它通过访问修饰符来隐藏类的内部实现细节，只暴露必要的接口。这样可以提高代码的安全性和可维护性。

public class EncapsulationExample {
    private String name;
    private int age;

    public EncapsulationExample(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) {
        if (age > 0) {
            this.age = age;
        } else {
            System.out.println("Age must be greater than 0.");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        EncapsulationExample example = new EncapsulationExample("John", 30);
        System.out.println("Name: " + example.getName()); // 输出: Name: John
        System.out.println("Age: " + example.getAge());   // 输出: Age: 30

        example.setAge(-5); // 输出: Age must be greater than 0.
    }
}

代码解释：

private String name 和 private int age：name 和 age 变量被封装在类内部，外部无法直接访问。
public String getName() 和 public void setName(String name)：提供公共的 getter 和 setter 方法，用于访问和修改 name 变量。
public int getAge() 和 public void setAge(int age)：提供公共的 getter 和 setter 方法，用于访问和修改 age 变量，并在 setter 方法中添加了验证逻辑。

2.2 继承中的访问控制

在继承中，子类可以访问父类的 public 和 protected 成员，但不能访问 private 成员。默认成员只能被同一个包中的类访问。

package com.example.package1;

public class Parent {
    public String publicVar = "Public Variable";
    protected String protectedVar = "Protected Variable";
    String defaultVar = "Default Variable";
    private String privateVar = "Private Variable";

    public void publicMethod() {
        System.out.println("Public Method");
    }

    protected void protectedMethod() {
        System.out.println("Protected Method");
    }

    void defaultMethod() {
        System.out.println("Default Method");
    }

    private void privateMethod() {
        System.out.println("Private Method");
    }
}

package com.example.package1;

public class Child extends Parent {
    public void accessParentMembers() {
        System.out.println(publicVar);       // 可以访问
        System.out.println(protectedVar);    // 可以访问
        System.out.println(defaultVar);      // 可以访问
        // System.out.println(privateVar);  // 编译错误，无法访问

        publicMethod();   // 可以访问
        protectedMethod(); // 可以访问
        defaultMethod();   // 可以访问
        // privateMethod(); // 编译错误，无法访问
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.accessParentMembers();
    }
}