java访问修饰符总结

java的访问修饰符

java面向对象的基本思想之一是封装细节并且公开接口。
java采用访问修饰符来封装类的方法和属性的访问权限，从而向使用者暴露接口、隐藏细节。

• public -- 对所有类可见。使用对象：类、接口、变量、方法

import pkg2.A;

public class Main {

  public static void main(String[] args) {
    A a = new A();
    a.method(a.field); // 所有类均可以访问权限为public的class A
  }}

// ---------------------------------------------------------------------

package pkg2;

public class A implements B { // 该类的访问权限为public
  public int field; // 该字段的访问权限为public

  public void method(int aInt) {
    // 该方法的访问权限为public
  }

  @Override
  public void method1() {
    System.out.println("method1 is implemented.");
  }}

public interface B { // 该接口的访问权限为public
  public void method1();}
}

• protected -- 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
  若子类与基类不在同一包中，那么在子类中，子类实例可以访问其从基类继承而来的protected方法，而不能访问基类实例的protected方法。

package pkg4;

import pkg1.H;import pkg1.K;

public class Test {
  public static void main(String[] args) {
    F f = new F();
    G g = new G(); // 是F类的同包子类
    H h = new H(); // 是F类的不同包子类

    f.method();
    g.method(); // protected方法是包内可见的
    h.method(); // protected方法是对子类可见的

    K k = new K();
    k.method(); // 编译不通过：'method()' has protected access in 'pkg1.K'
  }}

// ---------------------------------------------------------------------package pkg4;

public class F { // 该类为外部类，访问权限不能为protected，否则编译不通过
  protected int field; // 该字段的访问权限为protected

  protected void method() {
    // 该方法的访问权限为protected
  }}

public class G extends F {} // 同包子类

// ---------------------------------------------------------------------package pkg1;

import pkg4.F;import pkg4.Test;

public class H extends F {} // 不同包子类

public class K extends Test {
  protected void method() {
    //...
  }
 }

• default -- 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

import pkg1.A;

public class Main {

  public static void main(String[] args) {
    A a = new A(); // 编译不通过：'pkg1.A' is not public in 'pkg1'. Cannot be accessed from outside package
  }}

// ---------------------------------------------------------------------

package pkg1;

class A implements B { // 该类的访问权限为default
  int field; // 该字段访问权限为default

  void method(int aInt) {
    // 该方法的访问权限为default
  }

  @Override
  public void method1() {
    System.out.println("method1 is implemented.");
  }}

interface B { // 该接口的访问权限为default
  void method1();}

class C {
  public void method3() {
    A a = new A();
    a.method(a.field); // 同包内可以访问权限为default的类、方法、字段
  }
}

• private -- 使用对象：变量、方法。 注意：不能修饰类（外部类）

import pkg3.C;

public class Main {
  
  public static void main(String[] args) {
    C c = new C();
    c.method(0); // 编译不通过：'method()' has private access in 'pkg3.C'
  }}

// ---------------------------------------------------------------------package pkg3;

public class C { // 该类为外部类，访问权限不能为private，否则编译不通过
  private int field; // 该字段的访问权限为private

  private class B {} // 该类为内部类，访问权限可以为private

  private void method() {
    // 该方法的访问权限为private
    System.out.println(this.field); // 类内部可以访问私有字段
  }}

package pkg3;

private interface E { // 编译不通过：Modifier 'private' not allowed here
    //...
}

总结

转自：https://www.jianshu.com/p/170eea83dc8b