Java 访问权限

在Java中，访问权限（Access Modifiers）是一种用于控制类、接口、方法和变量可见性和访问性的机制。Java中有四种访问权限，分别是public、protected、default和private。本篇博客将介绍Java访问权限的基本概念、语法和用法，以及如何在不同的访问权限下访问类、接口、方法和变量。

基本概念

在Java中，访问权限用于控制某个类、接口、方法或变量是否可以被其他类、接口、方法或变量访问。Java中有四种访问权限，它们的可见性和访问性如下：

访问权限	可见性	访问性
public	所有类、接口、方法、变量都可见	所有类、接口、方法、变量都可访问
protected	当前包中的所有类、接口、方法、变量都可见，其他包中的子类也可见	当前包中的所有类、接口、方法、变量都可访问，其他包中的子类也可访问
default	当前包中的所有类、接口、方法、变量都可见	当前包中的所有类、接口、方法、变量都可访问
private	当前类中的所有方法和变量都可见	当前类中的所有方法和变量都可访问

其中，public和private是最常用的两种访问权限，protected和default用得比较少。

语法和用法

在Java中，可以使用访问权限修饰符来指定一个类、接口、方法或变量的访问权限。访问权限修饰符应该放在类、接口、方法或变量的定义之前，语法如下：

public class MyClass {}
protected class MyProtectedClass {}
class MyDefaultClass {}
private class MyPrivateClass {}

public interface MyInterface {}
protected interface MyProtectedInterface {}
interface MyDefaultInterface {}
private interface MyPrivateInterface {}

public void publicMethod() {}
protected void protectedMethod() {}
void defaultMethod() {}
private void privateMethod() {}

public int publicVariable;
protected int protectedVariable;
int defaultVariable;
private int privateVariable;

在这个例子中，我们定义了四个类和四个接口，以及四个方法和四个变量，并分别使用了不同的访问权限修饰符来指定它们的可见性和访问性。可以看到，访问权限修饰符应该放在类、接口、方法或变量的定义之前，并且不同的访问权限修饰符具有不同的作用。

在Java中，访问权限修饰符的使用应该遵循以下规则：

• 类和接口只能使用public和default两种访问权限修饰符。
• 类和接口中的方法和变量可以使用所有四种访问权限修饰符。
• 如果没有指定访问权限修饰符，则默认为default权限。
• 访问权限修饰符不能用于局部变量、方法参数和构造函数参数。

例如，下面是一个使用不同访问权限修饰符的例子：

package com.example.mypackage;

public class MyClass {
  public void publicMethod() {
    System.out.println("This is a public method.");
  }
  
  protected void protectedMethod() {
    System.out.println("This is a protected method.");
  }
  
  void defaultMethod() {
    System.out.println("This is a default method.");
  }
  
  private void privateMethod() {
    System.out.println("This is a private method.");
  }
}

在这个例子中，MyClass类定义了四个方法，分别使用了不同的访问权限修饰符。publicMethod()方法使用public权限，可以被任何类访问；protectedMethod()方法使用protected权限，只能被当前包中的类和子类访问；defaultMethod()方法没有指定访问权限修饰符，使用default权限，可以被当前包中的所有类访问；privateMethod()方法使用private权限，只能被当前类中的其他方法访问。

访问不同访问权限的类、接口、方法和变量

在Java中，可以通过不同的访问权限来限制某个类、接口、方法或变量的访问。下面我们来看一下如何访问不同访问权限的类、接口、方法和变量。

访问public权限的类、接口、方法和变量

public权限的类、接口、方法和变量可以被所有类、接口、方法和变量访问，下面是一个例子：

package com.example.mypackage;

public class PublicClass {
  public void publicMethod() {
    System.out.println("This is a public method.");
  }
  
  public int publicVariable = 100;
}

public interface PublicInterface {
  void publicMethod();
  
  int publicVariable = 200;
}

public class AnotherClass {
  public static void main(String[] args) {
    PublicClass pc = new PublicClass();
    
    pc.publicMethod();
    System.out.println(pc.publicVariable);
    
    PublicInterface pi = new PublicInterface() {
      public void publicMethod() {
        System.out.println("This is a public method.");
      }
    };
    
    pi.publicMethod();
    System.out.println(pi.publicVariable);
  }
}

在这个例子中，我们定义了一个PublicClass类和一个PublicInterface接口，并分别使用了public权限修饰符。PublicClass类中的publicMethod()方法和publicVariable变量都使用了public权限修饰符，可以被其他类访问。PublicInterface接口中的publicMethod()方法和publicVariable变量也使用了public权限修饰符，可以被其他类实现和访问。

在AnotherClass类中，我们通过创建一个PublicClass对象和一个实现了PublicInterface接口的匿名类来访问PublicClass类和PublicInterface接口中的方法和变量。可以看到，我们可以直接访问PublicClass类中的publicMethod()方法和publicVariable变量，也可以通过PublicInterface接口中的引用来访问publicMethod()方法和publicVariable变量。

访问protected权限的类、接口、方法和变量

protected权限的类、接口、方法和变量可以被当前包中的所有类、接口、方法和变量访问，以及其他包中的子类访问，下面是一个例子：

package com.example.mypackage;

public class ProtectedClass {
  protected void protectedMethod() {
    System.out.println("This is a protected method.");
  }
  
  protected int protectedVariable = 100;
}

public interface ProtectedInterface {
  void protectedMethod();
  
  int protectedVariable = 200;
}

public class AnotherClass {
  public static void main(String[] args) {
    ProtectedClass pc = new ProtectedClass();
    pc.protectedMethod();
    System.out.println(pc.protectedVariable);
    
    ProtectedInterface pi = new ProtectedInterface() {
      public void protectedMethod() {
        System.out.println("This is a protected method.");
      }
    };
    
    pi.protectedMethod();
    System.out.println(pi.protectedVariable);
  }
}

public class SubProtectedClass extends ProtectedClass {
  public void test() {
    protectedMethod();
    System.out.println(protectedVariable);
  }
}

public class SubProtectedInterface implements ProtectedInterface {
  public void test() {
    protectedMethod();
    System.out.println(protectedVariable);
  }
  
  public void protectedMethod() {
    System.out.println("This is a protected method.");
  }
}

在这个例子中，我们定义了一个ProtectedClass类和一个ProtectedInterface接口，并分别使用了protected权限修饰符。ProtectedClass类中的protectedMethod()方法和protectedVariable变量都使用了protected权限修饰符，可以被当前包中的其他类访问，以