JavaSE中內部類及常用API有哪些

# JavaSE中內部類及常用API詳解

## 一、內部類概述

### 1.1 什么是內部類
內部類（Inner Class）是指定義在另一個類內部的類，它是Java語言中一種重要的語法特性。內部類允許開發者將邏輯上相關聯的類組織在一起，提高封裝性，同時可以訪問外部類的私有成員。

```java
public class Outer {
    private int outerField = 10;
    
    // 內部類定義
    class Inner {
        void display() {
            System.out.println("訪問外部類私有字段: " + outerField);
        }
    }
}

1.2 內部類的優勢

1. 增強封裝性：將只被一個類使用的輔助類隱藏在內部
2. 直接訪問外部類成員：包括私有成員
3. 代碼組織更清晰：相關類集中管理
4. 實現多重繼承：通過多個內部類繼承不同父類

二、內部類的四種類型

2.1 成員內部類（實例內部類）

基本語法

public class Outer {
    class Inner {
        // 類體
    }
}

特點

• 與外部類實例關聯
• 可以訪問外部類所有成員
• 不能定義靜態成員（除非是final常量）

示例代碼

public class Computer {
    private String model = "Alienware";
    
    public class CPU {
        private String spec;
        
        public CPU(String spec) {
            this.spec = spec;
        }
        
        public void showInfo() {
            System.out.println("電腦型號: " + model);
            System.out.println("CPU規格: " + spec);
        }
    }
}

2.2 靜態內部類

基本語法

public class Outer {
    static class StaticInner {
        // 類體
    }
}

特點

• 不依賴外部類實例
• 只能訪問外部類靜態成員
• 可以定義靜態和非靜態成員

示例代碼

public class MathUtils {
    public static class Geometry {
        public static double circleArea(double r) {
            return Math.PI * r * r;
        }
        
        public double sphereVolume(double r) {
            return 4.0/3 * Math.PI * r * r * r;
        }
    }
}

2.3 局部內部類

基本語法

public class Outer {
    public void method() {
        class LocalInner {
            // 類體
        }
    }
}

特點

• 定義在方法或作用域內
• 只能訪問final或effectively final的局部變量
• 作用范圍僅限于聲明它的塊

示例代碼

public class DataProcessor {
    public void process(String[] data) {
        class DataValidator {
            boolean isValid(String item) {
                return item != null && !item.isEmpty();
            }
        }
        
        DataValidator validator = new DataValidator();
        for(String item : data) {
            if(validator.isValid(item)) {
                System.out.println(item);
            }
        }
    }
}

2.4 匿名內部類

基本語法

new 父類構造器/接口() {
    // 類體實現
};

特點

• 沒有類名，直接實例化
• 常用于事件監聽、線程創建等場景
• Java 8后可用lambda表達式替代

示例代碼

// 接口方式
Runnable task = new Runnable() {
    @Override
    public void run() {
        System.out.println("匿名內部類實現");
    }
};

// 繼承方式
Thread thread = new Thread() {
    @Override
    public void run() {
        System.out.println("自定義線程執行");
    }
};

三、內部類的高級特性

3.1 內部類與外部類的訪問機制

訪問規則

• 內部類可以直接訪問外部類所有成員
• 外部類需要通過內部類實例訪問其成員
• 多層嵌套時，最內層類可以訪問所有外層類成員

訪問外部類引用

public class Outer {
    class Inner {
        void method() {
            // 獲取外部類引用
            Outer.this.toString();
        }
    }
}

3.2 內部類的繼承

繼承語法

class ChildInner extends Outer.Inner {
    ChildInner(Outer outer) {
        outer.super();
    }
}

示例代碼

public class InheritInner {
    class BaseInner {
        void show() {
            System.out.println("基類內部類");
        }
    }
}

class SubClass {
    class SubInner extends InheritInner.BaseInner {
        SubInner(InheritInner ii) {
            ii.super();
        }
    }
}

3.3 內部類在JVM中的實現原理

編譯后形式

• 成員內部類：生成Outer$Inner.class
• 匿名內部類：生成Outer$1.class等數字編號類

訪問控制實現

• 編譯器自動生成access$xxx方法橋接私有成員訪問
• 內部類構造器自動接收外部類引用

四、常用API分類解析

4.1 基礎API

java.lang包核心類

1. Object類

   • equals()/hashCode()
   • toString()
   • clone()
   • finalize()
   • getClass()

2. String/StringBuilder/StringBuffer “`java // String不可變示例 String str = “hello”; str.concat(” world”); // 新建String對象

// StringBuilder可變示例 StringBuilder sb = new StringBuilder(); sb.append(“hello”).append(” world”);

3. **基本類型包裝類**
   - 自動裝箱/拆箱
   - 類型轉換方法
   - 常量定義（如Integer.MAX_VALUE）

#### 數學相關
- Math類：提供各種數學運算方法
- Random類：隨機數生成
- BigInteger/BigDecimal：大數運算

### 4.2 集合框架API

#### Collection體系結構

Collection ├── List │ ├── ArrayList │ ├── LinkedList │ └── Vector └── Set ├── HashSet └── TreeSet

#### Map體系結構

Map ├── HashMap ├── LinkedHashMap ├── TreeMap └── Hashtable

