java从头记-public、protected、default、private

当定义一个类及其成员时，可以使用不同的访问修饰符来控制类成员的可见性，从而限定它们的作用域。以下是详细解释每个访问修饰符的作用：

1. public 访问修饰符:

   • public 成员可以被任何其他类访问，无论是否在同一个包内。
   • 在不同的包内，可以使用类的对象来访问 public 成员。
   • public 成员的作用域最广，可在整个程序中访问。
   • 示例：

   public class MyClass {
       public int publicField;
   
       public void publicMethod() {
           // 在这里编写代码
       }
   }
   

2. protected 访问修饰符:

   • protected 成员只能在同一个包内的类和该类的子类中访问。
   • 在不同的包内，只有该类的子类可以通过继承方式访问 protected 成员。
   • protected 成员的作用域介于 public 和默认访问修饰符之间。
   • 示例：

   public class MyClass {
       protected int protectedField;
   
       protected void protectedMethod() {
           // 在这里编写代码
       }
   }
   

3. 默认（default）访问修饰符:

   • 如果没有使用任何访问修饰符，则成员默认为 default，也称为包级访问。
   • default 成员只能在同一个包内的其他类中访问。
   • default 成员在不同的包内是不可见的，即其他包中的类无法直接访问。
   • 示例：

   class MyClass {
       int defaultField;
   
       void defaultMethod() {
           // 在这里编写代码
       }
   }
   

4. private 访问修饰符:

   • private 成员只能在同一个类内部访问，其他类无法直接访问。
   • private 修饰符提供了最高级别的封装，确保成员的隐藏性，只能通过类的公共方法间接访问。
   • private 成员的作用域最小，仅限于类内部。
   • 示例：

   public class MyClass {
       private int privateField;
   
       private void privateMethod() {
           // 在这里编写代码
       }
   }
   

根据程序的需求和设计原则，选择合适的访问修饰符来限定类成员的作用域，以保证程序的安全性和可维护性。遵循访问修饰符的最佳实践，可以有效地控制类成员的可见性，并降低代码的耦合性，使代码更加健壮和易于维护。

访问修饰符	同一类内部	同一包内的类	不同包内的子类	不同包内的非子类
public	可见	可见	可见	可见
protected	可见	可见	可见	不可见
default	可见	可见	不可见	不可见
private	可见	不可见	不可见	不可见

在表格中，对于每个访问修饰符，标记了该修饰符下成员的可见性情况：

• “可见” 表示成员可以被访问。
• “不可见” 表示成员在当前情况下不可被访问。

需要注意的是，对于protected访问修饰符，虽然子类可以访问其父类中的protected成员，但是在不同包内的非子类中仍然不可见。对于default访问修饰符，虽然在同一包内的类中可以访问，但是在不同包内的类中仍然不可见。而private访问修饰符则在任何情况下都只能在类内部访问。

这些访问修饰符的不同作用域和可见性有助于控制类成员的访问权限，从而实现封装、隐藏数据，并保证程序的安全性和可维护性。

具体示例

// 文件名：Student.java

public class Student {
    public String name;      // 公开访问
    protected int age;       // 受保护访问
    int score;              // 默认访问修饰符
    private String address;  // 私有访问

    // 构造方法
    public Student(String name, int age, int score, String address) {
        this.name = name;
        this.age = age;
        this.score = score;
        this.address = address;
    }

    // 公开方法
    public void printInfo() {
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("成绩：" + score);
        // 注意：私有成员在类的内部可以直接访问
        System.out.println("地址：" + address);
    }

    // 受保护方法
    protected void showAge() {
        System.out.println("年龄：" + age);
    }

    // 默认访问修饰符方法
    void showScore() {
        System.out.println("成绩：" + score);
    }

    // 私有方法
    private void showAddress() {
        System.out.println("地址：" + address);
    }
}

// 文件名：Main.java

public class Main {
    public static void main(String[] args) {
        Student student = new Student("Alice", 20, 85, "Beijing");
        
        // 公开成员和方法可以在任何地方访问
        student.name = "Bob";
        student.printInfo();

        // 受保护成员和方法只能在同一个包或子类中访问
        student.age = 21;
        student.showAge();

        // 默认访问修饰符的成员和方法只能在同一个包中访问
        student.score = 90;
        student.showScore();

        // 私有成员和方法只能在同一个类中访问
        // student.address = "Shanghai";  // 编译错误
        // student.showAddress();        // 编译错误
    }
}

在上面的示例中，我们定义了一个名为 Student 的类，并使用不同的访问修饰符来控制成员的可见性。在 Main 类中，我们可以看到不同访问修饰符对成员和方法的可访问范围产生的影响。请注意，Main 类和 Student 类在同一个包内，因此可以访问默认访问修饰符和受保护访问修饰符的成员和方法。而私有访问修饰符的成员和方法只能在类的内部访问，其他类无法直接访问。