# Java 静态嵌套类

> 原文： [https://www.programiz.com/java-programming/static-class](https://www.programiz.com/java-programming/static-class)

#### 在本教程中，您将借助示例学习嵌套的静态类。 您还将了解静态类与内部类之间的区别。

如之前的教程所述，我们可以在 Java 的另一个类中包含一个类。 这样的类称为嵌套类。 在 Java 中，嵌套类有两种类型：

*   嵌套的非静态类（内部类）
*   嵌套的静态类。

在上一教程中，我们已经讨论了内部类。 如果您想了解内部类，请访问 [Java 嵌套类](https://www.programiz.com/java-programming/nested-inner-class)。

在本教程中，我们将学习静态嵌套类。

* * *

## Java 静态嵌套类

我们使用关键字`static`使我们的嵌套类静态化。

**注意**：在 Java 中，仅允许嵌套类为静态。

与常规类一样，静态嵌套类可以包含静态和非静态字段和方法。 例如，

```java
Class Animal {
   static class Mammal {
      // static and non-static members of Mammal
   }
   // members of Animal
} 
```

静态嵌套类与外部类相关联。

要访问静态嵌套类，我们不需要外部类的对象。

* * *

### 示例：静态嵌套类

```java
class Animal {

// inner class
   class Reptile {
      public void displayInfo() {
        System.out.println("I am a reptile.");
      }
   }

// static class
   static class Mammal {
      public void displayInfo() {
        System.out.println("I am a mammal.");
      }
   }
}

class Main {
   public static void main(String[] args) {
      // object creation of the outer class
      Animal animal = new Animal();

      // object creation of the non-static class
      Animal.Reptile reptile = animal.new Reptile();
      reptile.displayInfo();

      // object creation of the static nested class
      Animal.Mammal mammal = new Animal.Mammal();
      mammal.displayInfo();

   }
} 
```

**输出**

```java
I am a reptile.
I am a mammal. 
```

在上面的程序中，我们在类`Animal`中有两个嵌套类`Mammal`和`Reptile`。

为了创建非静态类`Reptile`的对象，我们使用了

```java
Animal.Reptile reptile = animal.new Reptile() 
```

要创建静态类`Mammal`的对象，我们使用了

```java
Animal.Mammal mammal = new Animal.Mammal() 
```

* * *

## 访问外层成员

在 Java 中，静态嵌套类与外部类相关联。 这就是为什么静态嵌套类只能访问外部类的类成员（静态字段和方法）的原因。

让我们看看如果尝试访问外部类的非静态字段和方法会发生什么。

### 示例：访问非静态成员

```java
class Animal {
  static class Mammal {
   public void displayInfo() {
     System.out.println("I am a mammal.");
   }
 }

 class Reptile {
   public void displayInfo() {
     System.out.println("I am a reptile.");
   }
 }

 public void eat() {
   System.out.println("I eat food.");
 }
}

class Main {
 public static void main(String[] args) {
   Animal animal = new Animal();
   Animal.Reptile reptile = animal.new Reptile();
   reptile.displayInfo();

   Animal.Mammal mammal = new Animal.Mammal();
   mammal.displayInfo();
   mammal.eat();
 }
} 
```

**输出**：

```java
Main.java:28: error: cannot find symbol
    mammal.eat();
          ^
  symbol:   method eat()
  location: variable mammal of type Mammal
1 error
compiler exit status 1 
```

在上面的示例中，我们在类`Animal`中创建了一个非静态方法`eat()`。

现在，如果我们尝试使用对象`Mammal`访问`eat()`，则编译器将显示错误。

这是因为`Mammal`是静态类的对象，我们无法从静态类访问非静态方法。

* * *

## 静态顶级类

如上所述，只有嵌套类可以是静态的。 我们不能有静态的顶级类。

让我们看看如果尝试使顶级类静态化会发生什么。

```java
static class Animal {
 public static void displayInfo() {
   System.out.println("I am an animal");
 }
}

class Main {
 public static void main(String[] args) {
   Animal.displayInfo();
 }
} 
```

**输出**：

```java
Main.java:1: error: modifier static not allowed here
static class Animal {
       ^
1 error
compiler exit status 1 
```

在上面的示例中，我们尝试创建一个静态类`Animal`。 由于 Java 不允许使用静态顶级类，因此会出现错误。