Java 面试八股文2023：基础知识概述

# 1. Java 的发展历程

Java 的发展历程主要可以分为两个方面： Java 的起源与发展，JDK、JRE、JVM 的概念及区别。接下来我们将对这两方面进行详细的介绍。

## 1.1 Java 的起源与发展

Java 是由Sun Microsystems公司的工程师James Gosling等人于上世纪90年代初开发的一种高级程序设计语言。下表列出了Java的一些重要里程碑与发展历程：

| 年份 | 事件 |
|--------|------------------------|
| 1995年 | Java 1.0发布，正式推出 |
| 1998年 | Java 2发布，引入了新特性 |
| 2006年 | Java 5发布，引入了泛型与注解等特性 |
| 2014年 | Java 8发布，引入了Lambda表达式与Stream API |
| 2017年 | Java 9发布，引入了模块化系统 |
| 2020年 | 当前最新版本为Java 15 |

Java 在其发展过程中不断引入新的特性与技术，逐渐成为了一门灵活、安全且跨平台的编程语言。

## 1.2 JDK、JRE、JVM 的概念及区别

JDK（Java Development Kit）是Java开发工具包，包含了Java的基本工具（编译器、调试器等）和Java的运行环境。JRE（Java Runtime Environment）是Java运行环境，用于支持Java程序的运行。JVM（Java Virtual Machine）是Java虚拟机，是Java程序的运行环境。

下面是它们之间的区别：

- JDK是Java开发工具包，包含了JRE和开发工具。
- JRE是Java运行环境，用于支持Java程序的运行，包含了JVM和Java类库。
- JVM是Java虚拟机，负责将Java字节码转换为机器码并执行。每个Java应用程序在JVM上运行。

JDK、JRE、JVM三者之间的关系可以用下图来表示：

graph TD
    A[JDK] --> B[JRE]
    B[JRE] --> C[JVM]

# 2. **Java 语言基础**

在 Java 编程语言中，掌握基本的数据类型和变量声明是至关重要的。此外，对于字符串的操作也是常见的需求。下面将详细介绍 Java 语言基础知识。

1. **数据类型与变量**
- Java 提供了八种基本数据类型，分为三类：整数型、浮点型和字符型。
| 数据类型 | 关键字 | 占用字节 | 范围 |
|-------------|------------|-------------|---------------------------------|
| byte | byte | 1 | -128 到 127 |
| short | short | 2 | -32768 到 32767 |
| int | int | 4 | -2147483648 到 2147483647 |
| long | long | 8 | -9223372036854775808 到 9223372036854775807 |
| float | float | 4 | 约 ±3.40282347E+38F （有效位数为6-7位） |
| double | double | 8 | 约 ±1.7976931348623157E+308 （有效位数为15位） |
| char | char | 2 | Unicode字符集中的单个字符 |
| boolean | boolean | 1/8 | true/false |

    // Java变量声明与赋值示例
    int num = 10;
    double pi = 3.1415;
    char letter = 'A';
    boolean isTrue = true;

- Java 还支持引用数据类型，如类、接口和数组等。

2. **字符串操作与常用方法**
- Java 中 String 类是不可变的，提供了丰富的字符串操作方法。

    // 字符串操作示例
    String str1 = "Hello";
    String str2 = "World";
    // 字符串拼接
    String result = str1 + " " + str2;
    // 字符串长度
    int length = result.length();
    // 字符串比较
    boolean isEqual = str1.equals(str2);
    // 字符串查找
    int index = result.indexOf("World");

- 常用的字符串处理方法包括：`concat()`, `toLowerCase()`, `toUpperCase()`, `trim()`, `substring()`, `replace()`, `split()` 等。

以上是 Java 语言基础的简要概述，深入理解这些概念和方法将有助于在面试中展现自己的编程能力。

# 3. **面向对象编程**

面向对象编程（Object-Oriented Programming，简称 OOP）是一种程序设计范式，通过对象的使用、封装、继承和多态等概念，帮助我们更好地组织和管理代码。

#### 3.1 类与对象的概念

在 Java 中，类（Class）是对象的模板，对象（Object）是类的实例化。类定义了对象的属性和行为，对象则代表了现实世界中的事物，并具有对应的状态和行为。

下面是一个简单的 Java 类的示例：

public class Car {
    String color;
    int maxSpeed;
    public void displayInfo() {
        System.out.println("这辆车的颜色是：" + color);
        System.out.println("这辆车的最高时速是：" + maxSpeed + "km/h");
    }
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.color = "红色";
        myCar.maxSpeed = 200;
        myCar.displayInfo();
    }
}

在上面的代码中，我们定义了一个 `Car` 类，包含颜色和最高时速两个属性，并提供了显示信息的方法 `displayInfo`。在 `main` 方法中，我们实例化了一个 `Car` 对象，并设置了颜色和最高时速，然后调用 `displayInfo` 方法输出信息。

