Java中四种权限修饰符

权限修饰符概述

修饰符	作用域
private	同一个类中
default	同一个类中，同一个包中子类、无关类
protected	同一个类中，同一个包中子类、无关类，不同包的子类
public	同一个类中，同一个包中子类、无关类，不同包的子类、无关类

Code 分析

private：私有的

• 我们可简单理解为，你的钱是私有的，不能给别人用，只能自己用,代码如下，可尝试自己敲下，理解即可。

class Test{
    // 私有的常量
    private final String name = "heng";
    // 私有的变量
    private int age;
    // 私有的方法
    private void print(){
        // 同一类中，可找到此常量
        System.out.println(name);
        // 同一类中，可找到此变量，new Test() 是匿名对象
        new Test().age = 3;
        System.out.println("Hello");
    }
}

public class TestPrivate {
    public static void main(String[] args) {
        // 创建测试类对象
        Test t = new Test();
        // 报错，因为不在同一个类中，找不到这个变量
        t.age = 1024;
        // 报错，因为不在不同一个类中，找不到此方法
        t.print();
        // 报错，因为不在同一个类中，找不到这个常量
        System.out.println(t.name);
    }
}

综上，我们可以看到 private 只适用于本类中

---

default：默认的

• 我们首先创建两个包 test1 和 test2，在包test1下再创建两个类，Test 和 TestDefault1，在包test2下创建一个类TestDefautl2。无关类指的就是两个类没有继承关系。

  

• 编写 Test 类代码，并正确运行，输出如下图所示，表明 default 修饰同一个类中可以被访问到（默认就是不写修饰符即可）

  

  // Test 类
  public class Test {
      // 默认的常量
      final String name = "heng";
      // 默认的变量
      int age;
      // 默认的方法
      void print(){
          System.out.println("Hello");
      }
  
      public static void main(String[] args) {
          // 创建测试类对象
          Test t = new Test();
          // 给默认变量赋值,并输出
          t.age = 3;
          System.out.println(t.age);
          // 输出默认常量
          System.out.println(t.name);
          // 调用默认方法
          t.print();
      }
  }
  

• 编写 TestDefault1 类，仅需将 Test 类中主方法拿过来即可，并正确运行，输出如下图所示，表明在同一个包无关类也能访问被 default 修饰的

  

  public class TestDefault1 {
      public static void main(String[] args) {
          // 创建测试类对象
          Test t = new Test();
          // 给默认变量赋值,并输出
          t.age = 3;
          System.out.println(t.age);
          // 输出默认常量
          System.out.println(t.name);
          // 调用默认方法
          t.print();
      }
  }
  

• 修改，TestDefault1 代码，让其继承 Test 类，并运行，发现可正确运行，表明 同一个包中子类也可以访问被 default 修饰的

  

  public class TestDefault1 extends Test {
      public static void main(String[] args) {
          // 创建测试类对象
          Test t = new Test();
          // 给默认变量赋值,并输出
          t.age = 3;
          System.out.println(t.age);
          // 输出默认常量
          System.out.println(t.name);
          // 调用默认方法
          t.print();
      }
  }
  

• 编写 TestDefault2 类，将 Test 中主方法拿过来即可，这里需注意，我们需要在 TestDefault2 类中将 Test 类导入进来, 不同包子类即可让 TestDefault2 继承 Test 即可，我们发现不同包子类，无关类都报错。

  

综上所述：default 修饰的只能在 同一个类中，同一个包中子类、无关类才能被访问到

---

protected：受保护的

• 理解了上述两个修饰符之后，后边的我们就比葫芦画瓢，即可，我们运用default时候，创建的 test1 和 test2 两个包和里边的3个类，将修饰符改为 protected

• 首先我们看同一个类中，即将default修改为protected 的 Test 类

  

• 我们看同一个包中的子类和无关类，无关类可自行删除继承

  

• 我们看不同包中的子类，这里需要注意，我们此时通过父类对象访问父类成员时候会报错，但是我们可通过子类对象访问父类的成员

  

• 不同包中的无关类，可删除继承自行测试，结果是无法编译的

综上所述：protected 修饰的 同一个类中，同一个包中子类、无关类、不同包的子类是可被访问到的，但需要注意的是，当不同包的子类访问是，用的是子类对象

---

public：公有的

• 我们还是运用上述代码，将 Test 类中的 protected 修改成 public 即可

• 首先，我们看 同一个类中

  

• 其次，我们再看 同一个包中子类、无关类（无关类不再演示）

  

• 最后，我们看 不同包中的子类、无关类（注意：不同包无关类是不能通过子类访问的，可不要迷糊了！）

  

  

综上所述：同一个类中，同一个包中子类、无关类、不同包的子类、无关类

最后，送大家一句话：不要害怕失败，因为失败是成功的一部分！！！