# Java 嵌套和內部類 > 原文： [https://www.programiz.com/java-programming/nested-inner-class](https://www.programiz.com/java-programming/nested-inner-class) #### 在本教程中，您將借助示例學習 Java 中的嵌套類及其類型。 在 Java 中，您可以在另一個類中定義一個類。 這種類稱為`nested class`。 例如， ```java class OuterClass { // ... class NestedClass { // ... } } ``` 您可以使用 Java 創建兩種類型的嵌套類。 * 非靜態嵌套類（內部類） * 靜態嵌套類 **推薦閱讀**： * [Java 訪問修飾符](/java-programming/access-modifiers "Java Access Modifiers") * [Java `static`關鍵字](/java-programming/static-keyword "Java Static Keyword") 首先讓我們看一下非靜態嵌套類。 * * * ## 非靜態嵌套類（內部類） 非靜態嵌套類是另一個類中的一個類。 它有權訪問封閉類（外部類）的成員。 通常稱為`inner class`。 由于`inner class`存在于外部類中，因此您必須首先實例化外部類，以便實例化內部類。 這是一個如何在 Java 中聲明內部類的示例。 ### 示例 1：內部類 ```java class CPU { double price; // nested class class Processor{ // members of nested class double cores; String manufacturer; double getCache(){ return 4.3; } } // nested protected class protected class RAM{ // members of protected nested class double memory; String manufacturer; double getClockSpeed(){ return 5.5; } } } public class Main { public static void main(String[] args) { // create object of Outer class CPU CPU cpu = new CPU(); // create an object of inner class Processor using outer class CPU.Processor processor = cpu.new Processor(); // create an object of inner class RAM using outer class CPU CPU.RAM ram = cpu.new RAM(); System.out.println("Processor Cache = " + processor.getCache()); System.out.println("Ram Clock speed = " + ram.getClockSpeed()); } } ``` **輸出**： ```java Processor Cache = 4.3 Ram Clock speed = 5.5 ``` 在上面的程序中，有兩個嵌套類：`CPU`和`RAM`位于外部類內部：`CPU`。 我們可以將內部類聲明為受保護的。 因此，我們已將 RAM 類聲明為受保護的。 在`Main`類里面 * 我們首先創建了一個名為`cpu`的外部類`CPU`的實例。 * 然后使用外部類的實例創建內部類的對象： ```java CPU.Processor processor = cpu.new Processor; CPU.RAM ram = cpu.new RAM(); ``` **注意**：我們使用點（`.`）運算符使用外部類創建內部類的實例。 * * * ### 訪問內部類中的外部類成員 通過使用`this`關鍵字，我們可以訪問外部類的成員。 如果您想了解`this`關鍵字，請訪問 [Java `this`關鍵字](https://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html)。 ### 示例 2：訪問成員 ```java class Car { String carName; String carType; // assign values using constructor public Car(String name, String type) { this.carName = name; this.carType = type; } // private method private String getCarName() { return this.carName; } // inner class class Engine { String engineType; void setEngine() { // Accessing the carType property of Car if(Car.this.carType.equals("4WD")){ // Invoking method getCarName() of Car if(Car.this.getCarName().equals("Crysler")) { this.engineType = "Smaller"; } else { this.engineType = "Bigger"; } }else{ this.engineType = "Bigger"; } } String getEngineType(){ return this.engineType; } } } public class Main { public static void main(String[] args) { // create an object of the outer class Car Car car1 = new Car("Mazda", "8WD"); // create an object of inner class using the outer class Car.Engine engine = car1.new Engine(); engine.setEngine(); System.out.println("Engine Type for 8WD= " + engine.getEngineType()); Car car2 = new Car("Crysler", "4WD"); Car.Engine c2engine = car2.new Engine(); c2engine.setEngine(); System.out.println("Engine Type for 4WD = " + c2engine.getEngineType()); } } ``` **輸出**： ```java Engine Type for 8WD= Bigger Engine Type for 4WD = Smaller ``` 在上面的程序中，我們在外部類`Car`內有一個名為`Engine`的內部類。 在這里，請注意這行， ```java if(Car.this.carType.equals("4WD")) {...} ``` 我們正在使用`this`關鍵字來訪問外部類的`carType`變量。 您可能已經注意到，我們使用`Car.this.carType`代替了`this.carType`。 這是因為，如果我們沒有提到外部類`Car`的名稱，那么`this`關鍵字將代表內部類內部的成員。 同樣，我們也從內部類訪問外部類的方法。 ```java if (Car.this.getCarName().equals("Crysler") {...} ``` 重要的是要注意，盡管`getCarName()`是`private`方法，但我們仍可以從內部類訪問它。 * * * ## 靜態嵌套類 在 Java 中，我們還可以在另一個類中定義一個`static`類。 此類稱為`static nested class`。 靜態嵌套類不稱為靜態內部類。 與內部類不同，靜態嵌套類無法訪問外部類的成員變量。 這是因為**靜態嵌套類**不需要您創建外部類的實例。 ```java OuterClass.NestedClass obj = new OuterClass.NestedClass(); ``` 在這里，我們僅通過使用外部類的類名來創建**靜態嵌套類**的對象。 因此，無法使用`OuterClass.this`引用外部類。 ### 示例 3：靜態內部類 ```java class MotherBoard { // static nested class static class USB{ int usb2 = 2; int usb3 = 1; int getTotalPorts(){ return usb2 + usb3; } } } public class Main { public static void main(String[] args) { // create an object of the static nested class // using the name of the outer class MotherBoard.USB usb = new MotherBoard.USB(); System.out.println("Total Ports = " + usb.getTotalPorts()); } } ``` **輸出**： ```java Total Ports = 3 ``` 在上面的程序中，我們在類`MotherBoard`中創建了一個名為`USB`的靜態類。 注意這一行， ```java MotherBoard.USB usb = new MotherBoard.USB(); ``` 在這里，我們使用外部類的名稱創建`USB`的對象。 現在，讓我們看看如果嘗試訪問外部類的成員會發生什么： * * * ### 示例 4：在靜態內部類內部訪問外部類的成員 ```java class MotherBoard { String model; public MotherBoard(String model) { this.model = model; } // static nested class static class USB{ int usb2 = 2; int usb3 = 1; int getTotalPorts(){ // accessing the variable model of the outer classs if(MotherBoard.this.model.equals("MSI")) { return 4; } else { return usb2 + usb3; } } } } public class Main { public static void main(String[] args) { // create an object of the static nested class MotherBoard.USB usb = new MotherBoard.USB(); System.out.println("Total Ports = " + usb.getTotalPorts()); } } ``` 當我們嘗試運行該程序時，將出現錯誤： ```java error: non-static variable this cannot be referenced from a static context ``` 這是因為我們沒有使用外部類的對象來創建內部類的對象。 因此，沒有引用存儲在`Motherboard.this`中的外部類`Motherboard`。 * * * ### 要記住的要點 * Java 將內部類視為類的常規成員。 它們就像在類中聲明的方法和變量一樣。 * 由于內部類是外部類的成員，因此您可以將`private`，`protected`之類的任何訪問修飾符應用于內部類，這在普通類中是不可能的。 * 由于嵌套類是其封閉的外部類的成員，因此可以使用點（`.`）表示法來訪問嵌套類及其成員。 * 使用嵌套的類將使您的代碼更具可讀性，并提供更好的封裝。 * 非靜態嵌套類（內部類）可以訪問外部/封閉類的其他成員，即使它們被聲明為私有的也是如此。