面经第三天（补）、第四天

内部类在 Java 中有多种类型，每种类型有不同的应用场景。让我为你提供一些具体的示例：

1. 成员内部类：成员内部类是定义在另一个类中的普通类。它通常用于访问外部类的成员，包括私有成员。一个常见的应用场景是使用成员内部类来实现迭代器模式。

class MyContainer {
    private Object[] elements;
    
    public MyContainer(Object[] elements) {
        this.elements = elements;
    }
    
    public class MyIterator {
        private int index = 0;
        
        public boolean hasNext() {
            return index < elements.length;
        }
        
        public Object next() {
            return elements[index++];
        }
    }
    
    public MyIterator iterator() {
        return new MyIterator();
    }
}

public class Main {
    public static void main(String[] args) {
        MyContainer container = new MyContainer(new Object[]{1, 2, 3, 4, 5});
        MyContainer.MyIterator iterator = container.iterator();
        
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

使用迭代器进行遍历输出具有以下好处相比使用普通的 for 循环：

1. 封装性：迭代器封装了容器的遍历逻辑，用户不需要了解容器内部的数据结构和索引，提供了更高的抽象层次。？

2. 统一的接口：迭代器为不同类型的容器提供了统一的遍历接口，这意味着可以使用相同的方式来访问不同类型的容器（例如，数组、链表、集合等）。？

3. 安全性：使用迭代器遍历时，不会出现越界错误，因为迭代器内部已经处理了边界条件，从而避免了可能的数组越界或集合溢出。？？？

4. 支持并发：某些迭代器实现可以支持并发访问，使多线程环境下的遍历更加安全。？

5. 可读性：迭代器的代码通常更加清晰和易读，它通过迭代的方式逐个访问元素，而不需要手动管理索引和边界条件。？

总之，使用迭代器能够提供更好的代码组织、可读性和安全性，同时具有更好的适用性，使代码更容易维护和扩展。因此，迭代器通常是遍历容器的首选方法。

2. 静态内部类：静态内部类不依赖外部类的实例，可以直接创建。它常用于将一个类封装在另一个类中，以便更好地组织代码。

class Outer {
    static class Inner {
        void doSomething() {
            System.out.println("Doing something in Inner class.");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
        inner.doSomething();
    }
}

静态内部类在企业应用中有许多用途，它通常用于将一个类封装在另一个类中，以实现更好的代码组织和封装性。以下是一个实际案例，使用静态内部类来实现数据库连接池：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;

public class ConnectionPool {
    private static final String URL = "jdbc:mysql://localhost:3306/mydb";
    private static final String USER = "username";
    private static final String PASSWORD = "password";
    private static final int INITIAL_POOL_SIZE = 10;

    // 使用静态内部类来实现连接池中的连接对象
    private static class PooledConnection {
        Connection connection;

        PooledConnection() {
            try {
                connection = DriverManager.getConnection(URL, USER, PASSWORD);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        public Connection getConnection() {
            return connection;
        }
    }

    private LinkedList<PooledConnection> connections = new LinkedList<>();

    // 创建连接池并初始化连接对象
    public ConnectionPool() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            for (int i = 0; i < INITIAL_POOL_SIZE; i++) {
                connections.add(new PooledConnection());
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    // 从连接池中获取连接对象
    public Connection getConnection() {
        if (connections.isEmpty()) {
            System.out.println("No available connections");
            return null;
        }
        return connections.poll().getConnection();
    }

    // 将连接对象放回连接池
    public void releaseConnection(Connection connection) {
        if (connection != null) {
            connections.add(new PooledConnection());
        }
    }
    
    // 关闭连接池，释放资源
    public void close() {
        for (PooledConnection pooledConnection : connections) {
            try {
                pooledConnection.getConnection().close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个示例中，ConnectionPool 类是一个数据库连接池，它使用了静态内部类 PooledConnection 来管理连接对象。这个设计使得连接池的内部实现可以更好地封装，而外部用户只需要调用 getConnection 和 releaseConnection 方法来获取和释放连接。

静态内部类可以轻松地和外部类进行通信，同时也能够实现更好的封装，确保连接对象的创建和管理都受到封装的保护。这种设计在企业级应用中的数据库连接池等场景中非常有用。
3. 局部内部类：局部内部类是定义在一个方法内部的类。它通常用于解决某个方法的特定问题。

class Calculator {
    public int add(int a, int b) {
        class Adder {
            int performAddition() {
                return a + b;
            }
        }
        Adder adder = new Adder();
        return adder.performAddition();
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        int result = calculator.add(5, 3);
        System.out.println("Result: " + result);
    }
}

在这个例子中，它允许在 add 方法内部创建一个可以执行加法操作的内部类。
4. 匿名内部类：匿名内部类是没有显式名称的内部类，通常在创建接口的实例时使用。这种内部类通常用于创建临时、一次性的对象。

interface Greeting {
    void greet();
}

public class Main {
    public static void main(String[] args) {
        // 创建一个匿名内部类实现 Greeting 接口
        Greeting anonymousGreeting = new Greeting() {
            @Override
            public void greet() {
                System.out.println("Hello from anonymous inner class!");
            }
        };
        
        // 调用匿名内部类的 greet 方法
        anonymousGreeting.greet();
    }
}

这个代码展示了匿名内部类的用法，通常用于创建临时的、简单的类实例，而不必显式定义一个具名的类。这在某些情况下可以简化代码并增加代码的可读性。

每种类型的内部类都有其独特的应用场景和优点，可以根据具体需求选择合适的类型。

MySQL 数据库

1、什么是数据库事务？讲⼀下事务的 ACID 特性？
官⽅解析
数据库事务是指数据库管理系统（DBMS）中的⼀个操作序列，这些操作必须作为⼀个不可分割的单元执⾏，即要么全部执⾏成功，要么全部失败回滚。事务通常涉及到对数据库中的数据进⾏读写操作。
事务的ACID特性指四个关键特征：原⼦性（Atomicity）、⼀致性（Consistency）、隔离性（Isolation）和持久性（Durability）。

概念

数据库事务是一系列数据库操作组成的工作单元，这些操作必须被视为一个不可分割的整体，要么全部成功执行，要么全部不执行。数据库事务通常涉及对数据库中的数据进行读取和写入操作，例如插入、更新、删除等。

事务的 ACID 特性如下：

1. 原子性（Atomicity）：原子性指事务是不可分割的单位，要么全部执行成功，要么全部执行失败。如果事务中的任何一个操作失败，整个事务都会被回滚，回到事务开始前的状态。这确保了数据库中的数据一致性。

2. 一致性（Consistency）：一致性要求事务在执行前后，数据库的完整性约束仍然保持。这意味着事务的执行不会破坏数据库的一致性，如果事务执行成功，数据库应该从一个一致的状态转移到另一个一致的状态。

3. 隔离性（Isolation）：隔离性指多个并发事务在执行时应该相互隔离，一个事务的执行不应该影响其他事务，每个事务应该感觉自己在操作整个数据库。这可以防止并发执行时的数据不一致问题。

4. 持久性（Durability）：持久性确保一旦事务成功提交，对数据库的改变将被永久保存，即使在系统崩溃后也不会丢失。这通常涉及将事务的变化写入数据库的持久存储（如磁盘）。

示例

1. 原子性（Atomicity）：考虑一个电子商务网站的订单处理。当客户下订单时，订单包括减少库存、生成订单记录和扣除支付等多个操作。如果其中一个操作失败，整个订单处理应该回滚，以防止出现库存错误或未支付的订单。

2. 一致性（Consistency）：假设有一个银行应用，客户要在两个账户之间进行转账。一致性要求在转账事务中，无论哪个账户扣款或增款，总的账户余额应该保持不变，以维护银行账户的一致性。

3. 隔离性（Isolation）：考虑一个在线酒店预订系统，多个用户同时尝试预订同一家酒店的最后一个房间。在一个事务中，应该隔离这些操作，以防止多个用户同时预订相同的房间，从而导致超卖。

4. 持久性（Durability）：在一个社交媒体应用中，当用户发布状态或图片时，应该确保这些内容是持久的，即使应用服务器崩溃。持久性要求将用户的状态或图片数据写入持久存储（如数据库）以确保不会丢失。

这些示例强调了 ACID 特性在不同领域的应用。在每种情况下，ACID 特性有助于维护数据的完整性、一致性和可靠性。