Java 访问权限

素颜马尾好姑娘i 2023-10-13 14:28 8阅读 0赞

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

### 基本概念 ###

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

<table> 
 <thead> 
  <tr> 
   <th>访问权限</th> 
   <th>可见性</th> 
   <th>访问性</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public</td> 
   <td>所有类、接口、方法、变量都可见</td> 
   <td>所有类、接口、方法、变量都可访问</td> 
  </tr> 
  <tr> 
   <td>protected</td> 
   <td>当前包中的所有类、接口、方法、变量都可见，其他包中的子类也可见</td> 
   <td>当前包中的所有类、接口、方法、变量都可访问，其他包中的子类也可访问</td> 
  </tr> 
  <tr> 
   <td>default</td> 
   <td>当前包中的所有类、接口、方法、变量都可见</td> 
   <td>当前包中的所有类、接口、方法、变量都可访问</td> 
  </tr> 
  <tr> 
   <td>private</td> 
   <td>当前类中的所有方法和变量都可见</td> 
   <td>当前类中的所有方法和变量都可访问</td> 
  </tr> 
 </tbody> 
</table>

其中，`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`权限修饰符，可以被当前包中的其他类访问，以