#### 3.2 封装、继承、多态的实现方式

- **封装**：将数据和行为封装在对象内部，通过控制访问权限来保护数据，提高代码的安全性和可维护性。

| 修饰符 | 含义 |
| ------ | ------------------------ |
| private | 仅在本类中可访问 |
| default | 同一包内可访问 |
| protected | 同一包内及继承类中可访问 |
| public | 所有类可访问 |

- **继承**：子类继承父类的属性和方法，可以通过 `extends` 关键字实现。

class Animal {
    void eat() {
        System.out.println("动物会吃东西");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("狗会汪汪叫");
    }
}

- **多态**：同一操作作用于不同的对象，可以有不同的解释和不同的实现。通过方法的重载（Overload）和重写（Override）实现。

class Cat extends Animal {
    void eat() {
        System.out.println("猫在吃鱼");
    }

    void mew() {
        System.out.println("猫会喵喵叫");
    }
}

Animal a = new Cat();
a.eat();  // 输出：猫在吃鱼

通过封装、继承和多态，我们能够更好地组织和设计 Java 程序，提高代码的可读性和可维护性。

# 4. **Java 集合框架**

Java 的集合框架提供了一组用于存储和操作数据的类和接口。在本章节，我们将深入探讨集合框架的体系结构和常用类的使用方法。

#### 4.1 集合框架的体系结构

Java 集合框架包括 Collection 和 Map 两个顶层接口，它们下面分别有不同的实现类。以下是 Java 集合框架的体系结构：

- **Collection 接口**：存储一组对象的集合，包括 List、Set 和 Queue 接口。
- List 接口：有序的集合，可以有重复元素。常见实现类有 ArrayList、LinkedList。
- Set 接口：不允许重复元素的集合。常见实现类有 HashSet、LinkedHashSet。
- Queue 接口：队列，通常用于存储和操作元素的顺序。
- **Map 接口**：存储键值对的集合，每个键都与一个值相关联。常见实现类有 HashMap、LinkedHashMap。

#### 4.2 ArrayList、LinkedList、HashMap 的用法与区别

在 Java 中，ArrayList 和 LinkedList 是两种常用的 List 集合类，而 HashMap 则是常用的键值对 Map 集合类。下面我们将分别介绍它们的用法和区别。

1. **ArrayList**
- ArrayList 是基于动态数组实现的，支持随机访问元素。
- 示例代码：

    ArrayList<String> list = new ArrayList<>();
    list.add("Apple");
    list.add("Banana");
    System.out.println(list.get(0)); // 输出 "Apple"

- 总结：适合查找和随机访问，但在插入和删除操作时效率较低。
2. **LinkedList**
- LinkedList 是基于双向链表实现的，支持快速插入和删除操作。
- 示例代码：

    LinkedList<String> list = new LinkedList<>();
    list.add("Apple");
    list.add("Banana");
    list.remove(0);

- 总结：适合插入和删除操作频繁的场景，但访问元素时效率较低。
3. **HashMap**
- HashMap 使用键值对存储数据，通过键快速定位到值。
- 示例代码：

    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "One");
    map.put(2, "Two");
    System.out.println(map.get(1)); // 输出 "One"

- 总结：适合需要通过键值快速查找数据的场景，但不保证顺序。

#### 集合框架体系结构及以上三种集合类的用法和区别内容，可以通过下方流程图进行更直观的理解。

graph TD
    A[Collection] -->|子接口| B(List)
    A -->|子接口| C(Set)
    A -->|子接口| D(Queue)
    B --> E(ArrayList)
    B --> F(LinkedList)
    C --> G(HashSet)
    C --> H(LinkedHashSet)
    D --> I(HashMap)
    D --> J(LinkedHashMap)

# 5. **异常处理**

在 Java 中，异常处理是非常重要的一部分，能够帮助我们更好地处理程序在运行过程中可能遇到的问题。下面将介绍 Java 异常处理的相关内容：

1. **异常分类与如何捕获异常**
| 异常类型 | 描述 |
|----------------|--------------------------------------------------------------|
| 受检查异常 | 编译器要求必须进行处理的异常，如 IOException、SQLException |
| 运行时异常 | 由 Java 虚拟机抛出的异常，如 NullPointerException、ArrayIndexOutOfBoundsException |
| 错误 | 严重问题，应用程序通常不会捕获并处理，如 OutOfMemoryError |

   public class ExceptionHandlingExample {
       public static void main(String[] args) {
           try {
               int[] arr = new int[3];
               System.out.println(arr[5]);
           } catch (ArrayIndexOutOfBoundsException e) {
               System.out.println("数组下标越界异常：" + e.getMessage());
           }
       }
   }

- 通过 try-catch 块捕获异常，并在捕获到异常时进行相应的处理。
2. **自定义异常与异常链**

