2023年最全新面试题含答案-【面试大全之100问-第一刊】

1. 说出一些数据库优化方面的经验?(重点)

数据库优化是提高数据库性能和效率的关键。以下是一些数据库优化方面的经验：

1. 索引优化：合理创建和使用索引可以加快查询速度。确保在经常用于查询和连接的列上创建索引，但不要过度索引，因为索引会增加写操作的开销。
2. 查询优化：编写高效的查询语句可以减少数据库的负载。避免使用全表扫描，使用合适的查询条件和连接条件，避免不必要的数据加载和计算。
3. 数据库设计优化：良好的数据库设计可以提高查询性能。优化表结构、字段类型和关系模型，避免冗余数据和多余的表连接。
4. 缓存优化：使用缓存技术减少对数据库的访问。将经常访问的数据缓存在内存中，如使用Redis或Memcached等缓存工具。
5. 批量操作优化：尽量使用批量操作代替逐条操作。批量插入、更新和删除可以减少数据库的事务开销和日志记录，提高性能。
6. 服务器和硬件优化：优化数据库服务器的配置和硬件资源，如增加内存、调整缓冲区大小、优化磁盘读写等，以提高数据库的处理能力。
7. 定期维护和优化：定期进行数据库维护操作，如数据清理、索引重建、统计信息更新等，以保持数据库的健康状态和性能。
8. 监控和调优：使用数据库性能监控工具，监测数据库的性能指标，发现潜在的瓶颈和问题，并进行相应的调优和优化。
   这些经验可以根据具体的数据库系统和应用场景进行调整和优化。数据库优化是一个持续的过程，需要不断地评估和改进。

2. 你有优化 SQL 查询数据经验吗？说一下你一般用那些什么方式进行优化？

是的，我有优化SQL查询的经验。以下是我通常使用的一些方式进行优化：

1. 确保正确的索引：对于经常被查询的列，确保为其创建合适的索引。根据查询的条件和连接操作，创建单列索引、组合索引或覆盖索引，以提高查询性能。
2. 优化查询语句：编写高效的查询语句可以减少数据库的负载。避免使用全表扫描，使用合适的查询条件和连接条件，避免不必要的数据加载和计算。使用EXPLAIN语句来分析查询计划，查看是否存在潜在的性能问题。
3. 避免使用SELECT *：只选择需要的列，避免使用SELECT *，以减少数据传输和内存开销。
4. 使用合适的数据类型：选择合适的数据类型来存储数据，避免使用过大或不必要的数据类型，以节省存储空间和提高查询性能。
5. 分页查询优化：对于大数据量的分页查询，使用合适的分页策略，如使用LIMIT关键字进行分页，避免一次性加载所有数据。
6. 避免频繁的连接和断开：尽量避免频繁地打开和关闭数据库连接，可以使用连接池来管理数据库连接，以减少连接的开销。
7. 定期维护和优化：定期进行数据库维护操作，如索引重建、统计信息更新、表碎片整理等，以保持数据库的健康状态和性能。
8. 使用缓存：对于频繁查询但不经常变化的数据，可以使用缓存技术，如Redis或Memcached，减少对数据库的访问。
   这些优化方式可以根据具体的数据库和查询需求进行调整和应用。同时，通过监控和评估查询性能，可以不断地改进和优化查询过程。

3. 什么是事务,事务的四个特性是什么？有哪些隔离级别？

事务是数据库管理系统中的一个操作单元，它是由一组数据库操作组成的逻辑工作单元，要么全部执行成功，要么全部回滚。事务具有以下四个特性，通常被称为ACID特性：

1. 原子性（Atomicity）：事务是一个不可分割的操作单元，要么全部执行成功，要么全部回滚。如果事务中的任何一个操作失败，整个事务都会被回滚到事务开始前的状态。
2. 一致性（Consistency）：事务执行前后，数据库的状态应保持一致。事务在执行过程中对数据的修改必须符合所有的约束和规则，以确保数据的完整性。
3. 隔离性（Isolation）：事务的执行应该相互隔离，不会相互影响。每个事务都应该感觉自己在独立地操作数据，即使多个事务同时执行也不会产生干扰。
4. 持久性（Durability）：一旦事务提交成功，其所做的修改将永久保存在数据库中，即使发生系统故障或重启，修改的数据也不会丢失。

隔离级别是指数据库管理系统在处理并发事务时，为了保证事务隔离性而采取的策略。常见的隔离级别有以下四种：

1. 读未提交（Read Uncommitted）：允许一个事务读取另一个事务未提交的数据。最低级别的隔离，可能会导致脏读、不可重复读和幻读的问题。
2. 读已提交（Read Committed）：要求一个事务只能读取另一个事务已提交的数据。避免了脏读的问题，但仍可能出现不可重复读和幻读的问题。
3. 可重复读（Repeatable Read）：要求一个事务在整个过程中多次读取同一数据时，结果保持一致。避免了脏读和不可重复读的问题，但仍可能出现幻读的问题。
4. 序列化（Serializable）：最高级别的隔离，要求所有事务串行执行，避免了脏读、不可重复读和幻读的问题。但也导致了并发性能的下降。
   不同的隔离级别在事务的并发性和数据一致性之间做出了不同的权衡，开发者需要根据具体的业务需求选择适合的隔离级别。

4. 数据类型 char 与 varchar2 有什么区别？性能方面各有什么优势？

char 和 varchar2 是数据库中常见的数据类型，它们在存储字符数据方面有一些区别。
主要区别如下：

1. 存储方式：char 类型会固定分配指定长度的存储空间，不管实际存储的数据长度是多少，都会占用固定的空间。而 varchar2 类型只会占用实际存储数据所需的空间，不会浪费额外的空间。
2. 存储长度限制：char 类型的长度是固定的，如果存储的数据长度小于指定长度，会在后面补空格字符。varchar2 类型的长度是可变的，可以存储不同长度的数据。
3. 查询性能：由于 char 类型固定长度的特性，对于查询操作来说，在存储和检索过程中更加高效。而 varchar2 类型在存储和检索过程中需要额外的长度信息，可能会稍微降低查询性能。

总体来说，使用 char 类型适合存储长度固定的数据，例如存储固定长度的编码、状态等信息。而使用 varchar2 类型适合存储长度不固定的数据，例如存储用户输入的文本、描述等信息。请注意，这些优势可能会因不同的数据库管理系统而有所不同。

5. 你怎么知道查询 SQL 的性能高还是低？

确定查询 SQL 的性能高低可以通过以下几种方式：

1. 执行计划（Execution Plan）：数据库管理系统会为每个查询语句生成一个执行计划，它描述了查询的执行方式和顺序。通过查看执行计划，可以了解查询是否使用了索引、是否存在全表扫描等信息，从而评估查询的性能。
2. 查询优化器（Query Optimizer）：数据库管理系统的查询优化器会根据查询语句和表结构等信息，选择最优的执行计划。如果查询优化器选择了一个高效的执行计划，那么查询的性能可能较高。
3. 执行时间（Execution Time）：执行时间是衡量查询性能的一个重要指标。可以通过记录查询的开始时间和结束时间，计算查询的执行时间。执行时间越短，性能越高。
4. 索引使用情况：索引是提高查询性能的常用手段之一。通过查看查询语句是否使用了适当的索引，以及索引的命中率等信息，可以初步评估查询的性能。
5. 数据库性能监控工具：数据库管理系统通常提供一些性能监控工具，可以实时监控数据库的性能指标，如CPU利用率、磁盘IO等。通过监控这些指标，可以了解查询对数据库整体性能的影响。

需要注意的是，查询的性能受到多种因素的影响，包括数据量、表结构、索引设计、硬件配置等。因此，综合考虑以上因素，才能准确评估查询 SQL的性能。

6. 在开发过程中遇到过数据库锁吗？怎样解锁？

在开发过程中，确实会遇到数据库锁的情况。数据库锁是为了保证并发操作的一致性而引入的机制，它可以防止多个事务同时对同一数据进行修改，从而避免数据不一致的问题。
解锁的方法取决于锁的类型和持有锁的事务。以下是常见的解锁方法：

1. 等待锁释放：如果一个事务请求获取了一个其他事务持有的锁，它可以选择等待锁释放。一旦锁被释放，请求的事务可以获取到锁并继续执行。
2. 提交或回滚事务：如果一个事务持有锁，并且完成了对数据的修改操作，它可以选择提交事务。提交事务会释放所有持有的锁。另外，如果一个事务遇到问题无法继续执行，可以选择回滚事务，同样会释放所有持有的锁。
3. 强制释放锁：某些数据库管理系统提供了手动释放锁的命令或操作，可以在特定情况下使用。但需要谨慎使用，因为强制释放锁可能会导致数据不一致或其他问题。
4. 优化锁使用：在开发过程中，可以通过优化数据库设计、查询语句和事务操作，减少锁的竞争和持有时间，从而提高并发性能。

需要注意的是，解锁的具体方法会因数据库管理系统和具体的应用场景而有所不同。在实际开发中，建议参考数据库管理系统的文档和相关资源，以了解特定数据库的锁机制和解锁方法。

7. 怎样处理并发数据? (重点)

处理并发数据是数据库开发中非常重要的一项任务，以下是一些常见的处理并发数据的方法：

1. 乐观并发控制（Optimistic Concurrency Control）：在这种方法中，不加锁地允许多个事务同时访问和修改数据。每个事务在提交之前会检查数据是否被其他事务修改过。如果数据未被修改，事务可以继续提交；如果数据被修改，事务需要进行回滚或重新尝试。常见的实现方式是使用版本号或时间戳来跟踪数据的变化。
2. 悲观并发控制（Pessimistic Concurrency Control）：在这种方法中，使用锁来保护数据，确保同一时间只有一个事务可以访问和修改数据。常见的锁包括行级锁和表级锁。悲观并发控制可以确保数据的一致性，但可能会降低并发性能。
3. 事务隔离级别（Transaction Isolation Level）：数据库提供了不同的事务隔离级别，如读未提交、读已提交、可重复读和串行化。通过设置适当的隔离级别，可以控制事务之间的数据可见性，从而处理并发数据的问题。
4. 数据库锁定（Database Locking）：使用数据库锁定机制可以确保在同一时间只有一个事务可以访问和修改特定数据。锁定的粒度可以是行级、表级或其他级别。合理使用数据库锁定可以避免并发冲突，但需要注意锁定粒度和持有时间，以避免性能问题和死锁。
5. 串行化（Serialization）：在某些情况下，为了确保数据的一致性，可能需要将一些操作串行化执行，即只允许一个事务执行某些操作。串行化可以避免并发冲突，但会降低并发性能，需要谨慎使用。

综合选择合适的并发控制方法取决于具体的应用场景和需求。需要根据数据访问模式、并发程度、数据一致性要求等因素进行评估和决策。同时，合理的数据库设计和优化查询语句也能够减少并发冲突的发生。

8.delete from table 与 truncate table 的区别？drop table 呢

delete from table 和 truncate table 是数据库中常用的删除表数据的操作，而 drop table 则是删除整个表的操作。它们之间有以下区别：

1. delete from table：这是一种删除表数据的操作，它会逐行地删除表中的数据。使用 delete from table 语句时，可以添加条件来指定要删除的数据行。delete from table 是一种 DML（数据操作语言）操作，会触发事务日志，可以通过回滚操作来还原删除的数据。删除操作会占用大量的系统资源，并且删除的数据可以被恢复。
2. truncate table：这是一种快速删除表数据的操作，它会一次性删除整个表的数据。使用 truncate table 语句时，不需要指定条件，它会直接删除整个表的数据。truncate table 是一种 DDL（数据定义语言）操作，不会触发事务日志，因此无法通过回滚来还原删除的数据。由于不记录日志，truncate table 比 delete from table 操作更快，且不会占用大量的系统资源。但需要注意的是，truncate table 操作是不可恢复的，删除的数据无法恢复。
3. drop table：这是一种删除整个表的操作，它会删除整个表及其相关的索引、约束、触发器等。使用 drop table 语句时，会直接删除整个表及其相关对象，无法通过回滚来还原。drop table 是一种 DDL 操作，执行后表的结构和数据都会被删除，需要谨慎使用。

总结：delete from table 是逐行删除表数据的操作，可以回滚，占用资源较多；truncate table 是一次性删除整个表数据的操作，无法回滚，速度快且资源消耗较少；drop table 是删除整个表的操作，无法回滚，会删除表及其相关对象。根据具体需求和场景选择合适的操作。

9. union 和 union all 有什么不同?

union 和 union all 是用于合并查询结果的操作符，它们在功能和行为上有一些不同之处：

1. union：union 操作符用于合并两个或多个查询结果，并去除重复的行。它会将多个查询的结果集合并成一个结果集，并自动去除重复的行。换句话说，如果多个查询的结果中有相同的行，只会保留一行。union 操作符会对结果进行排序，以确保去重的效果。由于需要进行去重操作，union 的性能可能会略低于 union all。
2. union all：union all 操作符也用于合并两个或多个查询结果，但不会去除重复的行。它会将多个查询的结果集合并成一个结果集，包括所有的行，不进行去重操作。换句话说，如果多个查询的结果中有相同的行，会保留所有的行。union all 操作符不会对结果进行排序或去重，因此性能可能会比 union 高。

总结：union 会合并查询结果并去除重复的行，而 union all 则会合并查询结果并保留所有的行。如果需要去除重复的行，可以使用 union；如果不需要去重，或者需要更高的性能，可以使用 union all。

10. JDBC 访问数据库的步骤？(重点)

JDBC（Java Database Connectivity）是Java提供的一种用于访问数据库的API。以下是使用JDBC访问数据库的一般步骤：

1. 加载驱动程序：使用Class.forName()方法加载数据库驱动程序，例如：

Class.forName("com.mysql.jdbc.Driver");

2. 建立数据库连接：使用DriverManager.getConnection()方法创建与数据库的连接，需要提供数据库的URL、用户名和密码等信息，例如：

   Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "username", "password");

3. 创建Statement或PreparedStatement对象：通过Connection对象创建Statement或PreparedStatement对象，用于执行SQL语句，例如：

  Statement statement = connection.createStatement();
  或
  PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM mytable WHERE id = ?");

4. 执行SQL语句：使用Statement对象的executeQuery()、executeUpdate()等方法执行SQL语句，例如：

  ResultSet resultSet = statement.executeQuery("SELECT * FROM mytable");
  或
  preparedStatement.setInt(1, 1);
  ResultSet resultSet = preparedStatement.executeQuery();

5. 处理查询结果：通过ResultSet对象获取查询结果，可以使用ResultSet的getXXX()方法获取具体的数据，例如：

   while (resultSet.next()) {
       int id = resultSet.getInt("id");
       String name = resultSet.getString("name");
       // 处理结果数据
   }

6. 关闭连接和释放资源：在使用完数据库连接、Statement、ResultSet等对象后，需要及时关闭连接和释放资源，例如：

   resultSet.close();
   statement.close();
   connection.close();

以上是JDBC访问数据库的一般步骤。需要根据具体的数据库和需求进行相应的配置和操作。同时，为了安全和性能考虑，还可以使用连接池技术来管理数据库连接。

11. 大数据量下的分页解决方法。

在处理大数据量下的分页时，常规的方式往往会面临性能和效率的挑战。以下列出几种常用的解决方法：

1. 使用数据库的分页：数据库提供了一些特定语法来处理分页，例如MySQL中的LIMIT关键字、Oracle中的ROWNUM等。通过在查询语句中添加合适的分页参数，可以在数据库层面实现分页，减少数据传输和处理的开销。

2. 使用游标：游标是一种数据库技术，可以使用它遍历查询结果集的一部分。通过使用游标，可以在数据库中直接定位到指定的分页数据，减少了数据传输的负担。不同的数据库系统对游标的支持和语法可能会有所不同。

3. 使用索引：在大数据量下，为需要分页的列添加索引可以大大提高分页的性能。索引可以使数据库在查询时更快地定位到需要的数据页，减少扫描的数据量。对查询的列添加适当的索引，可以提高分页操作的效率。

4. 基于查询条件的分页：在查询时，尽量通过添加合适的查询条件来限制数据量。例如，根据时间范围、状态等条件将数据进行过滤，减少需要分页的数据量。这样能够减少数据库查询的开销，提高分页操作的效率。

5. 数据预处理和缓存：在大数据量下，可以将数据进行预处理，并将部分结果缓存在内存中。通过将数据划分为合适的缓存块，可以快速响应分页请求，避免每次都对整个数据集进行查询和处理。

6. 延迟加载：如果分页结果中的每一条数据都非常庞大，可以考虑使用延迟加载的技术。只在需要显示具体数据时再进行加载，可以减少数据传输和处理的开销。对于像图片、文件等大数据字段，可以使用懒加载的方式，只在用户需要时再加载相应的内容。

12. 简述建立索引的作用和索引的分类 ?

建立索引是数据库中的一项重要技术，它可以提高数据的检索效率和查询性能。索引是数据库表中一个或多个列的值的排序结构，它们可以帮助数据库快速地定位和访问所需的数据，而无需扫描整个表。

索引的作用：

7. 提高查询性能：通过使用索引，数据库可以更快地定位到满足查询条件的数据，减少了磁盘I/O操作的开销，提高了查询效率。

8. 减少数据扫描：对于大型表或包含大量数据的表，使用索引可以减少需要扫描的数据量，从而降低了资源消耗。

9. 加速排序和连接操作：当需要对查询结果进行排序或进行表之间的连接操作时，索引可以加快这些操作的速度。

索引的分类：

B树索引（平衡树索引）：B树索引是最常见和常用的索引类型，如B+树、B树等。它适用于范围查询和精确匹配查询。B树索引根据索引值的大小建立搜索树，每个节点可以包含多个索引值，可以高效地支持范围查询。

1. 哈希索引：哈希索引使用哈希算法将索引值映射为哈希码，然后将哈希码映射到存储位置。它适用于等值查询，对于大数据量的范围查询效果不好。哈希索引在查询时具有快速查找的速度，但在范围查询和排序时的性能较差。

2. 全文索引：全文索引是对文本数据进行的索引。它适用于针对文本内容进行关键字搜索和匹配的查询。全文索引可快速搜索包含关键字的文档，并支持模糊匹配、通配符等高级搜索功能。

3. 组合索引：组合索引是对表中多个列进行组合建立的索引，它适用于多列的查询条件。组合索引在多列的查询或多个列的排序时具有较好的性能，但对于其中某些列的查询或排序性能可能不如单列索引。

在创建索引时，需要根据具体的查询需求和数据特点进行选择和优化，避免过多或不必要的索引，以免降低写操作的性能。同时，索引还会占用存储空间，因此需要权衡索引的性能提升和资源消耗之间的关系。

13. 什么是存储过程,有什么优缺点(重点)。

存储过程（Stored Procedure）是一组预编译的数据库操作语句，它们被存储在数据库中并可以被重复调用。存储过程通常由SQL语句、流程控制语句和变量等组成，用于完成特定的数据库操作。

存储过程的优点：

