一文搞定Java访问控制符public、private、protected、默认的区别

public class Person {
    private int age;          // 私有成员
    
    private void secret() {   // 私有方法
        System.out.println("这是秘密");
    }
    
    public void show() {
        System.out.println(age);  // ✅ 同类中可访问
        secret();                  // ✅ 同类中可访问
    }
}

public class Test {
    public static void main(String[] args) {
        Person p = new Person();
        // p.age = 10;     ❌ 编译错误
        // p.secret();     ❌ 编译错误
    }
}

// 文件：com/example/Person.java
package com.example;

class Person {              // 默认修饰符
    String name;            // 默认修饰符
    
    void sayHello() {       // 默认修饰符
        System.out.println("Hello");
    }
}

// 文件：com/example/TestSamePackage.java
package com.example;

public class TestSamePackage {
    public static void main(String[] args) {
        Person p = new Person();   // ✅ 同包可访问
        p.name = "Alice";           // ✅ 同包可访问
        p.sayHello();               // ✅ 同包可访问
    }
}

// 文件：com/other/TestDifferentPackage.java
package com.other;
import com.example.Person;

public class TestDifferentPackage {
    public static void main(String[] args) {
        Person p = new Person();   // ❌ 编译错误（类不可见）
    }
}

// 文件：com/example/Animal.java
package com.example;

public class Animal {
    protected String name;
    
    protected void eat() {
        System.out.println("吃东西");
    }
}

// 文件：com/example/TestSamePackage.java
package com.example;

public class TestSamePackage {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.name = "Tom";    // ✅ 同包可访问
        a.eat();            // ✅ 同包可访问
    }
}

// 文件：com/other/Dog.java（不同包，但继承 Animal）
package com.other;
import com.example.Animal;

public class Dog extends Animal {
    public void test() {
        name = "旺财";   // ✅ 子类可访问 protected 成员
        eat();            // ✅ 子类可访问 protected 方法
    }
}

// 文件：com/other/TestNotSubclass.java
package com.other;
import com.example.Animal;

public class TestNotSubclass {
    public static void main(String[] args) {
        Animal a = new Animal();
        // a.name = "Jerry";   ❌ 不同包且非子类，不可访问
        // a.eat();            ❌ 编译错误
    }
}

// 不同包子类中的特殊规则
package com.other;
import com.example.Animal;

public class Cat extends Animal {
    public void test() {
        name = "Kitty";        // ✅ 自己的继承成员
        eat();                  // ✅ 自己的继承成员
        
        Animal a = new Animal();
        // a.name = "Test";    ❌ 不能通过父类对象访问
    }
}

public class Utils {
    public static final double PI = 3.14159;
    
    public void printMessage() {
        System.out.println("公开方法");
    }
}

// 任何包、任何类中都可以访问

public class Demo {
    private   int a = 1;
              int b = 2;   // 默认
    protected int c = 3;
    public    int d = 4;
    
    public void test() {
        System.out.println(a); // ✅ private 可访问
        System.out.println(b); // ✅ 默认可访问
        System.out.println(c); // ✅ protected 可访问
        System.out.println(d); // ✅ public 可访问
    }
}

public class PublicClass {}     // ✅ 正确
class DefaultClass {}           // ✅ 正确
// private class PrivateClass {}   ❌ 编译错误
// protected class ProtectedClass {} ❌ 编译错误

class Father {
    protected void method1() {}
    public void method2() {}
}

class Son extends Father {
    @Override
    public void method1() {}   // ✅ protected → public 放宽权限
    
    @Override
    // protected void method2() {}   ❌ public → protected 收窄权限，编译错误
}

package packageA;
public class A {
    private   void m1() {}
              void m2() {}
    protected void m3() {}
    public    void m4() {}
}

package packageA;
public class B extends A {
    // 问：B 中可以访问 A 的哪些方法？
}

package packageB;
import packageA.A;
public class C extends A {
    // 问：C 中可以访问 A 的哪些方法？
}

package packageB;
public class D {
    A a = new A();
    // 问：D 中可以访问 A 的哪些方法？
}