- 自定义异常类可以帮助我们更好地区分不同的异常情况，增强程序的可读性和可维护性。

   // 自定义异常类
   class CustomException extends Exception {
       public CustomException(String message) {
           super(message);
       }
   }

   public class CustomExceptionExample {
       public static void main(String[] args) {
           try {
               throw new CustomException("自定义异常测试");
           } catch (CustomException e) {
               System.out.println("捕获自定义异常：" + e.getMessage());
           }
       }
   }

- 在捕获自定义异常时，可以根据不同的异常情况进行相应的处理，提高代码的灵活性。

### 流程图

graph TD
    A[开始] --> B{条件判断}
    B -- 条件1 --> C[处理异常1]
    B -- 条件2 --> D[处理异常2]
    C --> E[结束]
    D --> E
    B --> F[正常流程]
    F --> G[结束]

通过以上内容，我们可以更深入地了解 Java 异常处理的相关知识，包括不同类型的异常、如何捕获异常以及自定义异常的应用场景。在实际开发中，合理处理异常能够提高程序的健壮性和可靠性。

# 6. **多线程编程**

在Java中，多线程编程是非常重要的一部分，能够有效地提升程序的性能和并发处理能力。下面将详细介绍多线程编程的相关内容：

1. **线程的创建与调度**
- 通过继承Thread类创建线程，或者实现Runnable接口。
- 使用线程池Executor来管理线程的创建和调度。
- 通过调用 start() 方法启动线程，并通过 run() 方法执行线程任务。

2. **线程安全、死锁、线程池的概念与应用**
- **线程安全**：在多线程环境下，保证共享资源不会发生冲突，可以使用同步机制（synchronized、Lock）来实现线程安全。
- **死锁**：多个线程相互等待对方释放资源而无法继续执行的情况，可以通过合理的资源申请顺序避免死锁。
- **线程池**：通过线程池可以有效地管理和重用线程，提高程序性能。常见的线程池有ThreadPoolExecutor和ScheduledThreadPoolExecutor。

下面是一个使用线程池的示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            Runnable task = new MyTask(i);
            executor.execute(task);
        }

        executor.shutdown();
    }

    static class MyTask implements Runnable {
        private int taskId;

        public MyTask(int taskId) {
            this.taskId = taskId;
        }

        @Override
        public void run() {
            System.out.println("Task " + taskId + " is running.");
        }
    }
}

上述代码中，我们创建了一个固定大小为5的线程池，并提交了10个任务给线程池执行。每个任务都会输出自己的任务ID。

### 线程池示例流程图

graph LR
    A(开始) --> B(创建固定大小线程池)
    B --> C(提交任务给线程池)
    C --> D{是否有空闲线程}
    D -- 有 --> E(执行任务)
    E --> C
    D -- 无 --> F(等待)
    F --> D
    C -- 执行完成 --> G(关闭线程池)
    G --> H(结束)

# 7. **Java IO 与 NIO**

Java中的IO操作是非常常见且重要的一部分，而NIO则是在Java 1.4版本中引入的新IO库，提供了更高效的IO操作方式。下面我们将深入探讨Java IO与NIO的相关知识。

1. **字节流与字符流**

在Java中，IO流分为字节流和字符流两种类型，字节流用于处理二进制数据，而字符流用于处理文本数据。

2. **NIO 的特点与非阻塞IO的实现**

NIO（New Input/Output）是Java 1.4版中引入的一种新的IO模型，具有非阻塞IO操作的特性，并提供了以下几个关键组件：

- **通道（Channel）**：用于读取和写入数据的双向通道。
- **缓冲区（Buffer）**：在通道与数据源之间传输数据的缓冲区。
- **选择器（Selector）**：用于监听多个通道的事件，实现单线程处理多个通道。

下面我们通过一个示例来演示NIO中的非阻塞IO实现：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class NIOExample {

    public static void main(String[] args) throws IOException {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress("www.example.com", 80));

        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.put("Hello, NIO".getBytes());
        buffer.flip();
        socketChannel.write(buffer);

        socketChannel.close();
    }
}

**代码总结**：以上代码演示了如何使用SocketChannel和ByteBuffer实现NIO的非阻塞IO操作，向指定服务器发送消息后关闭连接。

**结果说明**：运行代码后，将向指定服务器发送消息"Hello, NIO"，并在发送完成后关闭连接。

3. **NIO 流程图**

下面是一个使用mermaid格式绘制的NIO的非阻塞IO流程示意图：

graph TD;
    A[客户端] -->|连接请求| B(选择器Selector);
    B -->|接受连接| C(通道Channel);
    C -->|读取数据| D(缓冲区Buffer);
    D -->|处理数据| C;
    C -->|写入数据| D;

通过以上内容，我们深入理解了Java中IO与NIO的特点和使用方式，希望能帮助读者更好地掌握这一重要知识点。