1. 提高性能：存储过程在数据库服务器上预编译和存储，可以减少网络通信开销和SQL解析的时间，提高查询和操作的性能。
2. 重用性：存储过程可以被多个应用程序或用户重复调用，提高了代码的重用性和可维护性。
3. 安全性：存储过程可以对数据库中的数据进行封装和保护，只允许授权用户访问和修改数据，提高了数据的安全性。
4. `简化复杂操作：存储过程可以封装复杂的业务逻辑和数据操作，简化了应用程序的开发和维护。

存储过程的缺点：

1. 学习和开发成本：编写和维护存储过程需要掌握特定的存储过程语言和数据库技术，对开发人员的要求较高。
2. 可移植性差：不同的数据库管理系统对存储过程的支持和语法有所不同，存储过程的可移植性较差。
3. 难以调试：存储过程在数据库服务器上执行，调试和排查问题相对复杂，需要使用特定的工具和技术。

综合考虑，存储过程在提高性能、重用性和安全性方面具有明显的优势，适用于复杂的业务逻辑和数据操作。但需要权衡其学习成本、可移植性和调试难度等缺点。在具体应用中，需要根据实际需求和数据库管理系统的特点进行评估和选择。

14. 存储过程与 SQL 的区别？

存储过程和SQL是数据库中的两个不同的概念：

1. 存储过程（Stored Procedure）是一组预编译的数据库操作语句，它们被存储在数据库中并可以被重复调用。存储过程通常由SQL语句、流程控制语句和变量等组成，用于完成特定的数据库操作。存储过程可以封装复杂的业务逻辑和数据操作，提高了性能、重用性和安全性。
2. SQL（Structured Query Language）是一种用于操作和管理关系型数据库的语言。它可以用于创建、修改、查询和删除数据库中的表、数据和索引等。SQL是一种通用的数据库查询语言，可以用于执行各种数据库操作，包括创建表、插入数据、查询数据、更新数据和删除数据等。

存储过程与SQL的区别如下：

1. 存储过程是一组预编译的数据库操作语句，而SQL是一种用于执行数据库操作的语言。
2. 存储过程可以被存储在数据库中并重复调用，而SQL语句通常是即时执行的。
3. 存储过程可以封装复杂的业务逻辑和数据操作，提供更高级的功能和性能优化，而SQL语句主要用于执行特定的数据库操作。
4. 存储过程通常由SQL语句组成，但还可以包含流程控制语句和变量等，具备更多的编程特性，而SQL语句更侧重于描述数据库操作的语法。

综上所述，存储过程和SQL是数据库中的两个不同概念，存储过程是一组预编译的数据库操作语句，而SQL是一种用于操作和管理关系型数据库的语言。存储过程可以提供更高级的功能和性能优化，而SQL语句主要用于执行特定的数据库操作。

15. 如何创建视图？

要创建一个视图（View），可以按照以下步骤进行：

1. 定义视图的查询语句：确定视图所要展示的数据，编写好对应的查询语句。可以包括任意有效的SELECT语句，可以涉及一个或多个表的数据。
2. 使用CREATE VIEW语句创建视图：在数据库管理系统提供的管理工具（如MySQL Workbench、Oracle SQL Developer等）或命令行终端中使用CREATE VIEW语句创建视图。CREATE VIEW语句的基本语法如下：

CREATE VIEW view_name AS
SELECT column1, column2, ...
FROM table_name
WHERE condition;

其中，view_name是要创建的视图的名称，column1, column2等是要展示的列名，table_name是查询的表名，condition是查询的条件（可选）。

3. 执行CREATE VIEW语句：将编写好的CREATE VIEW语句发送给数据库管理系统执行。如果语句无错误并成功执行，视图将会被创建并保存在数据库中。
   创建成功后，可以像普通表一样查询和引用视图。视图可以用于简化复杂查询、提供需要的数据显示、限制数据访问等。

需要注意的是，视图本身不存储实际的数据，它只是对基础表中数据的一个虚拟展示，因此视图的数据将随着基础表数据的变化而变化。此外，需要根据数据库管理系统的规范和文档来使用和管理视图。

16. JAVA 中常用的运算符有哪些？这些运算符之间的优先级怎么样？

Java中常用的运算符包括：

1. 算术运算符：用于执行各种数学运算，如加减乘除、取余等。包括：+ (加法)、- (减法)、* (乘法)、/ (除法)、% (取余)。
2. 赋值运算符：用于将值赋给变量。包括：= (简单赋值)、+= (加后赋值)、-= (减后赋值)、*= (乘后赋值)、/= (除后赋值)、%= (取余后赋值)。
3. 比较运算符：用于比较两个值的大小或相等性。包括：== (等于)、!= (不等于)、> (大于)、< (小于)、>= (大于等于)、<= (小于等于)。
4. 逻辑运算符：用于进行逻辑操作，如与、或、非等。包括：&& (逻辑与)、|| (逻辑或)、! (逻辑非)。
5. 位运算符：对二进制位进行操作，如按位与、按位或等。包括：& (按位与)、| (按位或)、^ (按位异或)、~ (按位取反)、<< (左移)、>> (带符号右移)、>>> (无符号右移)。
6. 条件运算符（三元运算符）：基于某个条件的真假选择不同的值。格式为条件表达式 ? 表达式1 : 表达式2，如果条件为真，则返回表达式1的结果，否则返回表达式2的结果。

运算符的优先级（从高到低）如下：

1.一元运算符 (++、–、+、-、!、~)
2.算术运算符 (、/、%)
3.加法和减法运算符 (+、-)
4.移位运算符 (<<、>>、>>>)
5.关系运算符 (<=、>=、<、>)
6.相等性运算符 (==、!=)
7.位运算符 (&、|、^)
8.逻辑运算符 (&&、||)
9.条件运算符 (?：)
10.赋值运算符 (=、+=、-=、=、/=、%=、<<=、>>=、&=、^=、|=)

需要注意的是，可以使用小括号来改变运算符的优先级，以便于控制表达式的求值顺序。

17. 在 JAVA 自定义一个生产 10-100 之间的随机数的公式？

在Java中，可以使用以下代码自定义一个生成10到100之间随机数的公式：

import java.util.Random;
 public class RandomNumberGenerator {
 
    public static void main(String[] args) {
        int randomNumber = generateRandomNumber(10, 100);
        System.out.println(randomNumber);
    }
    
    public static int generateRandomNumber(int min, int max) {
        Random random = new Random();
        return random.nextInt(max - min + 1) + min;
    }
}

在上述代码中，我们使用Random类来生成随机数。通过调用nextInt方法，传入参数max - min + 1，再加上min，即可生成10到100之间的随机数。

18. switch 语句中的表达式可以是什么类型数据？

在Java中，switch语句的表达式可以是以下类型的数据：

1. 整型数据类型：可以是byte、short、int或char类型。从Java 7开始，还支持使用枚举类型作为表达式。

2. 字符串类型：从Java 7开始，switch语句也支持使用字符串作为表达式。在switch语句中使用字符串作为表达式时，每个case标签必须是字符串常量或字符串字面值。

3. 枚举类型：自Java 7以后，可以使用枚举类型作为switch语句的表达式。
   需要注意的是，表达式的数据类型必须与每个case标签的数据类型兼容。也就是说，表达式的数据类型必须与case标签的数据类型相同或能够进行隐式转换。此外，Java中不支持在switch语句中使用浮点数、布尔类型或对象类型作为表达式。

以下是一个使用不同类型数据作为switch语句表达式的示例：

public class SwitchStatement {
    public static void main(String[] args) {
        int choice = 1;
        switch (choice) {
            case 1:
                System.out.println("选择了1");
                break;
            case 2:
                System.out.println("选择了2");
                break;
            default:
                System.out.println("选择了其他");
                break;
        }
        
        String day = "Monday";
        switch (day) {
            case "Monday":
                System.out.println("星期一");
                break;
            case "Tuesday":
                System.out.println("星期二");
                break;
            default:
                System.out.println("其他天");
                break;
        }
    }
}

上述代码中，我们展示了使用整型和字符串作为switch语句表达式的例子。注意，每个case标签必须以break语句或return语句来结束，以避免执行其他情况的代码。

19. while 循环结构与 do…while 循环结构的不同？

while循环结构和do…while循环结构是两种不同的循环结构，它们的主要区别在于循环条件的判断时机不同：

1. while循环结构：在进入循环之前先判断循环条件是否满足，如果条件为真，则执行循环体中的代码。如果条件为假，则直接跳过循环体，不执行其中的代码。因此，while循环有可能一次都不执行。
   示例：

int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

在上述示例中，循环条件是 i < 5 ，在每次循环之前都会先判断条件是否满足。

2. do...while循环结构：先执行循环体中的代码，然后再判断循环条件是否满足。如果条件为真，则继续执行循环体，否则退出循环。因此，do…while循环至少会执行一次循环体中的代码。
   示例：

int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 5);

在上述示例中，循环条件是 i < 5 ，在执行完循环体中的代码后，会先判断条件是否满足。

总结：
while循环和do…while循环的区别在于循环条件的判断时机不同，while循环在进入循环之前判断条件，do…while循环在执行完循环体后判断条件。因此，如果循环体至少要执行一次，可以使用do…while循环；如果循环体可能一次都不执行，可以使用while循环。

20. 程序中 break、continue、return 跳转语句的不同？(重点)

在程序中，break、continue和return是三种不同的跳转语句，它们的作用和行为有所不同：

1. break语句：break语句用于终止当前循环或switch语句的执行，并跳出循环或switch语句的代码块。当遇到break语句时，程序会立即退出当前循环或switch语句，并继续执行循环或switch语句后面的代码。break语句通常用于在满足某个条件时提前结束循环，或者在switch语句中匹配到特定的case后跳出switch语句。
   示例：

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println(i);
}

在上述示例中，当i等于5时，遇到break语句，会立即终止循环的执行，输出结果为0到4。

2. continue语句：continue语句用于终止当前循环的本次迭代，并跳过循环体中continue语句后面的代码，继续下一次循环迭代。当遇到continue语句时，程序会跳过当前循环迭代中continue语句后面的代码，直接进入下一次循环迭代。continue语句通常用于在满足某个条件时跳过当前迭代，继续下一次迭代。
   示例：

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    System.out.println(i);
}

在上述示例中，当i为偶数时，遇到continue语句，会跳过当前迭代中continue语句后面的代码，直接进入下一次迭代，输出结果为1、3、5、7、9。

3. return语句：return语句用于结束当前方法的执行，并返回指定的值（如果有返回值）。当遇到return语句时，程序会立即退出当前方法，并将指定的值返回给调用者。return语句可以在任何地方使用，用于提前结束方法的执行，并返回结果。
   示例：

public int add(int a, int b) {
    return a + b;
}

在上述示例中，当调用add方法时，执行到return语句时，会立即退出方法，并返回a和b的和作为方法的结果。

总结：
break语句用于终止当前循环或switch语句的执行，并跳出代码块；
continue语句用于终止当前循环的本次迭代，并跳过循环体中continue语句后面的代码，继续下一次迭代；
return语句用于结束当前方法的执行，并返回指定的值（如果有返回值）。

21. 数组的定义有哪些方式？

数组的定义有以下几种方式：

1. 静态初始化：在定义数组的同时，为数组元素赋初值。
   • 语法：数据类型[] 数组名 = {元素1, 元素2, …};
   • 示例：int[] numbers = {1, 2, 3, 4, 5};
2. 动态初始化：先定义数组，然后为数组元素赋值。
   • 语法：数据类型[] 数组名 = new 数据类型[数组长度];
   • 示例：int[] numbers = new int[5];
3. 默认初始化：在定义数组时，不为数组元素赋初值。数组元素会根据数据类型进行默认初始化。
   • 语法：数据类型[] 数组名 = new 数据类型[数组长度];
   • 示例：int[] numbers = new int[5];
4. 匿名数组：定义一个没有指定名称的数组。
   • 语法：数据类型[] 数组名 = new 数据类型[] {元素1, 元素2, …};
   • 示例：int[] numbers = new int[] {1, 2, 3, 4, 5};
5. 多维数组的定义：数组中的元素也是数组的数组。
   • 语法：数据类型[][] 数组名 = new 数据类型[行数][列数];
   • 示例：int[][] matrix = new int[3][3];
     需要根据具体的需求和场景选择合适的数组定义方式。

22. 编写一个程序实现费波拉契数。

以下是一个使用Java编写的实现斐波那契数列的程序：

public class Fibonacci {
    public static void main(String[] args) {
        int n = 10; // 指定要输出的斐波那契数列的个数
        System.out.println("斐波那契数列前 " + n + " 个数为：");
        for (int i = 0; i < n; i++) {
            System.out.print(fibonacci(i) + " ");
        }
    }
     public static int fibonacci(int n) {
        if (n <= 1) {
            return n;
        } else {
            return fibonacci(n - 1) + fibonacci(n - 2);
        }
    }
}

在上述代码中，我们定义了一个名为 fibonacci 的递归方法，用于计算斐波那契数列中第 n 个数的值。然后在 main 方法中，我们指定要输出斐波那契数列的个数，并通过循环调用 fibonacci 方法来输出每个数的值。

运行该程序，将输出斐波那契数列前10个数的值： 斐波那契数列前 10 个数为：
0 1 1 2 3 5 8 13 21 34
请注意，斐波那契数列中的第一个数是0，第二个数是1，后续的数是前两个数的和。

23. 成员变量和局部变量的区别是什么？

成员变量和局部变量是两种不同的变量类型，它们在作用域、存储位置和生命周期等方面有所不同：

• 作用域：
  成员变量（也称为实例变量）：属于类的成员，可以在整个类中被访问。成员变量在类中声明，但在方法外部定义。它可以被类中的所有方法访问和共享。
  局部变量：定义在方法或块中，并且在方法或块内部有效。局部变量仅在定义它的方法或块中可见。
• 存储位置：
  成员变量：存储在对象的堆内存中（如果是实例变量）或静态存储区中（如果是静态变量）。
  局部变量：存储在栈内存中。
• 生命周期：
  成员变量：与对象的生命周期相同，即它们的存在与对象的创建和销毁相关。
  局部变量：在定义它们的方法或块执行期间创建，当方法或块执行完毕后销毁。
• 默认值：
  成员变量：如果没有显式赋初值，将被赋予默认值（如0、null等）。
  局部变量：在使用之前必须被显式赋值，否则编译错误。
• 访问修饰符：
  成员变量：可以使用不同的访问修饰符（如public、private、protected等）进行修饰。
  局部变量：不能使用访问修饰符进行修饰。
  需要注意的是，成员变量可以用关键字static修饰，使其称为静态变量，而局部变量不能使用static修饰。

总之，成员变量和局部变量用于在程序中存储和访问数据，但它们的使用场景和特性不同。成员变量主要用于表示对象的属性，而局部变量主要用于辅助方法或块的执行过程。

24. JAVA 中包的作用是什么？

在Java中，包（Package）是用来组织和管理类和接口的一种机制。包的作用主要有以下几个方面：

1. 组织类：包可以将相关的类和接口组织在一起，形成一个逻辑上的单元。这样可以更好地管理和维护代码，提高代码的可读性和可维护性。
2. 命名空间：包提供了命名空间的概念，不同包中的类可以使用相同的类名，通过包名进行区分，避免类名冲突的问题。
3. 访问控制：包可以通过访问修饰符（如public、private、protected、default）来控制类和接口的可见性和访问权限。只有在同一个包中的类才能访问包私有（default）访问修饰符修饰的类或成员。
4. 封装和隐藏：包可以将类和接口进行封装和隐藏，通过将类和接口声明为包私有或使用访问修饰符限制访问，可以控制外部代码对类和接口的访问权限，提高封装性和安全性。
5. 组织和管理资源：包可以用于组织和管理相关的资源文件，如配置文件、图像、音频等，使得资源文件和代码可以放在一起，方便管理和使用。
   在Java中，使用关键字 package 来声明一个包，并使用包名来标识一个类或接口所属的包。例如： package com.example.mypackage; 表示该类或接口属于 com.example.mypackage 包。

25. 包命名规范有哪些？

在Java中，包的命名应遵循以下命名规范：

1. 使用小写字母：包名应使用全小写字母，不应使用大写字母。
2. 使用英文单词或者域名倒置：包名可以使用由英文单词组成的命名，也可以使用域名的逆序作为包名的一部分。
   • 使用英文单词：包名应描述包含的类和接口的功能或者所属的模块，使用有意义的单词命名，避免使用过于简单或者无意义的名字。
   • 使用域名倒置：对于企业或者组织的代码，可以使用域名的逆序作为包名的一部分，以确保包名的唯一性。例如，com.example.mypackage。
3. 使用点（.）作为分隔符：包名使用点作为分隔符，表示不同层级的包之间的关系。
4. 避免使用Java关键字和保留字：包名不应与Java关键字和保留字相同，以避免编译错误。

需要注意的是，包名的命名规范是一种约定，遵循这种约定可以使代码更具可读性和可维护性。同时，在团队合作开发时，还应遵循项目中的命名规范和约定，以保证代码风格的一致性。

26. String 是最基本的数据类型吗?

在Java中，String 不是最基本的数据类型。实际上，String 是Java中的一个类，用于表示字符串类型的数据。Java的最基本的数据类型是原始数据类型，包括以下几种：

1. 整数类型：byte、short、int、long
2. 浮点类型：float、double
3. 字符类型：char
4. 布尔类型：boolean

这些原始数据类型是Java语言中最基本的内置类型，它们在内存中直接存储对应的值，不需要进行对象的创建操作。

而String 类是用于表示文本字符串的数据类型，它提供了丰富的方法和功能来操作字符串，比如拼接、截取、替换等。虽然String 类提供了一些操作字符串的方法，但它本身不是原始数据类型，而是一个引用类型，也就是一个类。

需要注意的是，Java为了方便编程和提高性能，对字符串类型使用了特殊处理，使得我们可以像使用原始数据类型一样使用字符串。这种特殊处理称为字符串常量池（String
Pool），它可以使字符串的比较更高效，同时也使得字符串在某些情况下表现得更像原始数据类型。但是，从语言层面上来说，String
类是一个引用类型，而不是原始数据类型。

27.说明一下类变量和实例变量的区别. (重点)

类变量（静态变量）和实例变量（成员变量）是两种不同的变量类型，它们在访问方式、存储位置和生命周期等方面有所不同：

1. 访问方式：
   • 类变量：使用类名或对象名来访问，可以通过类名直接访问；
   • 实例变量：使用对象名来访问，必须通过创建对象后才能访问。
2. 存储位置：
   • 类变量：属于类本身，在类加载时创建，在类的生命周期中只有一份，存储在静态存储区。
   • 实例变量：属于类的实例，在创建对象时被创建，每个对象都有自己的实例变量，存储在堆内存中。
3. 生命周期：
   • 类变量：在类加载时创建，当程序结束或类被卸载时销毁。
   • 实例变量：在创建对象时创建，当对象被回收时销毁。
4. 共享性：
   • 类变量：所有该类的对象共享同一份类变量的值。
   • 实例变量：每个对象都有自己的实例变量，彼此之间不会相互影响。
5. 默认值：
   • 类变量：如果没有显式赋初值，将被赋予默认值（如0、null等）。
   • 实例变量：如果没有显式赋初值，将根据类型而有所不同，比如数值类型初始值为0，布尔类型初始值为false，引用类型初始值为null。

需要注意的是，在使用类变量时应注意线程安全性，因为类变量的共享性可能导致并发访问的问题。另外，在实践中，类变量通常用于表示全局或共享的状态，实例变量用于表示对象的属性和状态。

总结来说，类变量和实例变量在访问方式、存储位置、生命周期和共享性等方面有所不同，它们在面向对象的程序设计中具有不同的应用场景和特点。

28. 说明实例方法和类方法的区别？ (重点)

实例方法（实例成员方法）和类方法（静态方法）是Java中两种不同的方法类型，它们在访问方式、调用方式和使用场景等方面有所不同：

1. 访问方式：

   • 实例方法：只能通过对象来访问和调用。在调用实例方法时，需要先创建对象，然后通过对象来调用该方法。
   • 类方法：可以通过类名直接访问和调用，也可以通过对象来访问。无需先创建对象就可以访问和调用类方法。

2. 调用方式：

   • 实例方法：在方法体内可以访问和操作实例变量，也可以访问和调用其他实例方法。
   • 类方法：不能直接访问和操作实例变量，但可以访问和调用类变量（静态变量），以及调用其他类方法。

3. 使用场景：

   • 实例方法：适合用于实现对象的行为和操作，可以访问和操作对象的状态（实例变量）。
   • 类方法：适合用于实现与类相关的功能或者工具方法，不依赖于具体的对象状态，独立于对象存在。

4. 继承和重写：

   • 实例方法：可被子类继承和重写（覆盖），子类可以通过继承和重写实例方法来改变方法的行为。
   • 类方法：不可被子类继承和重写，不具有多态性。类方法的调用始终是基于编译时的类型，而不是运行时的类型。

需要注意的是，类方法通常用于实现共享的工具方法或者对类进行操作的方法，而实例方法通常用于对具体对象进行操作的方法。在设计和使用时，需要根据具体需求和设计原则合理选择实例方法或类方法。

总结来说，实例方法和类方法在访问方式、调用方式和使用场景等方面有所不同，它们在面向对象的程序设计中具有不同的应用场景和特点。

29. 数组有没有 length( )方法? String 有没有 length( )方法？

在Java中，数组和字符串都有length属性而不是length()方法。

• 数组的length属性表示数组的长度，它是一个公共的成员变量，可以直接使用。例如，对于一个整型数组int[] arr，可以使用arr.length来获取数组的长度。
• 字符串的length()方法是一个方法而不是属性，用于返回字符串的长度。例如，对于一个字符串String str，可以使用str.length()来获取字符串的长度。

需要注意的是，数组的length是一个属性，没有圆括号，而字符串的length()是一个方法，需要使用圆括号。这是因为数组的长度是在创建数组时确定的，而字符串的长度需要通过方法计算得出。

总结来说，数组有length属性表示数组的长度，而字符串有length()方法返回字符串的长度。

30. String s=new String(“a”);共创建了几个 String 对象？

在代码String s = new String("a")中，共创建了两个String对象。

1. 第一个String对象是字面值字符串"a"，这是在编译时创建的。当编译器遇到字面值字符串时，它们会被自动放入字符串常量池中，如果字符串常量池中已经存在相同内容的字符串，则会直接使用已存在的对象。
2. 第二个String对象是通过new String("a")显式地创建的。使用new关键字创建String对象时，会在堆内存中分配新的内存空间来存储字符串对象。即使字符串常量池已经存在相同内容的字符串，使用new关键字创建的String对象仍然会在堆内存中创建一个新的对象。

因此，虽然代码中调用了一次new String("a")，但实际上创建了两个String对象，一个在字符串常量池中，另一个在堆内存中。

31. Java 里的传引用和传值的区别是什么？

在Java中，传引用和传值是两种不同的参数传递方式，它们的区别如下：

• 传值（传递基本类型）：当将基本类型（如int、float、boolean等）作为参数传递给方法时，实际上是将该值的副本传递给方法。在方法内部对参数进行修改不会影响原始值。

示例：

public class PassByValueExample {
    public static void main(String[] args) {
        int number = 10;
        System.out.println("Before method call: " + number);
        modifyValue(number);
        System.out.println("After method call: " + number);
    }
     public static void modifyValue(int value) {
        value = 20;
        System.out.println("Inside method: " + value);
    }
}

在上述示例中，传递给 modifyValue 方法的是 number 的副本，方法内部对 value 的修改不会影响原始的 number 值。

• 传引用（传递对象）：当将对象作为参数传递给方法时，实际上是将对象的引用（内存地址）传递给方法。在方法内部对参数进行修改会影响原始对象。

示例：

public class PassByReferenceExample {
    public static void main(String[] args) {
        StringBuilder message = new StringBuilder("Hello");
        System.out.println("Before method call: " + message);
        modifyReference(message);
        System.out.println("After method call: " + message);
    }
     public static void modifyReference(StringBuilder sb) {
        sb.append(", World!");
        System.out.println("Inside method: " + sb);
    }
}

在上述示例中，传递给 modifyReference 方法的是 message 对象的引用，方法内部对 sb 的修改会影响原始的 message 对象。

总结：
传值是将基本类型的值的副本传递给方法，方法内部对参数的修改不会影响原始值。传引用是将对象的引用（内存地址）传递给方法，方法内部对参数的修改会影响原始对象。

32. 如果去掉了 main 方法的 static 修饰符会怎样？

• 如果去掉了 main 方法的 static 修饰符，将无法直接运行该方法，会导致编译错误。在Java中， main 方法必须被声明为 static ，以便在没有创建对象的情况下直接调用该方法。这是因为 main 方法是程序的入口点，它是Java虚拟机在执行Java程序时的起点。

• 如果去掉了 static 修饰符， main 方法将成为一个实例方法，而不是一个静态方法。在Java中，实例方法需要通过创建对象来调用，而不是直接通过类名调用。因此，如果去掉了 static 修饰符，编译器将无法找到合适的入口点来执行程序，从而导致编译错误。

正确的 main 方法声明应该是：

public static void main(String[] args) {
    // 程序逻辑
}

请注意， main 方法的参数必须是一个 String 类型的数组 args ，用于接收命令行参数。

33. 如何将 String 类型转化成 Number 类型？

• 要将String类型转换为Number类型，可以使用Number类的各个子类提供的方法，如Integer、Double、Float等。这些子类提供了将String类型转换为对应Number类型的方法，例如parseInt()、parseDouble()、parseFloat()等。具体的转换方法取决于需要转换的Number类型。

以下是几个常见的String到Number类型的转换示例：

1. 转换为整数类型（Integer）：
String str = "123";
int num = Integer.parseInt(str);
2. 转换为浮点数类型（Double）：
String str = "3.14";
double num = Double.parseDouble(str);
3. 转换为长整数类型（Long）：
String str = "9876543210";
long num = Long.parseLong(str);

需要注意的是，如果String类型的值无法转换为对应的Number类型，会抛出NumberFormatException异常。因此，在进行转换之前，最好先进行合适的异常处理或验证。

另外，如果需要进行更加复杂的字符串转换操作，也可以使用正则表达式或其他字符串处理方法来提取或转换所需的数值部分。

34. 什么是 Java 虚拟机?

Java虚拟机（Java Virtual Machine，JVM）是Java平台的核心组成部分之一，它是一种在计算机上运行Java字节码的虚拟机。JVM充当了Java程序和底层操作系统之间的中间层，它负责解释和执行Java字节码，并提供了一些重要的功能和特性，包括内存管理、垃圾回收、安全性和跨平台性等。

JVM的主要功能包括：

1. 类加载器（Class Loader）：负责将编译后的Java字节码加载到内存中，并进行验证、准备和解析等操作。
2. 执行引擎（Execution Engine）：负责解释和执行Java字节码，可以采用解释执行或即时编译（Just-In-Time Compilation，JIT）等方式来提高执行效率。
3. 内存管理（Memory Management）：负责Java程序的内存分配和回收，包括堆内存和栈内存的管理。
4. 垃圾回收器（Garbage Collector）：负责自动回收不再使用的对象，释放内存空间。
5. 安全管理（Security Manager）：通过安全策略和权限控制，保护Java应用程序免受恶意代码的攻击。
6. 即时编译器（Just-In-Time Compiler，JIT）：将热点代码（频繁执行的代码）编译成本地机器码，提高程序的执行速度。
7. 跨平台性（Platform Independence）：JVM的存在使得Java程序具有跨平台性，可以在不同的操作系统和硬件平台上运行。

通过Java虚拟机，Java程序可以实现一次编写、到处运行的特性，提供了高度的可移植性和安全性。开发人员只需要编写一次Java代码，然后将其编译为字节码，就可以在支持Java虚拟机的任何平台上运行。

35. Java 的访问修饰符是什么?

在Java中，访问修饰符用于控制类、方法、变量以及构造方法的访问范围和可见性。Java提供了以下四个访问修饰符：

1. public：公共的，具有最宽的访问权限。被public修饰的类、方法、变量可以被任何类访问。
2. private：私有的，具有最小的访问权限。被private修饰的类、方法、变量只能在其所属类的内部访问，其他类无法直接访问。
3. protected：受保护的，类似于私有访问权限，但在同一包内和子类中也有访问权限。被protected修饰的方法、变量可以在同一包内的其他类中访问，并且可以被子类继承和访问。
4. 默认（不写任何修饰符）：也称为包级访问权限，默认修饰符的访问权限在同一包内可见，但对于其他包中的类不可见。

这些访问修饰符可以用于类、内部类、构造方法、成员变量和方法上，并且具有不同的作用范围和访问权限。它们的使用可以帮助我们控制类的封装性、数据的访问权限和代码的可见性，提高程序的安全性和可维护性。

36. &操作符和&&操作符有什么区别? (重点)

在Java中，&操作符和&&操作符都用于进行逻辑与（AND）操作，但它们在使用和功能上有一些区别。

1. 运算规则：
   • &操作符执行按位与操作，它对两个操作数的每个比特位进行逻辑与运算，并返回结果。
   • &&操作符执行短路与操作，它只有在第一个操作数为true时才会对第二个操作数进行求值，并返回结果。
2. 结果类型：
   • &操作符对于boolean类型的操作数，返回的结果仍是boolean类型。
   • &&操作符对于boolean类型的操作数，返回的结果仍是boolean类型。
3. 短路特性：
   • &操作符在执行时，无论第一个操作数的值是true还是false，都会对第二个操作数进行求值。
   • &&操作符在执行时，只有在第一个操作数为true时，才会对第二个操作数进行求值。如果第一个操作数为false，则不会对第二个操作数进行求值，直接返回false。
4. 应用场景：
   • &操作符常用于进行位操作，例如对两个整数的比特位进行逻辑与运算。
   • &&操作符常用于条件判断，例如在if语句中，可以根据条件的短路特性来避免不必要的计算或方法调用。

下面是一个示例：

int a = 5, b = 10;
boolean result1 = (a > 0) & (b > 0);  // 按位与操作，结果为true
boolean result2 = (a > 0) && (b > 0); // 短路与操作，结果为true
System.out.println(result1); // 输出: true
System.out.println(result2); // 输出: true

在上面的示例中，由于a和b的值都大于0，所以无论是&操作符还是&&操作符，最终的结果都为true。但如果条件不满足，&&操作符将会在第一个操作数为false时直接返回false，不再对第二个操作数进行求值，这种短路特性可以提高程序的效率。

37. 声明变量和定义变量有什么不同？

在编程中，声明变量和定义变量是两个不同的概念：

1. 声明变量：声明变量是指在代码中告诉编译器有一个变量将被使用，但并不为其分配内存空间或赋予初始值。声明变量的目的是为了让编译器知道该变量的名称和类型，以便在后续的代码中使用。在声明变量时，可以使用关键字（如int、String等）和变量名来指定变量的类型和名称。

示例：

int num;
String name;

在上述示例中，我们声明了一个整型变量 num 和一个字符串变量 name ，但并没有为它们分配内存空间或赋予初始值。

2. 定义变量：定义变量是指在声明变量的同时，为其分配内存空间并赋予初始值。定义变量包括声明变量的过程，并且为变量分配了内存空间，以便在程序运行时存储数据。在定义变量时，除了指定变量的类型和名称外，还可以为其赋予初始值。

示例：

int num = 10;
String name = "John";

在上述示例中，我们定义了一个整型变量 num 并赋予初始值10，以及一个字符串变量 name 并赋予初始值"John"。

总结：
声明变量是指告诉编译器有一个变量将被使用，但并不为其分配内存空间或赋予初始值；定义变量是在声明变量的同时，为其分配内存空间并赋予初始值。在实际编程中，通常会将声明和定义合并在一起，即同时指定变量的类型、名称和初始值。

38. 你怎么理解变量？

变量是程序中用于存储和表示数据的一种命名的内存区域。它们用于临时存储程序中需要处理的各种值，可以是数字、文字、对象引用等各种类型的数据。在程序中，我们可以通过变量名来访问和操作这些存储的数据。

在Java中，变量具有以下几个重要的特点：

1. 命名：每个变量都有一个唯一的标识符（变量名），用来标识和引用它。变量名可以由字母、数字、下划线和美元符号组成，但不能以数字开头，并且对大小写敏感。
2. 类型：变量具有预定义的数据类型，例如整数类型int、浮点数类型float、字符类型char等。变量的类型决定了它能够存储的值的种类和范围。
3. 内存空间：每个变量在内存中都有一块空间用于存储其值。变量的值可以在程序的执行过程中发生变化。
4. 赋值和访问：变量的值可以通过赋值操作进行初始化或修改。赋值操作使用赋值运算符（=）来将一个值存储到变量中。访问变量时，可以使用变量名来获取其存储的值。
5. 作用域：变量具有作用域，即其在程序中的可见范围。在不同的作用域中，可以使用相同的变量名来表示不同的变量。通常，变量的作用域由它的声明位置决定。
   变量在程序中起到了存储和传递数据的作用，使得程序可以根据不同的需求动态地处理和操作数据。通过合理地使用变量，我们可以提高程序的灵活性、可读性和可维护性。

39. 怎么判断数组是 null 还是为空?

在Java中，可以使用以下方法来判断一个数组是null还是为空：

1. 判断是否为null：使用==操作符来检查数组是否为null。如果数组变量的值为null，表示数组未被实例化或引用了一个null对象。

   int[] arr = null;
   if (arr == null) {
       System.out.println("数组为空");
   }

在上述示例中，arr数组变量的值为null，因此输出结果为"数组为空"。

2. 判断是否为空：使用length属性来检查数组的长度是否为0。如果数组的长度为0，表示数组已经被实例化了，但没有元素。

   int[] arr = new int[0];
   if (arr.length == 0) {
       System.out.println("数组为空");
   }

在上述示例中，arr数组被实例化了，但没有任何元素，所以输出结果为"数组为空"。
需要注意的是，判断数组为空使用的是arr.length == 0，而不是arr == null。因为当数组实例化后，即使没有元素，数组的值也不会是null，而是一个引用的内存地址。因此，这两者的判断条件是不同的，需要根据具体的情况选择适当的判断方式。

40. Java 中的“短路”是指什么？

在Java中，"短路"是指在逻辑运算中，当使用逻辑与（&&）和逻辑或（||）操作符时，如果对于得到最终结果而言，已经可以确定整个表达式的值，则不再继续对后续的操作数进行求值。

具体来说，"短路"的逻辑规则如下：

• 对于逻辑与（&&）操作符：
  • 如果第一个操作数为false，则整个表达式的值一定为false，不再继续对后续操作数进行求值，直接返回false。
  • 只有当第一个操作数为true时，才会对第二个操作数进行求值，如果第二个操作数为true，则整个表达式的值为true，否则为false。
• 对于逻辑或（||）操作符：
  • 如果第一个操作数为true，则整个表达式的值一定为true，不再继续对后续操作数进行求值，直接返回true。
  • 只有当第一个操作数为false时，才会对第二个操作数进行求值，如果第二个操作数为true，则整个表达式的值为true，否则为false。
    这种"短路"的机制有助于提高程序的性能和效率，因为它避免了不必要的计算或方法调用。在某些情况下，我们可以利用"短路"特性来简化代码并防止出现可能导致异常的情况。
    下面是一个示例：

int x = 5;
int y = 10;
if (x > 0 && y / x > 2) {
    System.out.println("条件成立");
} else {
    System.out.println("条件不成立");
}

在上述示例中，判断条件为x > 0 && y / x > 2。由于短路与操作符的特性，当x的值为负数时，即使后面的表达式会导致除零错误，也不会发生，因为第一个操作数为false，整个表达式的值已经确定为false。这样可以避免抛出异常，并且输出结果为"条件不成立"。

41. switch 语句能否作用在 byte 上,能否作用在 long 上,能否作用在 String 上? (重点)

在Java中，switch语句可以用于操作byte、short、char、int类型的数据。但在Java 7及以后的版本中，switch语句也可以用于String类型。
具体来说：

1. byte类型：可以在switch语句中使用byte类型的表达式。

   byte x = 2;
   switch (x) {
       case 1:
           // 执行操作1
           break;
       case 2:
           // 执行操作2
           break;
       default:
           // 执行默认操作
   }

2. long类型：在Java中，long类型不能直接用于switch语句。因为switch语句的限制是表达式的类型必须是byte、short、char或int。如果要在switch语句中操作long类型的数据，可以将其转换为适用于switch语句的整数类型（如int）。

   long x = 2L;
   int y = (int) x;
   switch (y) {
       case 1:
           // 执行操作1
           break;
       case 2:
           // 执行操作2
           break;
       default:
           // 执行默认操作
   }

3. String类型：在Java 7及以后的版本中，switch语句可以使用String类型的表达式。

   String str = "hello";
   switch (str) {
       case "hello":
           // 执行操作1
           break;
       case "world":
           // 执行操作2
           break;
       default:
           // 执行默认操作
   }

需要注意的是，switch语句在比较表达式的值时，使用的是equals()方法进行比较而不是==运算符。因此，String类型的switch语句可用于基于字符串的条件分支控制。

42. short s = 1; s = s + 1;有什么错? short s = 1; s += 1;有什么错? (重点)

在Java中，short s = 1; s = s + 1;和short s = 1; s += 1;两行代码中都存在数据类型转换错误。

具体解释如下：

1. short s = 1; s = s + 1;中的表达式s = s + 1;会导致错误。这是因为+运算符会自动将表达式中的操作数转换为int类型进行计算，而+运算的结果是int类型，无法直接赋值给short类型的变量。所以，需要进行强制类型转换才能将结果赋值给short类型的变量。

   short s = 1;
   s = (short) (s + 1);

2. short s = 1; s += 1;中的表达式s += 1;没有错误。这是因为+=运算符会先进行自动类型转换，将右侧的操作数1转换为与左侧变量类型相同的类型（即short），然后再进行相加赋值操作。所以，不需要显式进行强制类型转换。

总结起来，由于Java中对于+运算符和+=运算符的处理方式不同，导致了在对short类型进行加法运算时的不同结果。在使用+运算符时，需要进行强制类型转换；而在使用+=运算符时，会自动进行类型转换，无需显式转换。这种差异是为了避免数据丢失或溢出，并确保程序的正确性。

43. char 型变量中能不能存贮一个中文汉字?为什么? (重点)

在Java中，char类型的变量可以存储Unicode字符，包括中文汉字。因为Java中的字符编码采用Unicode编码，它支持全球范围内的字符集，包括不同语言的字符，如中文、英文、日文等。

Unicode字符集为每个字符分配了一个唯一的整数码点，而char类型就是用来表示Unicode字符的。char类型变量在内存中占用2个字节（16位），足以存储一个Unicode字符。

下面是一个示例，演示了如何在char类型的变量中存储中文汉字：

char chineseChar = '中';
System.out.println(chineseChar);  // 输出: 中

在上述示例中，char类型的变量chineseChar存储了中文汉字"中"，并成功地打印出来。

需要注意的是，如果在源代码文件中直接使用中文汉字作为字符常量，为了避免编码问题，建议在源代码文件的开头指定使用的字符集，如UTF-8。这样可以确保源代码中的中文字符正确地被解析和存储。

// 指定源代码文件的字符集为UTF-8
public class Main {
    public static void main(String[] args) {
        char chineseChar = '中';
        System.out.println(chineseChar);  // 输出: 中
    }
}

总结起来，char类型的变量可以存储任何Unicode字符，包括中文汉字。这是因为Java使用Unicode编码来表示字符，保证了字符的普适性和多语言支持。

44. 冒泡排序实现(重点)

冒泡排序是一种简单的排序算法，它的基本思想是通过相邻元素之间的比较和交换，将最大（或最小）的元素逐渐“冒泡”到序列的一端。

下面是冒泡排序的实现代码：

public class BubbleSort {
    public static void bubbleSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    // 交换两个元素
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] array = {5, 2, 8, 12, 1, 6};
        System.out.println("排序前的数组：");
        for (int num : array) {
            System.out.print(num + " ");
        }
        bubbleSort(array);
        System.out.println("\n排序后的数组：");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

以上代码实现了冒泡排序算法。在bubbleSort方法中，使用两个嵌套的循环进行相邻元素的比较和交换，通过多次迭代将较大的元素不断向右“冒泡”。外层循环控制迭代的次数，内层循环进行每一轮的比较和交换。

在main方法中，我们定义了一个整型数组array并初始化。然后调用bubbleSort方法对数组进行排序，并输出排序前后的数组元素。

以上代码的输出结果为：

排序前的数组：
5 2 8 12 1 6 
排序后的数组：
1 2 5 6 8 12 

可以看到，冒泡排序算法成功将数组中的元素从小到大进行了排序。需要注意的是，冒泡排序是一种简单但效率较低的排序算法，对于大规模数据排序不是很适用。

45. "=="和 equals 方法究竟有什么区别？(重点)

"=="和equals方法是Java中用于比较对象的两种方式，它们的区别如下：

1. "=="运算符用于比较两个对象的引用是否相等，即判断两个对象是否为同一个对象。对于基本数据类型，比较的是它们的值；对于引用类型，比较的是它们的内存地址。当两个对象的引用指向同一个内存地址时，返回true；否则返回false。

示例代码：

   String str1 = "hello";
   String str2 = "hello";
   String str3 = new String("hello");
   System.out.println(str1 == str2);  // 输出: true，因为str1和str2引用同一个字符串常量
   System.out.println(str1 == str3);  // 输出: false，因为str1和str3引用不同的对象

2. equals方法是Object类中定义的方法，用于比较两个对象的内容是否相等，默认行为与"=="运算符相同，即比较两个对象的引用。但是，可以根据需要重写equals方法，实现自定义的比较逻辑。通常需要重写equals方法时，还应该重写hashCode方法来维护对象的一致性。

示例代码：

   String str1 = "hello";
   String str2 = "hello";
   String str3 = new String("hello");
   System.out.println(str1.equals(str2));  // 输出: true，因为String类已重写equals方法，比较的是字符串内容
   System.out.println(str1.equals(str3));  // 输出: true，因为字符串内容相同，重写的equals方法比较内容

需要注意：

• 对于基本数据类型（如int、char等），"=="比较的是它们的值，不存在对象引用的问题。
• 在使用自定义类时，如果没有重写equals方法，则使用默认实现，即比较对象的引用。如果想要按照自定义逻辑进行比较，就需要重写equals方法。

总结起来，"=="运算符比较的是对象的引用，而equals方法比较的是对象的内容。通常情况下，我们更倾向于使用equals方法来比较对象的内容，特别是在自定义类中重写equals方法以实现自定义的比较逻辑。

46. 静态变量和实例变量的区别？

静态变量（static variable）和实例变量（instance variable）是两种不同类型的变量，它们在作用域和生命周期等方面有所区别。

1. 定义和作用域：

   • 静态变量：使用static关键字修饰，属于类级别的变量，不属于具体的对象实例。在类加载的时候被创建，且在整个程序的执行过程中只有一份拷贝。可以通过类名直接访问静态变量。
   • 实例变量：定义在类中方法之外的变量，属于对象级别的变量。每个类的对象都会拥有一份实例变量的副本。需要通过对象实例来访问实例变量。

2. 内存分配：

   • 静态变量：存储在静态存储区，即类加载的过程中被分配和初始化，直到程序结束才被销毁。
   • 实例变量：与对象一起分配在堆内存中，当对象被创建时，实例变量也会被初始化，当对象不再被引用时，实例变量的内存会被回收。

3. 生命周期：

   • 静态变量：在程序的整个运行过程中存在，即使没有创建类的实例，也可以通过类名访问。
   • 实例变量：随着对象的创建和销毁而存在和销毁，每个对象的实例变量独立存在，互不影响。

4. 访问方式：

   • 静态变量：可以通过类名直接访问，也可以通过对象实例访问。
   • 实例变量：必须通过对象实例来访问。

示例代码：

public class MyClass {
    static int staticVariable;  // 静态变量
    int instanceVariable;       // 实例变量
    
    public static void main(String[] args) {
        MyClass.staticVariable = 10;  // 通过类名访问静态变量
        
        MyClass obj1 = new MyClass();
        obj1.instanceVariable = 20;   // 通过对象实例访问实例变量

        MyClass obj2 = new MyClass();
        obj2.instanceVariable = 30;
        
        System.out.println(MyClass.staticVariable);   // 输出: 10
        System.out.println(obj1.instanceVariable);    // 输出: 20
        System.out.println(obj2.instanceVariable);    // 输出: 30
    }
}

总结：
静态变量属于类级别的变量，在内存中只有一份拷贝，可以通过类名直接访问。实例变量属于对象级别的变量，每个对象都会拥有一份副本，需要通过对象实例来访问。静态变量与实例变量在生命周期、作用域和访问方式上都有所不同，适合不同的使用情景。

47. 谈谈你对 static 关键词的理解(重点)

static是Java中的一个关键字，可以应用于变量、方法和代码块等地方。它表示某个成员属于类本身，而不是类的实例对象。下面是对static关键字的一些理解：

1. 静态变量（static variable）：

   • 静态变量属于类级别，在类加载的时候被创建并初始化，整个程序的执行过程中只有一份拷贝。
   • 静态变量被所有类的实例对象共享，在任何对象实例创建之前就可以通过类名直接访问。
   • 静态变量通常用于表示与类相关的永久性数据，如常量、配置信息等。

2. 静态方法（static method）：

   • 静态方法属于类级别，不依赖于特定的对象实例而存在。
   • 静态方法可以直接通过类名调用，而不需要创建类的对象实例。
   • 静态方法只能调用其他的静态方法或静态变量，而不能直接访问非静态成员（实例变量、非静态方法等）。

3. 静态代码块（static block）：

   • 静态代码块用于在类加载时执行一些初始化操作，只会执行一次。
   • 静态代码块在类的静态变量初始化之后执行，在其他代码块和构造方法之前执行。

4. 静态内部类（static inner class）：

   • 静态内部类与普通内部类的主要区别是，静态内部类不依赖于外部类的实例对象而存在，可以直接使用。
   • 静态内部类只能访问外部类的静态成员，而不是外部类的实例成员。

5. 静态导入（static import）：

   • 静态导入用于导入一个类中的静态成员（变量或方法），使得在使用时可以直接使用静态成员名，而无需使用类名限定。

在使用static关键字时，需要注意以下几点：

• 静态成员在内存中只有一份拷贝，共享给所有对象实例。
• 静态成员不能直接访问非静态成员，但非静态成员可以访问静态成员。
• 静态成员与实例成员之间的调用存在限制。
• 静态成员的生命周期长于对象实例，直到程序结束才会销毁。

总结：static关键字用于表示成员属于类本身，而不是类的实例对象。静态成员在内存中共享，可以通过类名直接访问。它们在各种场景中提供了更灵活的编程方式和使用方式。

48. 是否可以从一个 static 方法内部发出对非 static 方法的调用？

是的，可以从一个static方法内部发出对非static方法的调用。但是，需要通过对象实例来调用非静态方法。

在静态方法中调用非静态方法时，需要先创建一个对象实例，然后使用该对象实例来调用非静态方法。因为非静态方法是属于对象实例的，只有对象实例存在时才能够调用。

下面是一个示例代码：

public class MyClass {
    public static void staticMethod() {
        // 静态方法内部调用非静态方法
        MyClass obj = new MyClass();
        obj.nonStaticMethod();
    }

    public void nonStaticMethod() {
        System.out.println("非静态方法被调用");
    }

    public static void main(String[] args) {
        // 静态方法直接调用
        staticMethod();
    }
}

在上述代码中，staticMethod()是一个静态方法，它通过创建MyClass的对象实例obj，然后调用obj.nonStaticMethod()来调用非静态方法nonStaticMethod()。

需要注意的是，在静态方法中不能直接调用非静态方法，因为静态方法与对象实例无关，无法直接访问非静态成员。而在非静态方法中可以直接调用静态方法或访问静态变量。

49. Integer 与 int 的区别(重点)

Integer和int是Java中的两种数据类型，它们有以下区别：

1. 类型：

   • Integer是一个封装类（Wrapper Class），对应于Java中的整数数据类型int的包装类。
   • int是Java的基本数据类型，用于表示整数值。

2. 值范围：

   • int的取值范围较大，为-2,147,483,648到2,147,483,647。
   • Integer是一个对象，其值范围和int相同。

3. 可空性：

   • int是基本数据类型，它不能为null，即不存在null值。
   • Integer是一个对象，可以为null。可以使用Integer类中的静态方法valueOf()将int转换为Integer时，如果传入null，会得到一个null值的Integer对象。

4. 自动装箱和拆箱：

   • Integer可以通过自动装箱（Autoboxing）和拆箱（Unboxing）与int互相转换。
   • 自动装箱是指将基本数据类型自动转换为对应的封装类对象，而自动拆箱则是相反的操作。

5. 使用方式：

   • int适合在计算过程中使用，因为它是基本数据类型，不需要执行额外的方法调用。
   • Integer适合在需要将整数值作为对象使用的场景中，因为它提供了更多的功能，比如在集合中存储、作为方法参数等。

示例代码：

int num1 = 10;                   // 声明一个 int 变量
Integer num2 = new Integer(20);  // 声明一个 Integer 对象
Integer num3 = Integer.valueOf(30);  // 使用 valueOf() 方法创建 Integer 对象

int sum = num1 + num2;           // 自动拆箱，将 Integer 对象转换为 int
Integer result = num1 + num2;    // 自动装箱，将 int 转换为 Integer 对象

总结：Integer是int的包装类，int是基本数据类型。它们的主要区别在于可空性、自动装箱和拆箱以及使用方式。选择使用哪个类型取决于具体的需求和场景。在需要将整数值作为对象使用，或者需要使用null来表示特定状态时，可以选择使用Integer；而在计算过程中，可以选择使用int。在需要将两者相互转换时，可以通过自动装箱和拆箱来实现。

50. Math.round(11.5)等于多少? Math.round(-11.5)等于多少?

Math.round(11.5)等于12，Math.round(-11.5)等于-11。

Math.round()是Java中的一个数学函数，用于将一个浮点数四舍五入为最接近的整数。具体的规则如下：

• 当参数为正数时，如果小数部分大于等于0.5，返回最接近的较大整数；否则，返回最接近的较小整数。
• 当参数为负数时，如果小数部分大于等于-0.5，返回最接近的较大整数；否则，返回最接近的较小整数。

因此，Math.round(11.5)中的小数部分0.5大于等于0.5，所以结果为12。而Math.round(-11.5)中的小数部分-0.5小于-0.5，所以结果为-11。

需要注意的是，Math.round()返回的结果是一个long类型的整数。如果需要获取一个四舍五入后的整数，可以将结果强制转换为int类型。例如：

double num1 = 11.5;
double num2 = -11.5;

int roundedNum1 = (int) Math.round(num1);
int roundedNum2 = (int) Math.round(num2);

System.out.println(roundedNum1);  // 输出：12
System.out.println(roundedNum2);  // 输出：-11

51. 请说出作用域 public,private,protected,以及不写时的区别(重点)

在Java中，作用域（访问修饰符）用于控制类、变量、方法和构造函数的可访问性。Java中的作用域包括以下几种：

1. public：在Java中，被声明为public的成员可以被任何其他类访问。即使在不同的包中，只要类是公共的，都可以访问该成员。

2. private：private是最严格的访问修饰符。被声明为private的成员只能在同一个类中访问。其他类无法直接访问private成员，包括子类。

3. protected：protected修饰符允许子类访问该成员，即使子类在不同的包中。被声明为protected的成员在同一个包中的其他类中也是可访问的。

4. 不写时（默认）：如果不写任何访问修饰符，即默认情况下，该成员的访问权限将限定在同一个包中。对于类而言，如果没有指定访问修饰符，它将具有默认访问权限。

下面是一个示例代码，演示了不同访问修饰符的使用：

public class MyClass {
    public int publicVar;         // public 变量
    private int privateVar;       // private 变量
    protected int protectedVar;   // protected 变量
    int defaultVar;               // 默认访问修饰符

    public void publicMethod() {
        // public 方法
    }

    private void privateMethod() {
        // private 方法
    }

    protected void protectedMethod() {
        // protected 方法
    }

    void defaultMethod() {
        // 默认方法
    }
}

public class AnotherClass {
    public static void main(String[] args) {
        MyClass myObj = new MyClass();
        myObj.publicVar = 10;            // 可以访问 public 变量
        myObj.privateVar = 20;           // 无法访问 private 变量
        myObj.protectedVar = 30;         // 无法访问 protected 变量
        myObj.defaultVar = 40;           // 可以访问默认变量

        myObj.publicMethod();            // 可以调用 public 方法
        myObj.privateMethod();           // 无法调用 private 方法
        myObj.protectedMethod();         // 无法调用 protected 方法
        myObj.defaultMethod();           // 可以调用默认方法
    }
}

总结：

• public修饰符允许在任何地方访问。
• private修饰符只允许在同一个类内部访问。
• protected修饰符允许在同一类、同一包、不同包的子类中访问。
• 不写访问修饰符时，默认为包级可访问，即同一包内可访问。

52. Java 是否有过程和函数?

在Java中，有函数（methods），但没有过程（procedures）的概念。

函数（methods）是一种有返回值的代码块，用于执行特定的任务。在Java中，函数被声明在类中，并通过对象或类名进行调用。函数可以接受参数，并根据给定的输入执行一系列操作后返回一个值。函数可以被重复使用，并且可以在不同的地方进行调用。

例如，下面是一个计算两个整数之和的函数示例：

public class Calculator {
    public int add(int num1, int num2) {
        int sum = num1 + num2;
        return sum;
    }
    
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        int result = calculator.add(5, 10);
        System.out.println(result);  // 输出：15
    }
}

过程（procedures）是一种不返回值的代码块，仅用于执行特定的任务。在其他编程语言中，如Pascal和Python，过程是一种独立的概念，用于执行一系列操作而不返回任何值。但在Java中，没有专门的过程概念。如果一个函数不需要返回值，可以将其返回类型声明为void，表示没有返回值。

例如，下面是一个打印Hello的过程（实际上是一个没有返回值的函数）的示例：

public class HelloWorld {
    public void sayHello() {
        System.out.println("Hello");
    }
    
    public static void main(String[] args) {
        HelloWorld hello = new HelloWorld();
        hello.sayHello();  // 输出：Hello
    }
}

所以，尽管Java没有过程的特殊概念，但我们可以通过声明返回类型为void的函数来实现类似过程的效果。

53. String 和 StringBuffer 的区别(重点)

在Java中，String和StringBuffer都表示可变的字符序列，但它们有一些重要的区别。

1. 不可变性:

   • String是不可变的，即一旦创建，就无法修改。每次对String的操作，都会创建一个新的String对象。这意味着对字符串执行拼接、替换、删除等操作时，实际上是创建了新的String对象，原始的String对象并没有改变。
   • StringBuffer是可变的，可以随时修改。对StringBuffer执行拼接、替换、删除等操作时，不会创建新的对象，而是直接在原始的StringBuffer对象上进行修改。

2. 线程安全性:

   • String是线程安全的，因为它是不可变的。多个线程可以同时访问相同的String对象，而不会发生竞争条件（race condition）。
   • StringBuffer是线程安全的，因为它的方法被synchronized关键字修饰，保证了多个线程在访问StringBuffer对象时的同步性。这种同步性会带来一定的性能开销。

3. 性能:

   • 由于String是不可变的，对它进行大量的拼接、替换、删除等操作会产生大量的临时对象，影响性能。
   • StringBuffer是可变的，对它进行拼接、替换、删除等操作是原地修改，不会创建大量的临时对象，性能较好。

基于以上区别，应根据不同的需求选择使用String或StringBuffer：

• 当需要拼接、替换、删除等操作时，尤其是在一个循环或迭代中执行这些操作，建议使用StringBuffer，以避免频繁创建临时对象和提高性能。
• 当不需要修改字符串内容时，或仅进行少量操作时，使用String更为简洁并且安全。

需要注意的是，在Java
5及以后的版本中，引入了StringBuilder，它与StringBuffer类似，但没有线程安全的保证。因此，对于单线程环境下的字符串操作，StringBuilder是更好的选择。

54. StringBuffer 与 StringBuilder 的区别(重点)

在Java中，StringBuffer和StringBuilder都用于可变的字符序列，它们有相似的功能，但也存在一些重要的区别。

1. 线程安全性：

   • StringBuffer是线程安全的，它的方法被synchronized关键字修饰，确保多个线程在访问StringBuffer对象时的同步性。因此，多个线程可以同时访问和修改StringBuffer对象。
   • StringBuilder不是线程安全的，它的方法没有进行同步处理。因此，在多线程环境下，如果需要对可变字符序列进行操作，应该使用StringBuffer以保证线程安全性。

2. 性能：

   • 由于StringBuffer是线程安全的，它的方法都进行了同步处理。这种同步性会带来一定的性能开销，尤其在高并发环境下。因此，StringBuffer的性能比较低于StringBuilder。
   • StringBuilder不具备线程安全的特性，它的方法没有进行同步处理。因此，在单线程环境下，StringBuilder的性能要优于StringBuffer，因为不需要进行同步操作。

3. 应用场景：

   • 如果在多线程环境下需要对可变的字符序列进行操作，应该使用StringBuffer以保证线程安全性。
   • 如果在单线程环境下进行字符串的拼接、替换、删除等操作，使用StringBuilder能获得更好的性能。

总结：

• 如果需要线程安全性，或者在多线程环境下进行字符串操作，应该使用StringBuffer。
• 如果不需要线程安全性，或者在单线程环境下进行字符串操作，可以使用StringBuilder以获得更好的性能。

需要注意的是，StringBuffer和StringBuilder在使用方法上基本相同，它们都提供了相似的API，可以方便地进行字符串的修改操作。

55. 数组有没有 length( )这个方法? String 有没有 length( )这个方法？

在Java中，数组和String都有length()方法，但使用方式略有不同。

1. 数组的length属性：

   • 数组是一组相同类型的数据的集合，可以通过length属性来获取数组的长度，表示数组中元素的数量。length是一个属性而不是方法，因此没有括号。
   • 例如，对于一个整型数组 int[] arr，可以通过 arr.length 来获取该数组的长度。

2. 字符串的length()方法：

   • String 是一个不可变的字符序列，使用length()方法来获取字符串的长度，即字符串中字符的个数。
   • length()是一个方法，需要在后面加上括号进行调用。
   • 例如，对于一个字符串变量 String str = "Hello"，可以通过 str.length() 来获取字符串的长度。

需要注意的是，数组的长度是一个固定值，一旦创建就不能改变。而字符串的长度可以随着字符串内容的修改而改变。

以下是使用示例：

int[] numbers = {1, 2, 3, 4, 5};
int length = numbers.length;
System.out.println(length);  // 输出：5

String str = "Hello";
int strLength = str.length();
System.out.println(strLength);  // 输出：5

无论是数组还是字符串，length属性和length()方法都是用于获取对象的长度或大小。

56. 使用 final 关键字修饰一个变量时,是引用不能变,还是引用的对象不能变？

当使用 final 关键字修饰一个变量时，被修饰的变量变为一个常量，并且有两种情况：

1. 引用不能变：

   • 如果 final 修饰的是一个引用变量，那么该变量的引用不能改变，即指向的对象不能改变。
   • 也就是说，在使用 final 修饰一个引用变量后，不能对该引用变量重新赋值引用到其他对象。

2. 引用的对象不能变：

   • 如果 final 修饰的是一个引用变量所指向的对象（非基本数据类型），那么该引用的对象本身不能被改变。
   • 也就是说，被 final 修饰的引用变量所指向的对象的状态（成员变量）不能被修改，但可以调用对象的方法进行操作。

下面分别举例说明这两种情况：

1. 引用不能变的示例：

   final int a = 10;
   // a = 20;  // 编译错误：无法重新分配值
   

2. 引用的对象不能变的示例：

   class Person {
       String name;
   }
   
   final Person person = new Person();
   // person = new Person();  // 编译错误：无法重新分配值
   person.name = "John";  // 可以修改对象的状态
   

总结：

• 使用 final 修饰一个引用变量时，表示该引用不能改变，即不能指向其他对象。
• 使用 final 修饰一个引用变量所指向的对象时，表示对象本身的状态（成员变量）不能被修改，但可以调用对象的方法进行操作。

57. 类与对象的关系是什么?

类与对象是面向对象编程中的两个重要概念，并且存在着一种包含与实例化的关系。

• 类（Class）是对一类事物的抽象描述，它定义了事物的属性和行为。类是对对象的一种抽象，是创建对象的模板。

• 对象（Object）是类的实例化结果，它是具体的实体，具有类定义的属性和行为。对象是根据类的模板创建出来的，每个对象都是独立的，拥有自己的状态和行为。

类与对象的关系可以理解为模板和具体实例的关系：

1. 类是对对象的抽象描述，它定义了对象应该具有的属性和行为，并提供了创建对象的模板。类可以看作是一类对象的共同特征的概括，是创建对象的蓝图。

2. 对象是类的实例化结果，它是根据类的模板创建出来的具体实体。每个对象都是独立的，具有自己的属性值和行为细节。

通过类，可以创建多个对象，而每个对象都具有相同的属性和行为，但属性的值可以不同。类是对象的抽象，而对象是类的具体化。

例如，可以将类比作是汽车的设计图纸，而对象就是根据这个设计图纸制造出来的真实汽车。设计图纸描述了汽车的特征和行为，而每个制造出来的汽车是具有独立特征的实体。

总结：

• 类是对一类事物的抽象描述，定义了事物的属性和行为。
• 对象是根据类的模板创建出来的具体实例，具有类定义的属性和行为。
• 类是对象的抽象，而对象是类的具体化。通过类可以创建多个具有相同属性和行为的不同对象。

58. 什么是封装？

封装（Encapsulation）是面向对象编程的一个重要概念，它是指将数据和对数据的操作（方法）封装在一个类中，隐藏内部实现细节，对外部提供访问和使用数据的接口。

• 封装的目的是将数据操作的细节隐藏在类的内部，避免外部直接访问和修改类中的数据，保证数据的安全性和完整性。外部只能通过类提供的公共接口来访问和操作数据，而不能直接操作数据。

• 封装的关键在于将数据定义为私有（private）的，只能在类内部访问，而提供公共的方法（getter和setter）来间接访问和修改数据。这样一来，类的设计者可以对数据进行各种限制和验证，确保数据的有效性和一致性。

封装的优点有：

1. 数据隐藏：封装将类的内部实现细节隐藏起来，不需要关心具体的实现，只需要调用公共接口即可。
2. 提高安全性：封装可以防止外部直接对类的数据进行修改，需要通过公共接口来访问和修改数据，可以对数据进行验证和限制。
3. 提高代码复用性：通过定义公共接口，可以实现类的复用，其他类可以直接使用公共接口进行交互，而不需要了解具体实现细节。
4. 降低耦合度：封装将类的内部实现细节与外部隔离开来，减少了类与类之间的依赖，降低了耦合度，提高了系统的可维护性和扩展性。

封装是面向对象编程的一个核心原则，它帮助我们构建更加安全、健壮和可维护的代码。

59. this 关键字

this 是一个关键字，用于表示当前对象的引用。它可以在类的成员方法中使用，代表调用该方法的当前对象。

this 关键字主要有以下几种用途：

1. 引用当前对象：

   • 在类的实例方法中，可以使用 this 关键字来引用调用该方法的当前对象。
   • 例如，可以使用 this 来访问当前对象的成员变量或调用当前对象的其他方法。

2. 区分局部变量和成员变量：

   • 当局部变量和成员变量名称相同时，可以使用 this 关键字来区分。
   • 在方法内部，this.成员变量名 表示当前对象的成员变量，而不是局部变量。

3. 在构造方法中调用其他构造方法：

   • 当一个类有多个构造方法时，可以使用 this 关键字在一个构造方法中调用其他构造方法。
   • 通过使用 this(参数列表) 可以调用同一个类中的其他构造方法，并且必须位于构造方法的第一行。

总结：

• this 关键字表示当前对象的引用。
• 在类的实例方法中，可以使用 this 来引用调用该方法的当前对象。
• 用于区分局部变量和成员变量，当名称相同时，this.成员变量名 表示当前对象的成员变量。
• 在构造方法中，可以使用 this(参数列表) 调用同一个类中的其他构造方法。

当使用 this 关键字时，可以根据具体的应用场景有不同的用法。下面列举几种常见的使用情况：

1. 引用当前对象的成员变量：

   public class MyClass {
       private int myVariable;
       
       public void setMyVariable(int value) {
           this.myVariable = value;  // 使用 this 引用当前对象的成员变量
       }
   }

2. 调用当前对象的其他方法：

   public class MyClass {
       public void method1() {
           // 调用 method2 方法
           this.method2();
       }
       
       public void method2() {
           // 方法的具体实现
       }
   }

4. 在构造方法中调用其他构造方法：

   public class MyClass {
       private int value;
       
       // 构造方法1
       public MyClass() {
           this(0);  // 调用另一个构造方法，并传递参数
       }
       
       // 构造方法2
       public MyClass(int value) {
           this.value = value;  // 使用 this 引用当前对象的成员变量
       }
   }

4. 区分局部变量和成员变量：

   public class MyClass {
       private int value;
       
       public void setValue(int value) {
           // 使用 this 来指定成员变量
           this.value = value;
       }
   }

注意事项：

• this 关键字只能在非静态方法（实例方法）中使用，因为静态方法没有隶属于任何对象。
• 在某些情况下，可以省略 this 关键字，尤其是在没有命名冲突的情况下。但为了代码的清晰和易读性，建议使用 this 关键字明确指定当前对象。
• this 关键字不能在静态上下文中使用。

60. 什么是继承？

继承（Inheritance）是面向对象编程中的一个重要概念，它允许一个类（称为子类或派生类）从另一个类（称为父类或基类）继承属性和方法。通过继承，子类可以共享父类的特性，并且可以在此基础上进行扩展或修改。

继承的关系可以描述为一种“是一个”（is-a）的关系，子类是父类的特殊类型或子集。

继承具有以下特点：

1. 子类继承父类的特性：

   • 子类可以继承父类的字段（成员变量）和方法，无需重复编写相同的代码。
   • 子类可以直接访问父类的非私有成员（public、protected、default）。

2. 子类可以拥有自己的特性：

   • 子类可以在继承父类的基础上，新增或重写父类的字段和方法，实现自己的特定功能。
   • 子类可以新增其他字段和方法。

3. 继承形成类的层次结构：

   • 通过多级继承，可以形成类的层次结构，建立类之间的关系。

继承的优点有：

1. 代码复用：子类可以继承父类的代码，避免重复编写相同的代码，提高代码复用性和开发效率。

2. 提高可扩展性：通过继承，可以在不修改父类代码的情况下，对子类进行扩展，实现新的功能，使系统更加灵活和可扩展。

3. 统一接口：通过继承，可以将多个类共有的属性和方法放在父类中，使得操作这些类的对象时具有一致的接口。

需要注意以下几点：

1. Java 中只支持单继承：一个类只能继承自一个父类，但可以通过接口实现多继承的效果。

2. 继承关系的访问权限：子类可以访问父类的非私有成员，但父类的私有成员对子类是不可见的。

总结：

• 继承允许子类从父类继承字段和方法，并可以在此基础上进行扩展或修改。
• 继承形成了类的层次结构，通过多级继承建立类与类之间的关系。
• 继承具有代码复用、提高可扩展性和统一接口的优点。
• Java 中只支持单继承，但可以通过接口实现多继承的效果。

61. Overload 和 Override 的区别.Overload 的方法是否可以改变返回值的类型? (重点)

Overload和Override是Java中的两个重要概念，它们有以下区别：

1. Overload（重载）：指在同一个类中，可以有多个方法具有相同的名称，但参数列表不同（参数个数、类型或顺序）。重载方法可以有不同的返回值类型，但返回值类型并不是用于区分重载方法的标准。

示例：

public class MyClass {
       public void myMethod(int num) {
           // 方法实现
       }
       public void myMethod(String str) {
           // 方法实现
       }
   }

在上述示例中， myMethod 方法被重载了，分别接受一个整数参数和一个字符串参数。

2. Override（重写）：指在子类中重新定义（覆盖）父类中已有的方法。重写方法必须具有相同的名称、参数列表和返回值类型。重写方法用于改变父类方法的实现，但不能改变其返回值类型。

示例：

public class Parent {
       public void myMethod() {
           // 父类方法实现
       }
   }
   public class Child extends Parent {
       @Override
       public void myMethod() {
           // 子类重写的方法实现
       }
   }

在上述示例中， Child 类重写了 Parent 类中的 myMethod 方法。
总结：

• Overload（重载）是指在同一个类中定义多个方法，方法名相同但参数列表不同。
• Override（重写）是指在子类中重新定义父类中已有的方法，方法名、参数列表和返回值类型必须相同。
• Overload的方法可以具有不同的返回值类型，但返回值类型并不用于区分重载方法。
• Override的方法不能改变返回值类型，只能改变方法的实现。

需要注意的是，重载和重写是Java中实现多态性的两种方式，它们在不同的场景下有不同的应用。

Overload（重载）和 Override（重写）是面向对象编程中的两个重要概念，它们用于实现多态性。它们的区别如下：

1. Overload（重载）：

   • Overload 是指在同一个类中，可以定义多个方法具有相同的名称但参数列表不同（参数类型、参数个数、参数顺序）的情况。
   • Overload 允许方法具有不同的功能，但方法名必须相同。
   • Overload 是在编译时进行静态绑定，根据调用的方法参数类型来决定使用哪个方法。
   • Overload 方法的返回值类型可以相同也可以不相同。

2. Override（重写）：

   • Override 是指在子类中重新定义父类中已经存在的方法，具有相同的方法名、参数列表和返回类型。
   • Override 用于实现多态性，子类对父类的方法进行重新实现，以满足自己的需求。
   • Override 是在运行时进行动态绑定，根据实际对象类型来决定使用哪个方法。
   • Override 方法的返回值类型必须与父类的方法返回值类型相同，或者是其子类型（协变类型）。

3. Overload 的方法是否可以改变返回值的类型：

   • Overload 方法可以具有不同的返回值类型。参数列表不同是 Overload 方法的关键。
   • 返回值类型不是 Overload 方法的标识符，因此返回值类型的改变不会产生方法的重载。

总结：

• Overload 是指在同一类中声明多个方法，方法名相同但参数列表不同。
• Override 是指子类重新定义父类中已经存在的方法，方法名、参数列表和返回类型都相同。
• Overload 方法的参数列表不同，可以具有相同或不同的返回值类型。
• Override 方法的返回值类型必须与父类的方法返回值类型相同或是其子类型（协变类型）。

62. super 关键字(重点)

super关键字是Java中的一个特殊关键字，用于访问父类的成员变量、成员方法和构造方法。它可以在子类中使用，用于引用父类的成员。super关键字主要有以下几种用法：

1. 访问父类的成员变量：可以使用super关键字来访问父类中被子类隐藏的同名成员变量。使用super关键字可以在子类中访问父类的成员变量。

public class Parent {
    int num = 10;
}
 public class Child extends Parent {
    int num = 20;
     public void printNum() {
        System.out.println(num); // 输出子类的 num 变量值
        System.out.println(super.num); // 输出父类的 num 变量值
    }
}

2. 访问父类的成员方法：可以使用super关键字来调用父类中被子类重写的同名成员方法。使用super关键字可以在子类中调用父类的成员方法。

public class Parent {
    public void printMessage() {
        System.out.println("Hello from Parent");
    }
}
 public class Child extends Parent {
    @Override
    public void printMessage() {
        super.printMessage(); // 调用父类的 printMessage 方法
        System.out.println("Hello from Child");
    }
}

3. 调用父类的构造方法：可以使用super关键字来调用父类的构造方法。使用super关键字可以在子类的构造方法中调用父类的构造方法，以便完成父类的初始化。

public class Parent {
    public Parent(int num) {
        System.out.println("Parent Constructor with num: " + num);
    }
}
 public class Child extends Parent {
    public Child(int num) {
        super(num); // 调用父类的构造方法
    }
}

需要注意的是，super关键字只能在子类中使用，用于引用父类的成员。它不能在静态方法中使用，也不能用于访问父类的private成员。

super 是一个关键字，用于表示父类（基类）的引用。它可以在子类中使用，用于访问父类的成员变量、成员方法和构造方法。super 关键字的使用可以有以下几种情况：

1. 访问父类的成员变量和成员方法：

   • 在子类中，可以使用 super 关键字来访问父类的非私有成员变量和成员方法。
   • 通过 super.成员变量名 可以访问父类的成员变量，通过 super.方法名() 可以调用父类的成员方法。

2. 在子类的构造方法中调用父类的构造方法：

   • 在子类的构造方法中，可以使用 super 关键字调用父类的构造方法。
   • 使用 super(参数列表) 可以显式调用父类的特定构造方法，并传递相应的参数。

3. 在子类中调用被覆盖的父类方法：

   • 当子类覆盖（Override）了父类的方法，但仍然希望在子类中通过 super 关键字调用父类的被覆盖方法时，可以使用 super.方法名()。

需要注意以下几点：

• super 关键字只能在子类中使用，用于表示父类的引用。
• super 关键字可以访问父类的非私有成员变量和成员方法。
• 在子类的构造方法中，可通过 super(参数列表) 调用父类的构造方法，必须位于构造方法的第一行。
• 在子类中调用被覆盖的父类方法时，使用 super.方法名()。

总结：

• super 关键字表示父类的引用。
• 可以使用 super 关键字访问父类的成员变量和成员方法。
• 在子类的构造方法中，可以使用 super(参数列表) 来调用父类的构造方法。
• 在子类中调用被覆盖的父类方法时，可以使用 super.方法名()。

63. 抽象类和抽象方法。

抽象类（Abstract Class）和抽象方法（Abstract Method）是面向对象编程中的两个重要概念，用于实现抽象和多态性。它们的主要特点如下：

抽象类（Abstract Class）：

• 抽象类是不能被实例化（创建对象）的类，它只能被继承。
• 抽象类用关键字 abstract 来修饰，可以包含抽象方法和具体方法。抽象方法在抽象类中没有具体实现。
• 抽象类可以拥有成员变量、成员方法和构造方法，也可以包含普通方法的实现。
• 子类继承抽象类时，必须实现（重写）所有的抽象方法，除非子类也是一个抽象类。

抽象方法（Abstract Method）：

• 抽象方法是在抽象类中声明但没有具体实现的方法，使用关键字 abstract 来修饰，没有方法体。
• 抽象方法只能存在于抽象类中，不能存在于普通的类中。
• 子类继承抽象类时，必须实现（重写）所有的抽象方法，否则子类也必须声明为抽象类。

抽象类和抽象方法的作用和特点：

• 抽象类用于表达某个类或一组相关类的共同特征和行为，它提供了一种模板和规范。
• 抽象方法表示某个类必须具备的行为，具体的实现交给子类去完成，实现了多态性和方法的动态绑定。
• 抽象类不能被实例化，只能用来作为其他类的父类，提供了一种继承的层次结构。
• 子类继承抽象类时，必须实现（重写）所有的抽象方法，以充分体现父类的约束和规范。

需要注意以下几点：

• 抽象类中可以包含非抽象的方法，子类可以直接继承并使用这些方法。
• 如果一个类继承了抽象类，但没有实现所有的抽象方法，则该类也必须声明为抽象类。
• 抽象类和抽象方法必须使用关键字 abstract 来声明，并且抽象方法不能具有方法体。

总结：

• 抽象类是不能被实例化的类，用于表达一组相关类的共同特征和行为。
• 抽象方法是在抽象类中声明但没有具体实现的方法，用于表示某个类必须具备的行为。
• 子类继承抽象类时，必须实现（重写）所有的抽象方法。
• 抽象类和抽象方法提供了一种模板和规范，实现了多态性和方法的动态绑定。
  抽象类和抽象方法是面向对象编程中的概念，用于实现抽象和多态性。

以下是对抽象类和抽象方法的解释：

1. 抽象类（Abstract Class）：抽象类是一个不能被实例化的类，它只能被继承。抽象类用于表示一种抽象的概念或通用的行为，它可以包含抽象方法和具体方法。抽象类通过关键字"abstract"来声明。抽象类可以有构造方法，但不能被直接实例化。

示例：

public abstract class Animal {
    private String name;
    public Animal(String name) {
        this.name = name;
    }
    public abstract void makeSound();
    public void sleep() {
        System.out.println("Sleeping...");
    }
}

在上述示例中，Animal类是一个抽象类，它包含了一个抽象方法 makeSound() 和一个具体方法 sleep() 。

2. 抽象方法（Abstract Method）：抽象方法是一个没有实现的方法，它只有方法声明，没有方法体。抽象方法用于定义一种行为的规范，具体的实现由子类来完成。抽象方法通过在方法声明中使用关键字"abstract"来标识。

示例：

public abstract void makeSound();

在上述示例中， makeSound() 是一个抽象方法，它没有具体的实现。

抽象类和抽象方法的主要特点和用途包括：

• 抽象类不能被实例化，只能被继承。
• 抽象类可以包含抽象方法和具体方法。
• 子类继承抽象类时，必须实现抽象方法，除非子类也是抽象类。
• 抽象类可以用于定义一组相关的类的通用行为和属性。
• 抽象方法用于定义一种行为的规范，具体的实现由子类来完成。
• 抽象类和抽象方法可以用于实现多态性，通过父类引用指向子类对象。
• 抽象类和抽象方法不能被声明为final和static。

64. final, finally, finalize 的区别. (重点)

final、finally 和 finalize 是在Java语言中具有不同用途和含义的关键字。它们的区别如下：

1. final:

   • final 是一个修饰符，可以用于修饰类、方法和变量。
   • 当修饰类时，表示该类是最终类，不能被继承。
   • 当修饰方法时，表示该方法是最终方法，不能被子类重写。
   • 当修饰变量时，表示该变量是一个常量，初始化后不能再被修改。

2. finally:

   • finally 是一个关键字，用于定义在异常处理结构中的一个代码块。
   • finally 块中的代码无论是否发生异常都会被执行，用于确保某些代码一定会被执行，例如资源的释放。
   • finally 块通常与 try-catch 或 try-catch-finally 结构一起使用。

示例：

try {
    // 代码块，可能会抛出异常
} catch (Exception e) {
    // 异常处理
} finally {
    // 无论是否发生异常，都会执行的代码
}

3. finalize:
   • finalize 是一个方法，在Java中是Object类的一个方法，用于在对象被垃圾回收之前执行清理操作。
   • finalize 方法会在垃圾回收器确定该对象没有被引用时被调用，但不保证一定会执行。
   • finalize 方法可以被子类重写，编写实现对象清理操作的代码。
     总结：

• final 用于修饰类、方法和变量，表示最终的、不可改变的。
• finally 是一个关键字，用于定义异常处理结构中的代码块，无论是否发生异常都会执行。
• finalize 是一个方法，在对象被垃圾回收之前执行清理操作。

65. 什么是接口？

接口（Interface）是一种定义了一组抽象方法的引用类型。在面向对象编程中，接口用于描述类应该具有的行为或能力，而无需指定具体的实现细节。接口定义了一组方法的签名，但不包含实现代码。

接口的特点如下：

1. 接口只能包含抽象方法和常量：

   • 抽象方法没有具体的实现代码，只有方法的签名。
   • 常量在接口中被隐式声明为 public static final，可以直接通过接口名来访问。

2. 接口可以被类实现（implements）：

   • 类使用 implements 关键字来实现接口，表示类拥有接口定义的所有方法。
   • 类可以实现多个接口，用逗号分隔。

3. 接口实现的类必须实现接口中的所有方法：

   • 类实现接口时，必须提供接口中定义的所有方法的具体实现。
   • 实现的方法必须满足接口方法的签名和要求。

4. 接口可以继承（extends）其他接口：

   • 接口可以通过 extends 关键字扩展其他接口，形成接口的继承关系。
   • 接口之间的继承关系可以实现接口的组合和复用。

接口的作用：

• 定义一组行为或能力，用于约束具体类的行为。
• 实现类实现接口时，必须提供接口定义的所有方法的具体实现。
• 实现多态性，通过接口类型引用，可以实现对不同实现类的统一操作。
• 促进代码的模块化、灵活性和可维护性。

需要注意以下几点：

• 接口只能定义抽象方法和常量，不能包含实例变量和具体的方法实现。
• 类通过 implements 关键字实现接口，并提供接口定义的所有方法的具体实现。

总结：

• 接口是一种定义了一组抽象方法的引用类型。
• 接口只能包含抽象方法和常量。
• 类通过 implements 关键字实现接口，并提供接口定义的所有方法的具体实现。
• 接口的作用是约束类的行为、实现多态性、促进代码的模块化和灵活性。

示例：

// 定义一个接口
interface Animal {
    void eat();
    void sleep();
}
 // 实现接口
class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }
     @Override
    public void sleep() {
        System.out.println("Dog is sleeping.");
    }
}
 public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.sleep();
    }
}

在上述示例中，定义了一个Animal接口，包含了eat()和sleep()两个抽象方法。然后通过实现接口的方式，在Dog类中实现了Animal接口中定义的方法。最后在主方法中创建了Dog对象，调用了eat()和sleep()方法。

66. abstract class 和 interface 有什么区别? (重点)

抽象类（Abstract Class）和接口（Interface）是在Java中用于实现抽象和多态的两种方式，它们有以下区别：

1. 实现方式：

   • 抽象类使用 abstract 关键字定义，可以包含抽象方法和具体方法，也可以包含成员变量。
   • 接口使用 interface 关键字定义，只能包含抽象方法和常量，不能包含成员变量。

2. 关联关系：

   • 类可以通过继承一个抽象类来使用其中的方法和属性，并可以扩展其功能。
   • 类可以通过实现多个接口来使用多个接口定义的方法，实现接口的多继承。

3. 实现方式限制：

   • 类只能继承一个抽象类，但可以实现多个接口。
   • 接口可以被类实现多次，实现类可以实现多个相同的接口。

4. 构造方法：

   • 抽象类可以有构造方法，并且可以被实例化。
   • 接口不能有构造方法，因为接口不能被实例化。

5. 默认实现：

   • 抽象类可以提供方法的默认实现，子类可以选择性地重写或继承。
   • 接口只能声明方法的签名，不提供默认实现，实现类必须提供方法的具体实现。

6. 成员变量：

   • 抽象类可以包含成员变量，可以有各种访问修饰符。
   • 接口只能包含常量，被隐式声明为 public static final。

应用场景：

• 使用抽象类：当多个类有一些共同的方法和属性，且需要子类进行扩展时，可以使用抽象类来作为继承的基础。
• 使用接口：当类需要实现多个无关的功能或遵循多个约束时，可以使用接口进行实现，实现接口的多继承。

需要注意以下几点：

• 抽象类和接口都可以提供一种抽象化和标准化的方式，实现代码的复用和灵活性。
• 抽象类使用继承来实现共享的方法和属性，接口使用实现来实现多态性和方法的动态绑定。
• 抽象类可以有构造方法和成员变量，接口不能有构造方法且只能包含常量。
• 类只能继承一个抽象类，但可以实现多个接口。

总结：

• 抽象类使用 abstract 关键字定义，接口使用 interface 关键字定义。
• 抽象类可以包含抽象方法和具体方法，可以有构造方法和成员变量；接口只能包含抽象方法和常量。
• 类只能继承一个抽象类，但可以实现多个接口；接口可以被实现多次。
• 抽象类可以提供方法的默认实现，接口只能声明方法的签名。
• 抽象类可以被实例化，而接口不能被实例化。

67. 接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)? 抽象类中是否可以有静态的 main 方法？(重点)

接口是可以继承接口的，使用关键字 extends 来实现接口的继承。通过接口继承，可以扩展接口的功能和规范。

示例：

interface InterfaceA {
    void methodA();
}
 interface InterfaceB extends InterfaceA {
    void methodB();
}

在上述示例中， InterfaceB 继承了 InterfaceA ，并添加了一个新的方法 methodB 。
抽象类是可以实现（implements）接口的，使用关键字 implements 来实现接口。通过实现接口，抽象类需要提供接口中定义的抽象方法的具体实现。

示例：

interface InterfaceA {
    void methodA();
}
 abstract class AbstractClass implements InterfaceA {
    public void methodA() {
        // 具体实现
    }
}

在上述示例中， AbstractClass 实现了 InterfaceA 接口，并提供了 methodA 方法的具体实现。

抽象类是可以继承实体类（具体类）的，使用关键字 extends 来实现类的继承。通过继承实体类，抽象类可以继承实体类的属性和方法，并可以在抽象类中添加抽象方法或提供具体方法的实现。

示例：

class ConcreteClass {
    public void method() {
        // 具体实现
    }
}
 abstract class AbstractClass extends ConcreteClass {
    public abstract void abstractMethod();
}

在上述示例中， AbstractClass 继承了 ConcreteClass ，并添加了一个抽象方法 abstractMethod 。
抽象类中是可以有静态的 main 方法的。静态的 main 方法是程序的入口点，用于启动Java应用程序。

示例：

abstract class AbstractClass {
    public static void main(String[] args) {
        // 程序入口
    }
}

在上述示例中， AbstractClass 中定义了一个静态的 main 方法，可以作为程序的入口点。

68. 什么是异常？

在编程中，异常（Exception）是指在程序执行过程中发生的意外或异常情况。当程序遇到异常时，它会中断正常的执行流程，并尝试找到能够处理异常的代码块。异常提供了一种机制，用于处理和报告程序的错误和异常情况。

异常的特点如下：

1. 异常是在运行时抛出（throw）的：

   • 当程序发生错误或异常情况时，它会抛出一个异常对象。
   • 异常对象封装了异常的类型和详细信息。

2. 异常分为不同的类型：

   • Java 提供了一些内置的异常类型，如 NullPointerException、ArithmeticException 等。
   • 异常类型分为两种：Checked Exception（受检异常）和 Unchecked Exception（非受检异常）。

3. 异常可以被捕获和处理：

   • 在程序中可以使用 try-catch 块来捕获异常并处理。
   • catch 块中的代码用于处理异常，可以采取相应的措施来修复异常或恢复程序的正常执行。

4. 未捕获的异常会导致程序终止：

   • 如果程序没有提供处理异常的代码，或处理代码未能成功处理异常，那么异常会传递给调用者，直到遇到能够处理异常的代码为止。
   • 如果依然没有处理异常，程序可能会终止执行。

异常处理的目的是：

• 提供代码的健壮性，防止错误情况导致程序崩溃。
• 提供错误信息和跟踪，帮助调试和排查问题。

需要注意以下几点：

• 异常是在程序运行时抛出的，用于处理和报告异常情况。
• 异常分为不同的类型，包括受检异常和非受检异常。
• 异常可以被捕获和处理，使用 try-catch 块来处理异常。
• 如果异常未能被捕获和处理，程序可能会终止执行。

总结：
异常是在程序执行过程中发生的意外或异常情况，用于处理和报告程序的错误。
异常分为不同的类型，可以被捕获和处理，如果未能处理，可能导致程序终止执行。

69. 运行时异常（RuntimeException）与一般异常有何异同？ (重点)

运行时异常（RuntimeException）和一般异常的异同如下：

1. 异常类型：

   • 运行时异常是一种非受检异常（Unchecked Exception），不需要在代码中显式捕获或声明抛出。
   • 一般异常是一种受检异常（Checked Exception），需要在代码中显式捕获或声明抛出。

2. 异常检查：

   • 运行时异常在编译时不会进行检查，可以不捕获或声明抛出。
   • 一般异常在编译时要求进行检查，必须捕获或声明抛出。

3. 异常的来源：

   • 运行时异常通常是由程序逻辑错误引发的，如空指针异常（NullPointerException）和数组越界异常（ArrayIndexOutOfBoundsException）等。
   • 一般异常通常是由外部条件引发的，如文件不存在异常（FileNotFoundException）和网络连接异常（IOException）等。

4. 异常的处理：

   • 运行时异常可以捕获和处理，但这并不是强制的，可以选择忽略。
   • 一般异常必须被捕获和处理，或者在方法声明中声明抛出。

5. 编程风格：

   • 运行时异常被认为是程序员的错误，常常由不良的编程习惯引起，应该通过代码优化和规范来避免。
   • 一般异常是无法预测或不可避免的外部情况，需要在代码中明确处理。

需要注意以下几点：

• 运行时异常是一种非受检异常，不需要在代码中显式捕获或声明抛出。
• 一般异常是一种受检异常，需要在代码中进行异常处理。
• 运行时异常通常是由程序逻辑错误引发的，一般异常通常是由外部条件引发的。
• 运行时异常的处理是可选的，一般异常的处理是必需的。

总结：
运行时异常和一般异常是Java中异常的两种分类方式。
运行时异常是一种非受检异常，不需要显式捕获或声明抛出；一般异常是一种受检异常，需要进行异常处理。
运行时异常通常是由程序逻辑错误引发的，一般异常通常是由外部条件引发的。 运行时异常的处理是可选的，一般异常的处理是必需的。

70. java 语言如何进行异常处理?关键字：throws、throw、try、catch、finally 分别代表什么意义？在 try 块中可以抛出异常吗? (重点)

在Java语言中，可以使用以下关键字进行异常处理：

1. throws：throws关键字用于在方法声明中指定该方法可能抛出的异常类型。当方法内部可能会抛出已检查异常时，可以使用throws关键字将异常类型声明在方法签名中，通知调用者需要处理该异常。
2. throw：throw关键字用于手动抛出一个异常对象。可以使用throw关键字在代码中主动抛出一个异常，用于表示出现了意外情况或错误，使得程序流程跳转到异常处理代码。
3. try-catch：try-catch语句用于捕获和处理异常。try块中包含可能会抛出异常的代码，catch块用于捕获并处理try块中抛出的异常。当try块中的代码抛出异常时，程序会跳转到catch块中执行相应的异常处理代码。
4. finally：finally块用于定义无论是否发生异常都会执行的代码块。在try-catch语句中，finally块中的代码总是会被执行，无论是否发生异常。通常用于释放资源或执行清理操作。

在try块中可以抛出异常，但需要在方法签名中使用throws关键字声明该异常类型。如果在try块中抛出了异常，并且没有在方法签名中声明该异常类型，编译器会报错。因此，在try块中抛出异常时，要么在方法签名中声明该异常类型，要么使用catch块捕获并处理该异常。

示例：

public class ExceptionHandling {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage());
        } finally {
            System.out.println("Finally block executed");
        }
    }
     public static int divide(int dividend, int divisor) throws ArithmeticException {
        if (divisor == 0) {
            throw new ArithmeticException("Division by zero");
        }
        return dividend / divisor;
    }
}

在上述示例中，divide方法可能会抛出ArithmeticException异常，因此在方法签名中使用throws关键字声明该异常类型。在main方法中，通过try-catch语句捕获并处理divide方法可能抛出的异常。无论是否发生异常，finally块中的代码总是会被执行。
需要注意的是，try-catch-finally语句块可以根据实际需求进行嵌套，以处理多个异常情况。

71. 程序中try{}里有一个 return 语句,那么紧跟在这个try 后的finally{}里的代码会不会被 执行？在什么时候被执行？(重点)

在程序中，如果在try块中遇到return语句，那么紧跟在该try块后的finally块中的代码仍然会被执行。finally块中的代码在以下情况下会被执行：

1. 在try块中没有发生异常的情况下：

   • 如果try块中的代码正常执行并遇到了return语句，finally块中的代码会在return语句执行之前被执行。这样可以确保在方法返回之前执行一些必要的清理工作。

2. 在try块中发生了异常的情况下：

   • 如果在try块中发生了异常，并且该异常被对应的catch块捕获并处理，finally块中的代码会在异常被捕获和处理之后执行。
   • catch块中的代码会在finally块之前执行，然后再执行finally块中的代码，以便在异常处理后执行清理操作。

需要注意以下几点：

• finally块中的代码总是会执行，不论是否发生异常。
• finally块中的代码会在try块中的return语句执行之前被执行。
• 如果在try块中发生异常，并且异常被捕获并处理，catch块中的代码会在finally块之前执行。

总结：

在程序中，如果在try块中遇到return语句，紧跟在该try块后的finally块中的代码会被执行。

• 如果try块顺利执行并遇到return语句，finally块中的代码会在return语句执行之前被执行。
• 如果try块中发生了异常，并且异常被捕获并处理，catch块中的代码会在finally块之前执行。
• finally块中的代码总是会被执行，不论是否发生异常。

72. error 和 exception 有什么区别?

在Java中，Error和Exception是两种不同的异常类型，它们之间有以下区别：

1. Error（错误）：

   • Error是一种严重的问题，通常由虚拟机（JVM）报告。
   • Error表示虚拟机（JVM）本身的错误或系统级错误，它们通常是不可恢复的。
   • Error一般不被捕获和处理，而是需要修复错误的代码才能解决问题。
   • 例如，OutOfMemoryError（内存溢出错误）和StackOverflowError（栈溢出错误）是Error的常见示例。

2. Exception（异常）：

   • Exception是一种可预测并可处理的问题，通常由编程错误或外部操作引起。
   • Exception表示程序在运行时遇到了意料之外的情况。
   • Exception可以被捕获和处理，以防止程序崩溃，并提供错误处理和异常恢复的机会。
   • Exception分为两种类型：已检查异常（Checked Exception）和未检查异常（Unchecked Exception）。
     • 已检查异常：需要在代码中明确捕获或声明抛出的异常，否则编译器会报错。例如，FileNotFoundException（文件未找到异常）。
     • 未检查异常：不需要在代码中显式捕获或声明抛出的异常。例如，NullPointerException（空指针异常）和RuntimeException（运行时异常）。

举例说明：

• Error的示例：OutOfMemoryError，当程序尝试使用过多内存时会抛出该错误。

public class OutOfMemoryErrorExample {
    public static void main(String[] args) {
        int[] array = new int[Integer.MAX_VALUE]; // 尝试分配超过最大限制的数组
    }
}

• Exception的示例：FileNotFoundException，当尝试访问不存在的文件时会抛出该异常。

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;

public class FileNotFoundExceptionExample {
    public static void main(String[] args) {
        try {
            FileReader fileReader = new FileReader("nonexistent.txt"); // 尝试打开不存在的文件
            BufferedReader br = new BufferedReader(fileReader);
            String line = br.readLine();
            System.out.println(line);
            br.close();
        } catch (FileNotFoundException e) {
            System.out.println("文件未找到！");
        } catch (Exception e) {
            System.out.println("发生了其他异常！");
        }
    }
}

在该示例中，我们尝试打开一个不存在的文件，这可能引发FileNotFoundException。在catch块中捕获该异常，并打印出自定义的错误消息。如果代码中存在其他异常，则会被捕获并输出相应的错误消息。

73. Java 中的异常处理机制的简单原理和应用。

Java中的异常处理机制是一种处理程序运行时错误或意外情况的机制，它的简单原理包括以下几个方面：

1. 抛出异常：

   • 当程序发生错误或出现意外情况时，通过使用throw关键字主动抛出一个异常对象。
   • 异常对象包含有关异常类型、消息和堆栈跟踪等信息。

2. 捕获异常：

   • 使用try-catch语句块来捕获异常。
   • try块中包含可能引发异常的代码。
   • 如果在try块中的代码引发了异常，对应的catch块会捕获并处理该异常。

3. 处理异常：

   • 在catch块中提供对异常的处理逻辑。
   • 可以根据异常类型使用多个catch块来捕获和处理不同类型的异常。
   • catch块中的代码将根据异常类型执行相应的处理操作，如打印错误消息、记录日志或采取其他适当的操作。

4. finally块：

   • 可以使用finally块指定必须在异常处理之后无论是否发生异常都要执行的代码。
   • finally块中的代码通常用于清理资源、关闭文件或释放数据库连接等操作。

异常处理机制的应用：

• 异常处理机制允许程序在发生错误或异常时进行适当的响应和处理，而不会导致整个程序崩溃或意外终止。
• 通过捕获和处理异常，可以提高程序的可靠性和可维护性。
• 异常处理机制还可以用于向上层调用者传递错误信息或状态，以便错误信息能够被处理或记录。
• 在开发过程中，可以根据不同的异常类型设计相应的异常类，并在方法声明中使用throws关键字来指定可能抛出的异常，提供了一种有效的错误处理和异常传递机制。

总结： Java中的异常处理机制通过抛出异常、捕获异常和处理异常来响应和处理程序运行时错误或意外情况。
通过使用try-catch语句块来捕获异常，可以提供对异常的处理逻辑。
通过finally块可以指定在异常处理之后无论是否发生异常都必须执行的代码。
异常处理机制可以提高程序的可靠性和可维护性，并允许错误信息的传递和处理。

Java中的异常处理机制是一种用于处理程序运行时错误或意外情况的机制。它的简单原理包括抛出异常、捕获异常和处理异常。下面通过一个示例来说明异常处理机制的应用：

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0); // 调用divide方法，传递了一个除数为0的参数
            System.out.println("结果：" + result);
        } catch (ArithmeticException e) {
            System.out.println("发生了算术异常：除数不能为0！");
        }
    }
    
    public static int divide(int dividend, int divisor) {
        return dividend / divisor; // 这里可能发生除零异常
    }
}

在上述示例中，我们调用了divide方法并传递了一个除数为0的参数。由于除数为0，会触发ArithmeticException算术异常。

在main方法中，我们使用try-catch语句块捕获并处理了这个异常。try块中包含可能引发异常的代码，即调用divide方法。当异常发生时，会被对应的catch块捕获并执行相应的处理逻辑，即打印出自定义的错误消息。

通过异常处理机制，程序能够避免在遇到错误时崩溃，而是能够适当地捕获和处理异常。这样可以提供更好的程序健壮性和用户体验。

除了捕获已知异常，Java还允许我们自定义异常类来表示特定的异常情况，并在方法中声明抛出这些自定义异常。通过这种方式，我们可以更好地组织和处理代码中的异常情况，使程序更加健壮和可维护。

74. throws 和 throw 的区别(重点)。

在Java中，throws和throw是用于处理异常的关键字，它们之间有以下区别：

1. throws：

   • throws用于在方法声明中指定可能抛出的异常，允许将异常传递给调用者来处理。
   • throws关键字出现在方法的签名或头部部分，并在方法名之后紧跟异常类型，可以指定多个异常类型，用逗号分隔。
   • 使用throws声明的异常表示方法可能会抛出这些异常，调用者必须在调用方法时处理或再次抛出这些异常，否则编译器会报错。
   • throws用于方法级别的异常声明，表示方法可能引发某些异常情况，将责任和处理转移给上层调用者。

2. throw：

   • throw用于在程序中抛出一个异常对象。它通常出现在方法的内部。
   • throw关键字后面跟着一个异常对象，可以是任意类型的异常对象。
   • throw用于显式地抛出一个异常，可以是Java类库中定义的异常对象，也可以是自定义的异常对象。
   • 当某种条件满足时，可以使用throw关键字来抛出异常，以使程序进入异常处理的流程。

举例说明：

import java.io.IOException;

public class ThrowsAndThrowExample {
    public static void main(String[] args) {
        try {
            throwException();
        } catch (IOException e) {
            System.out.println("捕获到IOException异常：" + e.getMessage());
        }
    }

    public static void throwException() throws IOException {
        throw new IOException("发生了IO异常");
    }
}

在上述示例中，我们定义了一个throwException方法，该方法使用throws关键字在方法声明中指定可能抛出的异常类型IOException。

在main方法中，我们调用了throwException方法，然后通过try-catch块捕获了可能抛出的IOException异常。在throwException方法内部，我们使用throw关键字抛出了一个IOException异常对象，即new IOException("发生了IO异常")。

通过throws关键字，我们表明throwException方法可能会抛出IOException异常。而通过throw关键字，我们显式地抛出了一个IOException异常对象。

总结：

• throws用于在方法声明中指定可能抛出的异常，将异常责任和处理转移给调用者来处理。
• throw用于在程序中抛出一个异常对象，使程序进入异常处理的流程。
• throws用于方法级别的异常声明，表示方法可能会引发某些异常情况。
• throw用于显式地抛出一个异常对象，可以是Java类库中定义的异常对象，也可以是自定义的异常对象。

75. 异常分为几类？

在Java中，异常分为三类：已检查异常（Checked Exception），运行时异常（Runtime Exception）和错误（Error）。

1. 已检查异常（Checked Exception）：
   • 已检查异常是在编译时强制检查的异常，通常表示外部条件变化或错误的情况，需要显示处理或传播给调用者。
   • 通常是可以预料和修复的异常情况。
   • 例如：IOException（输入输出异常）、SQLException（数据库异常）、ClassNotFoundException（类未找到异常）等。

示例：

import java.io.FileReader;
import java.io.FileNotFoundException;

public class CheckedExceptionExample {
    public static void main(String[] args) {
        try {
            FileReader fileReader = new FileReader("file.txt"); // 尝试打开一个不存在的文件，抛出FileNotFoundException
        } catch (FileNotFoundException e) {
            System.out.println("文件未找到！");
        }
    }
}

在上述示例中，我们尝试打开一个名为file.txt的文件。由于文件不存在，FileReader构造函数抛出了一个FileNotFoundException已检查异常。我们使用try-catch块捕获并处理了该异常，打印出自定义错误消息。

2. 运行时异常（Runtime Exception）：
   • 运行时异常是一种不需要显式捕获的异常，它们是由程序错误导致的，通常表示程序逻辑错误或错误的使用。
   • 运行时异常在编译时不需要强制处理或者指定throws，可以在程序运行时动态抛出和捕获。
   • 例如：NullPointerException（空指针异常）、ArrayIndexOutOfBoundsException（数组越界异常）、ArithmeticException（算术异常）等。

示例：

public class RuntimeExceptionExample {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        try {
            int result = arr[3]; // 访问数组越界，抛出ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组越界！");
        }
    }
}

在上述示例中，我们定义了一个包含三个元素的整型数组arr，然后尝试访问索引为3的元素，由于数组越界，抛出了一个ArrayIndexOutOfBoundsException运行时异常。我们使用try-catch块捕获并处理了该异常，打印出自定义错误消息。

3. 错误（Error）：
   • 错误表示严重的问题，通常由虚拟机（JVM）报告。
   • 错误通常表示虚拟机（JVM）本身的错误或系统级错误，它们是不可恢复的，无法通过代码来处理。
   • 错误不需要显式处理或指定throws。
   • 例如：OutOfMemoryError（内存溢出错误）、StackOverflowError（栈溢出错误）等。

示例：

public class ErrorExample {
    public static void main(String[] args) {
        try {
            recursiveMethod(); // 递归方法导致栈溢出，抛出StackOverflowError
        } catch (StackOverflowError e) {
            System.out.println("栈溢出！");
        }
    }

    public static void recursiveMethod() {
        recursiveMethod();
    }
}

在上述示例中，我们定义了一个递归方法recursiveMethod()，该方法无限递归调用自身。当递归层级过深时，导致栈溢出，抛出了一个StackOverflowError错误。我们使用try-catch块捕获并处理了该错误，打印出自定义错误消息。

总结：
Java中的异常分为已检查异常、运行时异常和错误。已检查异常是需要在编译时显示处理或传播的异常，运行时异常是由程序错误导致的异常，而错误是严重的问题，通常由虚拟机报告，是不可恢复的。不同类型的异常在处理方式和异常传递上有所不同。

76. Collection 和 Collections 的区别(重点)。

在Java中，Collection和Collections是两个相关但不同的概念。

1. Collection：
   • Collection是Java集合框架中的一个接口，它代表了一组对象的集合。它是所有集合类的基础接口。
   • Collection接口定义了对集合中元素进行基本操作的方法，如添加、删除、遍历等。
   • Collection接口提供了多个子接口和实现类（如List、Set、Queue等），每个子接口和实现类都提供了不同的特性和用途。

示例：

import java.util.ArrayList;
import java.util.Collection;

public class CollectionExample {
    public static void main(String[] args) {
        Collection<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        System.out.println(names);
    }
}

在上述示例中，我们使用Collection接口的实现类ArrayList创建了一个名为names的集合。然后使用add()方法向集合中添加了三个字符串元素。最后，我们使用System.out.println()方法打印出集合中的内容。

2. Collections：
   • Collections是Java集合框架中的一个工具类，它包含了一些静态方法，用于操作集合对象。
   • Collections类提供了一系列的静态方法，如排序、查找、遍历等，用于对集合进行常见操作。
   • 它不能被实例化，所有方法都是静态的。

示例：

import java.util.ArrayList;
import java.util.Collections;

public class CollectionsExample {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(2);
        numbers.add(8);
        numbers.add(1);

        Collections.sort(numbers); // 对集合进行排序

        for (Integer number : numbers) {
            System.out.println(number);
        }
    }
}

在上述示例中，我们使用ArrayList创建了一个名为numbers的集合，并向其中添加了四个整数元素。然后，我们使用Collections类的sort()方法对集合进行排序。最后，我们使用for-each循环遍历集合中的元素，并将它们打印出来。

总结：

• Collection是Java集合框架中的一个接口，代表了一组对象的集合，定义了对集合进行基本操作的方法。
• Collections是Java集合框架中的一个工具类，包含了一些静态方法，用于操作集合对象。
• Collection接口提供了多个子接口和实现类，而Collections类提供了一系列静态方法，用于对集合进行常见操作。
• Collection表示一个集合对象，Collections表示对集合的操作工具类。

77. 数组和集合的主要的区别(重点)，举例说明。

数组和集合是Java中常用的数据容器，它们有一些重要的区别：

1. 固定长度 vs 动态长度：
   • 数组具有固定长度，一旦创建后，其长度不可改变。
   • 集合（Collection）具有动态长度，可以根据需要随时添加或删除元素。

示例：

// 数组
int[] numbers = new int[3];
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;

// 集合
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);

在上述示例中，数组numbers在创建时需要指定长度为3，且长度无法改变。而集合list通过add()方法动态添加了4个元素，并且在需要时可以根据需要继续添加或删除元素。

2. 数据类型限制：
   • 数组可以存储任意类型的元素，包括基本类型（如int、char）和引用类型（如对象）。
   • 集合（Collection）只能存储对象引用，不支持直接存储基本类型，需要使用包装类装箱操作。

示例：

// 数组
int[] numbers = new int[3];
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;

// 集合
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(new Integer(4));

在上述示例中，数组numbers可以直接存储基本类型的整数，而集合list需要使用包装类Integer将整数进行装箱操作后，才能添加到集合中。

3. 功能和灵活性：
   • 数组提供了基本的访问和遍历功能，但在添加、删除和查找等操作上相对较繁琐。
   • 集合（Collection）提供了丰富的功能和灵活的操作方法，方便添加、删除、查找和遍历集合中的元素。

示例：

// 数组
int[] numbers = {1, 2, 3};
System.out.println(numbers[1]);  // 输出: 2

// 集合
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
System.out.println(list.get(1));  // 输出: 2

在上述示例中，通过数组numbers可以通过索引直接访问和获取指定位置的元素。而集合list通过get()方法来获取指定位置的元素。

总结：

• 数组具有固定长度，而集合（Collection）具有动态长度。
• 数组可以存储任意类型的元素，而集合只能存储对象引用。
• 数组提供了基本的访问和遍历功能，而集合提供了丰富的功能和灵活的操作方法，更方便地添加、删除、查找和遍历元素。

78. 列出你知道的容器类(就是指集合类)。

以下是我知道的一些常见的Java容器类，并给出了简单的示例说明：

1. List（列表）：

• ArrayList：基于数组实现的动态数组。

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");

• LinkedList：基于链表实现的双向链表。

List<Integer> linkedList = new LinkedList<>();
linkedList.add(10);
linkedList.add(20);
linkedList.add(30);

2. Set（集合）：

• HashSet：基于哈希表实现的无序集合。

Set<String> set = new HashSet<>();
set.add("Dog");
set.add("Cat");
set.add("Elephant");

• TreeSet：基于红黑树实现的有序集合。

Set<Integer> treeSet = new TreeSet<>();
treeSet.add(5);
treeSet.add(2);
treeSet.add(8);

3. Queue（队列）：

• LinkedList：基于链表实现的双向队列。

Queue<String> queue = new LinkedList<>();
queue.add("John");
queue.add("Alice");
queue.add("Bob");

• PriorityQueue：基于堆实现的优先级队列。

Queue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.add(5);
priorityQueue.add(2);
priorityQueue.add(8);

4. Map（映射）：

• HashMap：基于哈希表实现的无序键值对映射。

Map<String, Integer> map = new HashMap<>();
map.put("Apple", 10);
map.put("Banana", 15);
map.put("Orange", 20);

• TreeMap：基于红黑树实现的有序键值对映射。

Map<Integer, String> treeMap = new TreeMap<>();
treeMap.put(5, "Five");
treeMap.put(2, "Two");
treeMap.put(8, "Eight");

5. Stack（栈）：

• Stack：基于数组实现的后进先出（LIFO）的栈。

Stack<String> stack = new Stack<>();
stack.push("Apple");
stack.push("Banana");
stack.push("Orange");

这只是其中的一部分常见容器类，Java集合框架还包括其他类和接口，如Deque（双端队列）、Iterator（迭代器）等。每个容器类都有自己的特点和适用场景，根据实际需求进行选择和使用。

79. List, Set, Map 是否继承自 Collection 接口? (重点)

是的，List、Set和Map接口都继承自Java集合框架中的Collection接口。

1. List接口继承自Collection接口：

• List接口表示有序的元素序列，可以包含重复元素。
• List接口中定义了一些用于操作列表的方法，如get()、add()、remove()等。

2. Set接口继承自Collection接口：

• Set接口表示不包含重复元素的集合。
• Set接口中定义了一些用于操作集合的方法，如add()、remove()、contains()等。

3. Map接口不直接继承自Collection接口：

• Map接口表示具有键值对映射关系的数据集合，没有“继承”的概念。
• Map接口中定义了一些用于操作键值对的方法，如put()、get()、remove()等。

综上所述，List和Set接口继承自Collection接口，而Map接口是独立的，没有继承自Collection接口。尽管如此，List、Set和Map在Java集合框架中都属于不同的容器类型，用于存储和操作不同类型的数据，并提供了各自特定的方法和行为。

80. ArrayList、LinkedList 集合的区别(重点)，举例说明。

ArrayList和LinkedList是Java集合框架中常用的列表（List）实现类，它们有以下区别：

1. 底层数据结构：

• ArrayList底层采用数组（Array）实现，通过数组的索引来访问和操作元素。
• LinkedList底层采用双向链表（Doubly Linked List）实现，每个节点存储元素和前后节点的引用。

示例：

// ArrayList
List<Integer> arrayList = new ArrayList<>();
arrayList.add(1);
arrayList.add(2);
arrayList.add(3);

// LinkedList
List<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);

2. 插入和删除操作效率- ArrayList对于索引访问的操作效率比较高，但在中间或开头插入、删除元素时需要移动后续元素。

• LinkedList在中间或开头插入、删除元素时效率较高，不需要移动后续元素，但对于索引访问的操作效率较低。

示例：

// ArrayList
list.add(1);              // [1]
list.add(2);              // [1, 2]
list.add(3);              // [1, 2, 3]
list.add(1, 4);            // [1, 4, 2, 3]  - 在索引1处插入元素4
list.remove(2);           // [1, 4, 3]    - 移除索引2处的元素

// LinkedList
list.add(1);              // [1]
list.add(2);              // [1, 2]
list.add(3);              // [1, 2, 3]
list.add(1, 4);            // [1, 4, 2, 3]  - 在索引1处插入元素4
list.remove(2);           // [1, 4, 3]    - 移除索引2处的元素

在上述示例中，对于ArrayList来说，在中间插入元素或删除元素时，需要移动后续元素。而对于LinkedList来说，在中间插入元素或删除元素时，只需要调整节点的引用，效率较高。

3. 内存占用：

• ArrayList在内存中以连续的数组存储元素，需要预先分配固定长度的数组空间，可能会浪费一定内存。
• LinkedList在内存中以链表形式存储元素，不需要预先分配固定长度的数组空间，只需要为每个节点分配内存。

综上所述，ArrayList适用于需要频繁访问元素、按索引操作较多的场景，而LinkedList适用于需要频繁插入和删除元素、按索引操作较少的场景。根据实际需求和具体场景选择合适的列表实现类。

81. Set、List、Map 它们的区别(重点)。

Set、List和Map是Java集合框架中常见的容器类型，它们有以下区别：

1. 存储方式和元素特性：

• List是有序的列表集合，可以包含重复元素。
• Set是无序的集合，不允许包含重复元素。
• Map是键值对的映射集合，其中的键和值都可以是任意对象，键不允许重复。

示例：

// List
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Apple");  // 允许重复元素

// Set
Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Apple");  // 不允许重复元素

// Map
Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
map.put("Apple", 3);  // 键重复，后续值会覆盖前面的值

2. 访问方式：

• List和Set可以通过索引或迭代方式来访问集合中的元素。
• Map通过键来访问对应的值，而不是通过索引。

示例：

// List
String element1 = list.get(0);        // 通过索引访问元素
for (String element: list) {         // 迭代访问元素
    System.out.println(element);
}

// Set
for (String element: set) {
    System.out.println(element);     // 迭代访问元素
}

// Map
int value1 = map.get("Apple");       // 通过键访问值
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    String key = entry.getKey();
    int value = entry.getValue();    // 遍历访问键值对
    System.out.println(key + ": " + value);
}

3. 功能和用途：

• List适合需要维护元素的插入顺序、按索引访问元素的场景，并且允许重复元素。
• Set适合需要存储独特元素、不需要关心顺序的场景，用于去重和判断元素是否存在。
• Map适合需要将键与值进行关联和存储的场景，通过键快速查找和操作对应的值。

综上所述，Set、List和Map在功能和特性上有所不同，根据具体的需求和使用场景选择合适的容器类型。

82. Set 里的元素是不能重复的,那么用什么方法来区分重复与否呢? 是用==还是？

Set中的元素是不能重复的，重复与否是通过对象的equals()和hashCode()方法来判断的，而不是通过==操作符。

在Java中，对象的equals()方法用于判断两个对象是否逻辑上相等，即具有相同的内容或属性。hashCode()方法用于计算对象的哈希码，哈希码在散列数据结构中用于快速查找和存储对象。

Set在插入元素时，会先通过equals()方法判断是否重复，如果equals()返回true，则认为是重复元素，不会向Set中添加该元素。在判断重复元素时，Set会根据元素的hashCode进行一些优化，先比较hashCode值，如果不同，就不需要执行equals()方法来判断是否重复。

简单来说，Set通过equals()方法判断逻辑上的相等，利用hashCode()方法来快速判断是否可能重复，只有在hashCode相等的情况下才会进一步调用equals()方法来精确判断元素是否重复。

示例：

class Person {
    private String name;
    private int age;

    // 省略构造函数和其它方法

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

Set<Person> personSet = new HashSet<>();
Person p1 = new Person("Alice", 25);
Person p2 = new Person("Bob", 30);
Person p3 = new Person("Alice", 25);

personSet.add(p1);  // 添加成功
personSet.add(p2);  // 添加成功
personSet.add(p3);  // 添加失败，重复元素

在上述示例中，Person类重写了equals()方法和hashCode()方法，定义了通过name和age来判断是否相等。当p1、p2和p3对象加入Set时，由于p3与p1在逻辑上是相等的，因此添加失败，保持Set中元素的唯一性。

83. List、Map、Set 三个接口,存取元素时,各有什么特点？

List、Map和Set是Java集合框架中常见的接口，它们在存取元素时具有以下特点：

1. List接口：

• 存储特点：有序集合，可以包含重复元素。
• 存取方式：
  • 通过索引访问元素：List中的元素可以按照插入的顺序通过索引进行访问，通过get()方法可以获取指定索引位置的元素。
  • 通过迭代器访问元素：List提供了迭代器，可以用来遍历列表中的元素。

示例：

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Apple");

String element = list.get(0);  // 通过索引访问元素
for (String str : list) {     // 通过迭代器遍历元素
    System.out.println(str);
}

2. Map接口：

• 存储特点：键值对的映射集合，键不允许重复，值可以重复。
• 存取方式：
  • 通过键访问值：Map中的元素是通过键与值关联，通过键可以访问对应的值，使用get()方法根据键获取值。
  • 遍历键值对：Map提供了entrySet()方法返回键值对的集合，可以通过迭代器或增强for循环遍历键值对。

示例：

Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
map.put("Apple", 3);

int value = map.get("Apple");  // 通过键访问值
for (Map.Entry<String, Integer> entry : map.entrySet()) {  // 遍历键值对
    String key = entry.getKey();
    int val = entry.getValue();
    System.out.println(key + ": " + val);
}

3. Set接口：

• 存储特点：无序集合，不允许包含重复元素。
• 存取方式：
  • 添加元素：通过add()方法向Set中添加元素。如果添加的元素已经存在于Set中，则会被忽略。
  • 遍历元素：Set提供了迭代器或增强for循环用于遍历集合中的元素。

示例：

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Apple");

for (String element : set) {  // 遍历元素
    System.out.println(element);
}

综上所述，List通过索引和迭代器访问元素，可以存储重复元素；Map通过键访问值和遍历键值对，键不允许重复；Set通过添加元素和遍历元素，不允许包含重复元素。根据存取的需求和特点选择合适的集合类型。

84. HashMap 和 Hashtable 的区别(重点)

HashMap和Hashtable是Java集合框架中常用的哈希表（Hash Table）实现类，它们有以下区别：

1. 线程安全性：

• HashMap是非线程安全的，不同的线程可以同时对HashMap进行操作，需要自行保证线程安全性。
• Hashtable是线程安全的，内部的方法都是同步的，多个线程不能同时对Hashtable进行修改操作。

2. null键和null值的处理：

• HashMap允许使用null作为键和值，即可以插入null键或null值。
• Hashtable不允许使用null作为键或值，如果插入了null键或值，会抛出NullPointerException。

示例：

// HashMap
HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put("key", null);     // 允许插入null值
hashMap.put(null, 123);       // 允许插入null键

// Hashtable
Hashtable<String, Integer> hashtable = new Hashtable<>();
hashtable.put("key", null);   // 抛出NullPointerException
hashtable.put(null, 123);     // 抛出NullPointerException

3. 继承关系：

• HashMap是Hashtable的轻量级实现，实现了Map接口，继承抽象类AbstractMap。
• Hashtable是基于哈希表的字典实现，实现了Map接口，继承了Dictionary类。

4. 性能：

• HashMap相对于Hashtable来说，因为不是线程安全的，避免了同步开销，因此在多线程环境下性能更好。
• Hashtable由于需要进行同步操作，性能上相对较低，在单线程环境下使用时会有一定的性能损耗。

综上所述，HashMap和Hashtable在线程安全性、null键和null值的处理、继承关系和性能上存在着一些区别。在开发中，根据具体的需求和多线程环境选择合适的实现类。如果不需要线程安全性，推荐使用HashMap。

85. 说出 ArrayList,Vector, LinkedList 的存储性能和特性 (重点)

ArrayList、Vector和LinkedList是Java集合框架中常用的列表（List）实现类，它们有不同的存储性能和特性：

1. 存储性能：

• ArrayList和Vector都是基于数组实现的，适用于随机访问和大量元素的存储。数组支持根据索引快速访问元素，因此查询和随机访问的性能较好。
• LinkedList是基于双向链表实现的，适用于频繁的插入和删除操作。由于链表需要依次遍历找到特定的位置，因此查询和随机访问的性能相对较差，但在插入和删除操作上性能较好。

2. 线程安全性：

• ArrayList是非线程安全的，不同的线程可以同时对ArrayList进行操作，需要自行保证线程安全性。
• Vector是线程安全的，内部的方法都是同步的，多个线程不能同时对Vector进行修改操作。
• LinkedList是非线程安全的。

3. 动态扩容：

• ArrayList和Vector在存储空间不足时会自动扩容，扩容策略是按照当前容量的一定比例增加。ArrayList的扩容因子是原容量的50%，而Vector的扩容因子是原容量的100%。
• LinkedList不需要扩容，因为它使用链表存储，每个节点根据需要独立分配内存。

4. 迭代器：

• ArrayList、Vector和LinkedList都支持使用迭代器（Iterator）进行遍历。
• ArrayList和Vector可以使用索引进行快速访问，而LinkedList使用迭代器逐个访问元素。

根据上述特点，可以总结：

• 如果需要频繁进行随机访问和查询操作，且不考虑线程安全性，适合使用ArrayList。
• 如果需要频繁进行插入和删除操作，且不考虑线程安全性，适合使用LinkedList。
• 如果需要考虑线程安全性，可以使用Vector，但在性能上会有一定的损耗。

需要根据具体的需求和场景选择合适的列表实现类。

86. ArrayList 和 Vector 的区别

ArrayList和Vector是Java集合框架中常用的动态数组实现类，它们有以下区别：

1. 线程安全性：

• ArrayList是非线程安全的，不同的线程可以同时对ArrayList进行操作，需要自行保证线程安全性。
• Vector是线程安全的，内部的方法都是同步的，多个线程不能同时对Vector进行修改操作。通过使用同步锁保证线程安全性。

2. 动态扩容：

• ArrayList和Vector在存储空间不足时会自动扩容，扩容策略是按照当前容量的一定比例增加。ArrayList的扩容因子是原容量的50%，而Vector的扩容因子是原容量的100%。
• 扩容时，ArrayList会创建一个新的数组，将旧数组中的元素复制到新数组中，而Vector则会将旧数组中的元素复制到新的容量达到旧容量加1的数组中。

3. 性能：

• ArrayList相对于Vector来说，在单线程环境下性能更好。因为ArrayList不需要考虑线程同步的开销，所以在读取和修改数组元素、遍历等操作上性能较好。
• Vector由于需要进行同步操作，性能相对较低。在多线程环境下，Vector会在一定程度上保证线程安全性，但会有额外的性能损耗。

示例：

// ArrayList
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("Apple");
arrayList.add("Banana");

// Vector
Vector<String> vector = new Vector<>();
vector.add("Apple");
vector.add("Banana");

综上所述，ArrayList和Vector的主要区别在于线程安全性和性能。如果不需要考虑线程安全性，并希望在单线程环境下获得更好的性能，推荐使用ArrayList。如果需要线程安全性，可以使用Vector，但在性能上会有一定的损耗。

87. 集合框架中 Collections 和 Arrays 类的作用集合框架中有两个很实用的公用类。

在集合框架中，有两个实用的公用类：Collections和Arrays。

Collections类提供了一系列的静态方法，用于操作和处理各种集合类型（如List、Set、Map等）。以下是Collections类的常见功能：

1. 集合操作：

• 排序：sort()方法可以对List进行排序，也可以通过指定Comparator来进行自定义排序。
• 查找和替换：binarySearch()方法可以进行二分查找；indexOfSubList()方法用于查找子列表的起始索引；replaceAll()方法可以替换列表中的元素。
• 最值和频率：max()和min()方法可获取列表中的最大值和最小值；frequency()方法可获取指定元素在列表中出现的频率。
• 随机化和洗牌：shuffle()方法可随机排列列表中的元素。

2. 不可变集合：

• unmodifiableXXX()方法可以创建一个不可变的集合，使其不可修改。

3. 同步集合：

• synchronizedXXX()方法可以创建一个线程安全的集合，使其支持多线程并发操作。

Arrays类提供了一些静态方法，用于操作和处理数组。以下是Arrays类的常见功能：

1. 数组操作：

• 排序：sort()方法可以对数组进行排序，也可以通过指定Comparator来进行自定义排序。
• 搜索：binarySearch()方法可以对有序数组进行二分查找。
• 比较：equals()方法用于比较两个数组是否相等。

2. 数组和集合的转换：

• asList()方法可以将数组转换为List。
• toArray()方法可以将集合转换为数组。

这些公用类提供了一些方便实用的方法，能够简化对集合和数组的操作。在使用集合框架和数组时，可以参考这些公用类来提高开发效率。

当使用集合框架中的集合类型或操作数组时，可以使用Collections类和Arrays类提供的方法来进行方便的操作。

举例说明如下：

1. Collections类的使用示例：

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(2);
        numbers.add(7);
        
        // 排序列表
        Collections.sort(numbers);
        System.out.println(numbers);  // 输出：[2, 5, 7]
        
        // 替换元素
        Collections.replaceAll(numbers, 5, 10);
        System.out.println(numbers);  // 输出：[2, 10, 7]
        
        // 随机化列表
        Collections.shuffle(numbers);
        System.out.println(numbers);  // 输出：随机的顺序
        
        // 检索元素的频率
        int frequency = Collections.frequency(numbers, 10);
        System.out.println("元素10出现的频率：" + frequency);  // 输出：元素10出现的频率：1
        
        // 创建不可修改的集合
        List<Integer> unmodifiableList = Collections.unmodifiableList(numbers);
        //unmodifiableList.add(1);  // 会抛出UnsupportedOperationException异常
        
        // 创建同步的集合
        List<Integer> synchronizedList = Collections.synchronizedList(numbers);
        // 可以线程安全地同时对synchronizedList进行操作
    }
}

2. Arrays类的使用示例：

import java.util.Arrays;

public class ArraysExample {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 7};
        
        // 排序数组
        Arrays.sort(numbers);
        System.out.println(Arrays.toString(numbers));  // 输出：[2, 5, 7]
        
        // 搜索元素
        int index = Arrays.binarySearch(numbers, 5);
        System.out.println("元素5的索引：" + index);  // 输出：元素5的索引：1
        
        // 比较数组
        int[] numbers2 = {1, 2, 3};
        boolean isEqual = Arrays.equals(numbers, numbers2);
        System.out.println("两个数组是否相等：" + isEqual);  // 输出：两个数组是否相等：false
        
        // 转换为列表
        Integer[] numbersArray = Arrays.stream(numbers).boxed().toArray(Integer[]::new);
        System.out.println(Arrays.asList(numbersArray));  // 输出：[2, 5, 7]
    }
}

以上示例演示了Collections类和Arrays类的一些常见用法，包括排序、搜索、比较、转换等操作，展示了它们在集合框架中的实用性。

88. 数据结构中,数组与链表有哪些区别？为什么？(重点)

在数据结构中，数组和链表是两种常见的数据存储和访问方式，它们之间有以下主要区别：

1. 存储方式：

• 数组是一段连续的内存空间，用于存储相同类型的元素。元素在内存中的位置是通过索引来确定的，即可以通过索引直接访问数组中的元素。
• 链表是一组通过指针链接的节点存储的集合。每个节点包含数据和指向下一个节点的指针。节点在内存中不一定是连续存储的，由指针链接进行连接。

2. 内存分配：

• 数组在创建时需要一次性分配连续的内存空间，大小固定，不方便动态调整。
• 链表的节点可以动态地分配内存空间，每个节点的大小可以根据需求动态改变。

3. 插入和删除操作的效率：

• 数组在插入和删除元素时涉及到元素的移动，如果在数组的中间或开头进行插入和删除操作，需要进行大量元素的移动，时间复杂度为O(n)。
• 链表在插入和删除元素时只需修改节点的指针，不需要移动其他元素，时间复杂度为O(1)。

4. 随机访问效率：

• 数组可以通过索引直接访问元素，时间复杂度为O(1)，即常数级别的操作。
• 链表需要从头节点开始依次遍历，直到达到目标节点，时间复杂度为O(n)，其中n为链表的长度。

5. 空间效率：

• 数组需要连续的内存空间来存储元素，如果数组的长度较大，但只占用部分空间，会造成内存浪费。
• 链表的节点可以动态分配内存，只占用实际元素所需的空间，没有内存浪费。

根据上述区别，数组适用于随机访问、插入和删除操作相对较少的场景，而链表适用于频繁的插入和删除操作，对随机访问性能要求相对较低的场景。需要根据实际需求和操作特点选择合适的数据结构。

89. 描述一下 JVM（JAVA 虚拟机）加载 class 文件的原理机制?

JVM（Java虚拟机）加载class文件的过程可以分为以下几个阶段：

1. 加载（Loading）：

• JVM通过类加载器（ClassLoader）找到指定的class文件，并将其加载到内存中。加载过程包括以下步骤：
  • 类的加载：通过类加载器根据类的全限定名查找并加载字节码文件。
  • 字节码校验：对加载的字节码进行验证，确保其符合Java虚拟机规范。
  • 内存分配：在方法区中为类的信息分配内存空间，并设置初始值。
  • 符号引用解析：将类中的符号引用（常量池中的符号地址）转化为直接引用（指向真实数据或方法的指针）。

2. 链接（Linking）：

• 链接阶段主要包括三个步骤：验证（Verification）、准备（Preparation）和解析（Resolution）。
  • 验证：对字节码进行验证，确保其语义和结构的正确性，防止错误的字节码被加载和执行。
  • 准备：为类的静态变量分配内存空间，并设置默认的初始值。
  • 解析：将常量池中的符号引用转化为指向方法区中运行时常量池的直接引用。

3. 初始化（Initialization）：

• 在初始化阶段，JVM会执行类的初始化代码（静态代码块或静态变量赋值语句）。初始化阶段的触发有多种情况，例如：
  • 创建类的实例。
  • 访问类的静态变量或静态方法。
  • 使用反射方式对类进行操作。

在加载、链接和初始化的过程中，JVM会对类进行必要的验证、准备工作和符号引用解析，最终将类加载到内存中，并可进行实例化和调用。

值得注意的是，JVM还使用了双亲委派模型来保证类的一致性和安全性。当需要加载类时，首先从顶层的引导类加载器（Bootstrap ClassLoader）开始查找，如果找不到，则依次向下层的类加载器发起类加载请求，直至找到所需的类或加载失败。这种层级结构的类加载器保证了类的唯一性，避免了同名类的冲突和安全问题。

90. ClassLoader（类加载器）如何加载 class 文件。

ClassLoader（类加载器）是Java虚拟机（JVM）的重要组成部分，负责将class文件加载到内存中并定义它们。类加载器根据一定的规则和策略加载class文件，其加载过程可以描述如下：

1. 搜索类文件：

• 类加载器首先根据类的全限定名（例如com.example.MyClass）转换成对应的文件路径形式（例如/com/example/MyClass.class）。
• 类加载器会按照特定的搜索顺序（双亲委派模型）在指定的路径下搜索class文件。搜索路径可以包括本地文件系统目录、JAR文件和其他网络资源等。

2. 读取类文件：

• 一旦搜索到class文件，类加载器会读取该文件的二进制数据流。
• 类加载器将类的二进制数据流转化为内存中的代表该类的结构，例如ClassLoader会将字节码转化为Class对象。

3. 定义类：

• 类加载器将读取到的类的二进制数据转化为特定的格式，并创建Class对象，将其放入方法区（JDK1.8及之前）或元空间（JDK1.8及之后）中。
• 定义类的过程包括解析类的常量池、验证类的结构和语义合法性等操作。

4. 链接和初始化类：

• 链接阶段包括验证、准备和解析等操作，确保类在加载后的合法性和正确性。
• 初始化阶段会执行类的静态初始化代码（静态代码块或静态变量赋值语句），该阶段触发的方式有多种，例如创建类的实例、访问静态成员等。

ClassLoader是Java虚拟机运行的重要组成部分，它通过加载、读取、定义和链接等过程，将class文件加载到内存中，使得Java程序可以进行类的实例化和调用。Java还提供了不同类型的类加载器，例如Bootstrap ClassLoader、ExtClassLoader和AppClassLoader等，它们按照一定的搜索顺序进行类的加载，保证类的唯一性和安全性。

91. Class.forName 的作用?为什么要用?

Class.forName(String className)是一个Java反射API中的方法，它的作用是动态加载指定类的字节码，并返回对应的Class对象。它的主要作用是：

1. 动态加载类：Class.forName()方法可以在运行时根据类名字符串动态地加载对应的类。在编译时，我们可能并不知道要加载的类的具体名字，而是在运行时根据条件或配置来决定加载哪个类，这时候就可以使用Class.forName()方法来实现动态加载。
2. 初始化静态部分：Class.forName()方法会初始化类的静态部分，包括静态变量的初始化和静态代码块的执行。这是因为在加载类的过程中，JVM会执行类的初始化操作。

为什么要使用Class.forName()？

1. 可插拔性：Class.forName()方法可以根据运行时的配置动态地加载类，从而实现可插拔的扩展功能。比如，很多框架和插件系统可以通过使用Class.forName()加载提供的扩展类或实现类来支持动态的功能扩展。
2. 代码解耦：使用Class.forName()可以将具体的类名字符串解耦出来，降低了代码的耦合性。通过灵活地配置类名字符串，可以轻松地更换要加载的类，实现不同的功能效果。

需要注意的是，Class.forName()方法会抛出ClassNotFoundException异常，如果指定的类找不到。在使用Class.forName()时，需要提供类的完整限定名，包括包名和类名。例如：

try {
    Class<?> clazz = Class.forName("com.example.MyClass");
    // 根据clazz进行动态加载和操作
} catch (ClassNotFoundException e) {
    // 处理类找不到的异常
}

总结：Class.forName()方法的主要作用是动态加载并初始化指定的类，它具有可插拔性和解耦的优点，可以实现动态扩展和配置。

92. 为什么要用 ORM? 和 JDBC 有何不一样?

ORM（对象关系映射）和JDBC（Java数据库连接）是两种用于进行数据库操作的不同技术，它们有以下不同之处：

1. 数据模型：

• JDBC是一种底层的数据库操作API，它提供了一组用于执行SQL语句的方法，通过JDBC可以直接操作数据库表和记录。
• ORM是一种高级的技术，它通过映射对象与数据库的关系，将数据库表结构和数据转化为对象，让开发者以面向对象的方式进行数据库操作。

2. 编程风格：

• JDBC需要开发者手动编写SQL语句，并使用JDBC API来执行和处理SQL操作，需要对数据库的底层细节有一定的了解。
• ORM通过框架自动完成对象与数据库表之间的映射，开发者只需要操作对象，使用面向对象的编程风格来进行数据库操作，减少了编写SQL语句的工作。

3. 性能和效率：

• JDBC直接操作数据库，可以更灵活地控制SQL语句的编写和执行过程，对于复杂的查询和特定需求的操作，可以更高效地实现。
• ORM虽然提供了方便的对象操作方式，但在某些场景下可能由于额外的映射操作导致性能下降。但ORM框架通常会提供一些高级功能，如缓存、延迟加载等，可以优化数据库访问的效率。

4. 跨数据库兼容性：

• JDBC是标准的数据库访问API，可以与不同的关系型数据库进行交互，具有很好的跨数据库兼容性。
• ORM框架在实现上会针对不同的数据库提供相应的方言和特性支持，但由于每个ORM框架的实现不同，对于不同的数据库可能存在一定的兼容性问题。

综上所述，ORM和JDBC在数据库操作的方法、编程风格、性能和效率以及跨数据库兼容性等方面有所不同。选择使用ORM还是JDBC取决于具体的开发需求和项目情况，如果需要更底层的数据库控制和特定数据库的兼容性，可以选择使用JDBC；如果需要更高级的面向对象的开发方式和快速开发，可以选择使用ORM框架。

93. JDBC 中的 PreparedStatement 相比 Statement 的好处(最后一句话是重点) (重点)

在JDBC中，PreparedStatement是Statement的子接口，它提供了相比Statement更多的好处和优势，并且最重要的区别在于预编译和防止SQL注入的能力。

1. 预编译：

• PreparedStatement可以对SQL语句进行预编译，即在SQL语句执行前，数据库会对其进行编译和优化，提高了执行的效率。
• 在重复执行相同或类似的SQL语句时，使用PreparedStatement可以重复利用已编译的SQL执行计划，提升了性能。

2. 参数化查询：

• PreparedStatement支持参数化查询，即可以将动态参数绑定到预编译的SQL语句中。
• 通过设置参数，可以安全地将用户输入传递给数据库，避免了拼接字符串引发的SQL注入攻击。

举例说明：

// 使用Statement执行查询（存在SQL注入风险）
String username = request.getParameter("username");
String password = request.getParameter("password");
String sql = "SELECT * FROM users WHERE username = '" + username + "' AND password = '" + password + "'";
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(sql);

// 使用PreparedStatement执行查询（避免SQL注入）
String username = request.getParameter("username");
String password = request.getParameter("password");
String sql = "SELECT * FROM users WHERE username = ? AND password = ?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, username);
preparedStatement.setString(2, password);
ResultSet resultSet = preparedStatement.executeQuery();

在上述例子中，使用Statement进行查询时，如果用户输入了恶意的参数，例如' OR '1'='1，则会导致查询结果不符合预期，甚至可能会造成数据泄露。而使用PreparedStatement进行参数化查询，可以确保输入的参数被正确地解析和处理，从而防止了SQL注入攻击。

总结：PreparedStatement相比Statement的好处在于预编译和防止SQL注入的能力，它可以提高执行效率，同时保证了数据库操作的安全性。因此，优先使用PreparedStatement可以提高代码的效率和安全性。

94. 分层开发的优势。

分层开发是一种软件开发的架构设计模式，将软件系统划分为多个层次，每个层次负责不同的功能和责任。分层开发的优势如下：

1. 模块化和可维护性：

• 分层开发将系统划分为多个模块，每个模块都有清晰的责任和功能。
• 模块化的设计使得系统更易于维护和扩展，因为可以独立地修改或替换某个层次的代码，而无需影响其他层次。

2. 代码复用和可测试性：

• 每个层次都专注于不同的功能，可以重复使用和测试。
• 每个层次之间通过定义良好的接口进行通信，从而实现松耦合的架构，方便进行单元测试和模块的替换或独立开发。

3. 可扩展性和灵活性：

• 分层开发使得应用程序的不同层次可以独立地进行扩展和修改，而无需影响其他层次。
• 当需要增加新的功能或业务需求时，可以通过新增或修改某个层次的代码来实现，而不会影响整个系统。

4. 安全性和权限控制：

• 划分不同的层次可以实现安全性和权限的控制。
• 例如，将数据访问层与业务逻辑层分离，可以更好地控制对数据的访问权限，提高系统的安全性。

5. 提高开发效率：

• 分层开发使得开发团队可以并行开发不同层次的代码，从而提高开发效率。
• 不同的开发人员可以专注于各自负责的层次，降低沟通成本和开发时间。

总结：分层开发的优势包括模块化和可维护性、代码复用和可测试性、可扩展性和灵活性、安全性和权限控制以及提高开发效率。通过明确划分各个层次的职责，分层开发可以提供更好的代码组织、可维护性、扩展性和安全性等优势，为软件开发带来诸多好处。

95. 分层开发的原则特点。

分层开发是一种常用的软件架构设计模式，它具有以下原则和特点：

1. 单一职责原则（SRP）：

• 每个层次应该有清晰的责任和功能，不要承担过多的职责。
• 每个层次应该专注于自己的任务，使得代码的职责划分清晰，易于理解和维护。

2. 松耦合性：

• 各个层次之间通过定义良好的接口进行通信，实现松耦合的架构。
• 松耦合性使得层次之间可以独立地开发、测试和扩展，一个层次的变化不会对其他层次造成影响。

3. 高内聚性：

• 每个层次应该具有高内聚性，即其中的元素彼此紧密相关，通过共同目标和职责进行协作。
• 高内聚性可以提高代码的可读性、维护性和重用性。

4. 接口定义：

• 各层次之间通过接口定义进行通信，层次间的相互作用通过接口进行统一。
• 接口定义明确了各层次的协作方式，使得不同层次之间的交互更加规范和可控。

5. 可测试性：

• 分层开发使得不同层次的代码可以独立地进行单元测试，方便进行测试驱动开发（TDD）和保证代码质量。

6. 分工合作：

• 分层开发使得开发任务可以分工进行，不同开发人员可以专注于各自负责的层次。
• 分工合作可以提高开发效率和团队协作效果。

总结：分层开发的原则特点主要包括单一职责原则、松耦合性、高内聚性、接口定义、可测试性和分工合作。通过这些原则和特点，分层开发可以提供清晰的架构划分、灵活的模块协作和高效的开发方式，使得软件系统具备可维护、可测试和可扩展的优势。

96. Java 中有几种类型的流？JDK 为每种类型的流提供了一些抽象类以供继承,请说出他们分别是哪些类？

在Java中，流（Stream）根据数据的不同方向和类型可以分为两种类型的流：字节流和字符流。

1. 字节流：

• 字节流以字节为单位进行输入和输出，适用于处理二进制数据或字节流的场景。
• JDK提供了两个抽象类用于字节流：InputStream（输入流）和OutputStream（输出流）。

2. 字符流：

• 字符流以字符为单位进行输入和输出，适用于处理文本数据的场景，提供了更方便的字符处理方法。
• JDK提供了两个抽象类用于字符流：Reader（字符输入流）和Writer（字符输出流）。

具体的抽象类如下：

1. InputStream（字节输入流的抽象类）的常用子类：

• FileInputStream：从文件读取字节流的类。
• BufferedInputStream：提供缓冲功能的字节输入流。
• ByteArrayInputStream：从字节数组读取字节流的类。

2. OutputStream（字节输出流的抽象类）的常用子类：

• FileOutputStream：向文件写入字节流的类。
• BufferedOutputStream：提供缓冲功能的字节输出流。
• ByteArrayOutputStream：向字节数组写入字节流的类。

3. Reader（字符输入流的抽象类）的常用子类：

• FileReader：从文件读取字符流的类。
• BufferedReader：提供缓冲功能的字符输入流。
• InputStreamReader：字节流到字符流的桥接器。

4. Writer（字符输出流的抽象类）的常用子类：

• FileWriter：向文件写入字符流的类。
• BufferedWriter：提供缓冲功能的字符输出流。
• OutputStreamWriter：字符流到字节流的桥接器。

通过使用这些抽象类，我们可以方便地处理不同类型的流，并根据具体的需求选择合适的流类型进行操作。
在Java中，可以根据处理数据的类型和方向，分为字节流和字符流两种类型的流。以下是这两种类型的流以及对应的抽象类和子类的举例说明：

1. 字节流：

• InputStream：字节输入流的抽象类。

  • FileInputStream：从文件中读取字节的类。

  InputStream input = new FileInputStream("file.txt");
  int data = input.read();
  

• OutputStream：字节输出流的抽象类。

  • FileOutputStream：向文件写入字节的类。

  OutputStream output = new FileOutputStream("file.txt");
  output.write(data);
  

2. 字符流：

• Reader：字符输入流的抽象类。

  • FileReader：从文件中读取字符的类。

  Reader reader = new FileReader("file.txt");
  int data = reader.read();
  

• Writer：字符输出流的抽象类。

  • FileWriter：向文件写入字符的类。

  Writer writer = new FileWriter("file.txt");
  writer.write(data);
  

这些抽象类提供了基本的功能和操作方法，而具体的子类根据功能的不同提供了更多的特定功能，如缓冲处理、转换处理等。通过这些抽象类和具体子类，我们可以根据需求选择合适的流来进行数据的输入和输出操作。

97. 字节流与字符流的区别？(重点)

字节流和字符流是Java I/O流中的两种不同类型流，它们在处理数据的方式和适用场景上存在一些区别。

1. 数据单位：

• 字节流：以字节为单位进行读写。适合处理二进制数据或者字节数据，如图像、音频、视频等。
• 字符流：以字符为单位进行读写。适合处理文本数据，如文本文件、字符串等。

举例说明：

使用字节流读取和写入文件：

// 字节流读取文件
InputStream fileInput = new FileInputStream("file.txt");
int data = fileInput.read();

// 字节流写入文件
OutputStream fileOutput = new FileOutputStream("file.txt");
fileOutput.write(data);

使用字符流读取和写入文本文件：

// 字符流读取文件
Reader fileReader = new FileReader("file.txt");
int data = fileReader.read();

// 字符流写入文件
Writer fileWriter = new FileWriter("file.txt");
fileWriter.write(data);

2. 编码处理：

• 字节流：处理字节数据，不涉及数据编码，直接按字节进行读写。
• 字符流：处理字符数据，通过字符编码将字符转换为字节进行读写。可以处理不同字符编码的文件，如UTF-8、GBK等。

举例说明：

使用字节流读取和写入文件：

// 字节流读取文件
InputStream fileInput = new FileInputStream("file.txt");
int data = fileInput.read();

// 字节流写入文件
OutputStream fileOutput = new FileOutputStream("file.txt");
fileOutput.write(data);

使用字符流读取和写入文本文件：

// 字符流读取文件
Reader fileReader = new FileReader("file.txt");
int data = fileReader.read();

// 字符流写入文件
Writer fileWriter = new FileWriter("file.txt");
fileWriter.write(data);

总结：
字节流和字符流在处理数据的单位和编码处理上存在差异。字节流适用于处理二进制数据，而字符流适用于处理文本数据。在选择使用字节流还是字符流时，需根据具体的数据类型和需求来确定。

98. 什么是java 序列化,如何实现java 序列化？或者请解释Serializable 接口的作用. (重点)

Java序列化是一种将Java对象转换为字节序列的过程，并且可以在需要时将字节序列重新转换为相应的对象的过程。通过序列化，可以将对象保存到磁盘或通过网络进行传输，从而实现对象的持久化存储和跨网络的传输。

要实现Java的序列化，需要满足以下条件：

1. 实现Serializable接口：实现该接口是实现Java序列化的关键。Serializable接口是一个标记接口，没有定义任何方法，仅用于标识类的实例可以序列化。

2. 版本控制：为了保证序列化和反序列化的兼容性，需要给序列化类提供一个唯一的版本号。可以通过在类中添加一个名为serialVersionUID的静态变量来实现版本控制。

示例代码：

import java.io.Serializable;

// 实现Serializable接口
public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private String name;
    private int age;

    // 构造方法和其他方法
    
    // 获取和设置方法
    
    // 其他业务逻辑
}

在上述示例中，Person类实现了Serializable接口，同时定义了serialVersionUID作为版本控制变量。通过这样的实现，Person类的对象可以进行序列化和反序列化操作。

Serializable接口的作用：

• 标识类的实例可以进行序列化，使得对象可以被保存、传输和恢复。
• 提供了一个规范，要求序列化类的实例必须满足一些特定的规则和约束，以保证序列化和反序列化的正确性。
• 可以作为JVM进行对象序列化和反序列化操作时的检查依据，如在网络传输中确保对象正确传输、在分布式系统中进行对象的远程调用等。

总结：Java序列化是将Java对象转换为字节序列的过程。要实现Java序列化，需要实现Serializable接口并提供版本控制。Serializable接口的作用是标识类的实例可以序列化，提供序列化的规范和约束，并在序列化和反序列化过程中作为检查依据。

Serializable接口是Java中的一个接口，它用于通过将对象转换为字节流的方式实现对象的序列化和反序列化。当一个类实现了Serializable接口时，它可以被表示为一个字节序列，这个字节序列可以被写入到文件、网络流中或者存储在内存中，并且可以在以后重新通过反序列化将其转换回原始对象。

Serializable接口的作用有以下几点：

1. 持久化对象：通过实现Serializable接口，可以将一个对象的状态持久化保存在磁盘或数据库中，以便于以后恢复对象的状态。这对于需要保存和传输对象的应用程序非常有用，比如分布式系统、缓存系统等。

2. 网络传输：通过序列化和反序列化，可以将一个对象转换为字节流，从而在网络中进行传输。这使得分布式系统中的不同节点之间可以传递对象，实现远程方法调用或者分布式对象传递等功能。

3. Java集合类的序列化：Java集合类中的一些实现（如ArrayList、HashMap等）已经实现了Serializable接口，这意味着可以将它们序列化并保存到文件中，或者在网络中传输。

4. 版本控制：序列化的对象具有版本号，可以在对象结构发生变化时通过版本号来进行兼容性判断。这在进行升级和演化时非常有用，可以确保不同版本之间的对象能够正确序列化和反序列化。

需要注意的是，对于安全性敏感的类，比如包含密码、密钥等敏感信息的类，需要谨慎使用Serializable接口，因为对象的序列化操作可以将这些信息暴露在外部。在这种情况下，可以通过实现自定义的序列化和反序列化逻辑来控制对象的序列化过程。

99. 序列化的概念和序列化 ID 的作用？(这题需要看看)

序列化是指将对象转换为字节序列以便于存储、传输或持久化的过程。在Java中，通过实现Serializable接口可以使一个对象可被序列化。序列化过程将对象的状态转换为字节序列，可以将字节序列写入文件、网络或内存中，并且可以在需要时通过反序列化将其重新转换为对象。

序列化ID（Serialization ID）是在序列化和反序列化过程中对序列化类的版本进行识别的一种机制。每个Serializable类都有一个默认的序列化ID，称为默认序列化ID。默认序列化ID是通过根据类的结构自动生成的，并且它是基于类的名称、签名和其他属性计算得出的。

序列化ID的作用有以下几点：

1. 版本控制：序列化ID用于在反序列化时验证类的版本是否与序列化时的版本一致。如果类的结构发生了变化，如添加、删除或修改了字段或方法，那么默认的序列化ID也会发生变化，这意味着旧的序列化数据无法与新的类版本兼容。通过序列化ID，可以在反序列化过程中对版本进行检查，从而确保对象的兼容性。

2. 避免冲突：如果没有显式指定序列化ID，那么每次类的结构发生变化时，都会根据默认机制生成一个新的序列化ID。这可能会导致不同的类版本具有不同的序列化ID，从而导致反序列化时的冲突。通过显式指定序列化ID，可以确保序列化ID在不同版本之间保持一致，避免因为版本变化而引起的冲突。

3. 提高性能：由于序列化ID在序列化和反序列化过程中用于版本检查，比较序列化ID的操作是非常高效的。在反序列化时，如果序列化ID匹配，可以直接进行反序列化操作，而无需进行更复杂的对象兼容性检查，从而提高性能。

总之，序列化ID在Java序列化机制中起着重要的作用，它用于版本控制、避免冲突以及提高性能。通过显式指定序列化ID，可以确保类在不同版本之间的兼容性，并且可以提供更好的对象序列化和反序列化的效率。

100. 什么是 URL？

URL是统一资源定位符（Uniform Resource Locator）的缩写，是用于标识和定位互联网上的资源的字符串格式。

URL由多个部分组成，包括协议、主机名、端口号、路径、查询参数和片段标识等组成。

一个典型的URL的结构如下：

协议://主机名:端口号/路径?查询参数#片段标识

• 协议（Protocol）：指定了访问资源所使用的协议，常见的有HTTP、HTTPS、FTP等。
  示例：http://、https://、ftp://

• 主机名（Hostname）：指定了资源所在的主机的域名或IP地址。
  示例：www.example.com、192.168.0.1

• 端口号（Port）：指定了用于访问资源的端口号，默认情况下，HTTP使用80端口，HTTPS使用443端口。
  示例：:80、:8080

• 路径（Path）：指定了资源在服务器上的具体路径。
  示例：/index.html、/blog/post/123

• 查询参数（Query Parameters）：用于向服务器传递额外的参数，一般以键值对的形式表示，多个参数之间使用&符号分隔。
  示例：?name=John&age=25

• 片段标识（Fragment Identifier）：指定了在资源中的一个片段或锚点，常用于定位到网页的特定部分。
  示例：#section1、#header

URL通过将上述部分组合起来，提供了一种标准化的方式来访问和定位互联网上的各种资源，包括网页、图像、视频、文件等。浏览器通过解析URL可以找到资源所在的服务器，并加载并显示对应的内容。