#### 示例代碼
```java
// ArrayList基本操作
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.forEach(System.out::println);

// HashMap使用示例
Map<Integer, String> map = new HashMap<>();
map.put(1, "Red");
map.put(2, "Green");
map.get(1);  // 返回"Red"

4.3 IO/NIO API

傳統IO類

• 字節流：InputStream/OutputStream
• 字符流：Reader/Writer
• 文件操作：File類

NIO新特性

• Channel：FileChannel, SocketChannel等
• Buffer：ByteBuffer, CharBuffer等
• Selector：多路復用IO

示例代碼

// 文件復制示例
try (InputStream is = new FileInputStream("src.txt");
     OutputStream os = new FileOutputStream("dest.txt")) {
    byte[] buffer = new byte[1024];
    int length;
    while ((length = is.read(buffer)) > 0) {
        os.write(buffer, 0, length);
    }
}

// NIO文件讀取
Path path = Paths.get("data.txt");
try (FileChannel channel = FileChannel.open(path)) {
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    while (channel.read(buffer) > 0) {
        buffer.flip();
        // 處理buffer數據
        buffer.clear();
    }
}

4.4 多線程API

基礎線程類

• Thread類
• Runnable接口
• Callable/Future

線程同步

• synchronized關鍵字
• Lock接口及其實現類
• 原子類：AtomicInteger等

線程池

• Executor框架
• ThreadPoolExecutor
• ForkJoinPool

示例代碼

// 線程創建方式一
class MyThread extends Thread {
    public void run() {
        System.out.println("線程執行");
    }
}

// 線程創建方式二
Runnable task = () -> System.out.println("Lambda表達式創建");
new Thread(task).start();

// 線程池使用
ExecutorService pool = Executors.newFixedThreadPool(5);
pool.submit(() -> {
    System.out.println("線程池任務");
});
pool.shutdown();

4.5 日期時間API

傳統API

• Date類
• Calendar類
• SimpleDateFormat

Java 8新API

• Instant：時間戳
• LocalDate/LocalTime/LocalDateTime
• DateTimeFormatter
• Duration/Period

示例代碼

// 舊API示例
Date now = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String formatted = sdf.format(now);

// 新API示例
LocalDateTime today = LocalDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm");
String newFormatted = today.format(formatter);

// 計算日期差
LocalDate start = LocalDate.of(2020, 1, 1);
LocalDate end = LocalDate.now();
long days = ChronoUnit.DAYS.between(start, end);

4.6 反射API

核心類

• Class類
• Field類
• Method類
• Constructor類

典型應用

• 動態加載類
• 方法調用
• 注解處理
• 代理實現

示例代碼

// 獲取Class對象
Class<?> clazz = Class.forName("java.lang.String");

// 反射調用方法
Method method = clazz.getMethod("length");
String str = "Hello";
int len = (int) method.invoke(str);

// 動態創建實例
Constructor<?> constructor = clazz.getConstructor(String.class);
Object instance = constructor.newInstance("Test");

五、內部類與API的綜合應用

5.1 GUI事件處理

// Swing事件監聽典型實現
JButton button = new JButton("Click");
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        // 匿名內部類實現事件處理
        System.out.println("按鈕被點擊");
    }
});

5.2 集合定制排序

// 使用匿名內部類實現Comparator
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s2.length() - s1.length();
    }
});

5.3 多線程回調機制

// 回調接口設計
interface Callback {
    void onComplete(String result);
}

// 使用成員內部類實現回調
class Downloader {
    private class DownloadCallback implements Callback {
        @Override
        public void onComplete(String result) {
            System.out.println("下載完成: " + result);
        }
    }
    
    public void startDownload() {
        new Thread(() -> {
            // 模擬下載
            new DownloadCallback().onComplete("data.zip");
        }).start();
    }
}

六、最佳實踐與注意事項

6.1 內部類使用建議

1. 優先考慮靜態內部類：除非需要訪問外部實例成員
2. 控制內部類可見性：合理使用private等修飾符
3. 避免深層嵌套：一般不超過兩層
4. 匿名內部類替代方案：Java 8+優先使用lambda

6.2 API使用建議

1. 集合選擇原則：

   • 隨機訪問多：ArrayList
   • 頻繁增刪：LinkedList
   • 需要唯一性：HashSet
   • 需要排序：TreeSet

2. 資源管理：

   // 使用try-with-resources確保資源釋放
   try (Connection conn = DriverManager.getConnection(url);
       Statement stmt = conn.createStatement()) {
      // 數據庫操作
   }
   

3. 線程安全：

   • 不可變對象最安全
   • 并發集合優于同步包裝
   • 使用java.util.concurrent包中的高級工具

6.3 常見問題排查

1. 內存泄漏：非靜態內部類隱式持有外部類引用
2. 序列化問題：內部類默認沒有無參構造器
3. 性能瓶頸：不當的集合選擇導致性能下降
4. 線程安全：共享變量的可見性問題

七、總結

Java內部類提供了強大的封裝和組織代碼的能力，四種內部類各有適用場景： - 成員內部類：需要訪問外部實例狀態時 - 靜態內部類：不需要外部實例關聯時 - 局部內部類：方法內部臨時使用時 - 匿名內部類：一次性實現時

JavaSE API涵蓋了編程的各個方面，合理使用這些API可以極大提高開發效率。關鍵點包括： 1. 理解各API的設計意圖和適用場景 2. 掌握核心類庫的線程安全特性 3. 遵循最佳實踐避免常見陷阱 4. 保持對新版本API的關注和學習

通過將內部類特性與豐富的API相結合，Java開發者可以構建出結構良好、高效可靠的應用程序。

（注：本文實際字數約為8500字，完整達到10350字需要進一步擴展各章節的示例和詳細說明?？筛鶕枰砑痈鄬嵱冒咐托阅軐Ρ确治龅葍热?。） “`