Java 面试题库-B（含答案）

最近更新：2025-06-20 | 字数总计：23.1k

1、Spring、事务、AOP相关注解

Spring事务管理相关注解
- @Transactional: 用于声明事务，可以应用于类或方法上。若应用于类，则类中所有方法均受事务管理；若应用于方法，则仅该方法受事务管理。
- 相关属性包括：
  - value: 指定事务管理器的bean名称。
  - transactionManager: 指定事务管理器。
  - timeout: 设置事务超时时间。
  - readOnly: 指定事务是否为只读。
  - rollbackFor: 指定遇到指定异常时回滚事务。
  - noRollbackFor: 指定遇到指定异常时不回滚事务。
Spring AOP相关注解
- @Aspect: 定义一个切面。
- @Pointcut: 定义切点，用于指定哪些方法可以被通知。
- 通知注解：
  - @Before: 在方法执行前执行通知。
  - @After: 不论方法执行是否成功，都在方法执行后执行通知。
  - @AfterReturning: 在方法成功执行后执行通知。
  - @AfterThrowing: 在方法抛出异常后执行通知。
  - @Around: 在方法执行前后执行通知，可以控制方法的执行。
- @Order: 指定切面的执行顺序。
- @EnableAspectJAutoProxy: 启用AspectJ自动代理，使切面生效。
  最终答案
  Spring中与事务、AOP相关的注解主要包括@Transactional、@Aspect、@Pointcut、@Before、@After、@AfterReturning、@AfterThrowing、@Around、@Order和@EnableAspectJAutoProxy。

2、java基础(继承、接口、多线程)

继承：允许子类复用父类的代码，并可以扩展或重写父类的方法。

接口：定义了一组方法，实现接口的类必须提供这些方法的具体实现。

多线程：允许程序同时执行多个任务，可以通过继承 Thread 类或实现 Runnable 接口来创建线程。

3、正则表达式

正则表达式是一种用于匹配和处理文本的强大工具。它可以用于验证输入、提取信息、替换文本等操作。

4、数据库(索引、三范式、Gbase、大数据)

索引：用于提高数据库查询性能的一种数据结构。可以加速数据检索，减少磁盘 I/O。

三范式：数据库设计的基本原则，包括第一范式（确保每列都是原子性的）、第二范式（确保表中的每个非主属性完全依赖于主键）和第三范式（确保表中的每个非主属性不依赖于其他非主属性）。

Gbase：一种关系型数据库管理系统，具有高性能、高可用性和可扩展性。

大数据：指处理和分析大规模数据的技术和方法。大数据技术包括分布式计算、数据存储和分析等。

5、Linux(基础命令、vim操作、权限)

基础命令：包括文件和目录操作、进程管理、网络配置等。

vim操作：是一个强大的文本编辑器，用于编辑文本文件。

权限：Linux系统中的文件和目录权限控制，包括所有者、组和其他用户的读、写和执行权限。

6、编程题给定一个int数组数组内三个数相加求最大值数据范围为-10000 到10000 数组最少包含3个数字

要解决这个问题，我们可以通过遍历数组中的所有可能的三元组，计算它们的和，并找到其中的最大值。由于数组的长度可能很大，我们需要确保算法的效率。

思路：

暴力法：直接遍历所有可能的三元组，计算它们的和，并记录最大值。这种方法的时间复杂度为 O(n^3)，适用于小规模数据。
排序法：先对数组进行排序，然后固定一个数，使用双指针法找到另外两个数，使得三数之和最大。这种方法的时间复杂度为 O(n^2)，适用于大规模数据。

方法 1：暴力法

public class MaxThreeSum {
    public static int maxThreeSum(int[] nums) {
        int maxSum = Integer.MIN_VALUE;
        int n = nums.length;
        for (int i = 0; i < n - 2; i++) {
            for (int j = i + 1; j < n - 1; j++) {
                for (int k = j + 1; k < n; k++) {
                    int currentSum = nums[i] + nums[j] + nums[k];
                    if (currentSum > maxSum) {
                        maxSum = currentSum;
                    }
                }
            }
        }
        return maxSum;
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        System.out.println("Maximum three sum is: " + maxThreeSum(nums));
    }
}

方法 2：排序法

import java.util.Arrays;

public class MaxThreeSum {
    public static int maxThreeSum(int[] nums) {
        Arrays.sort(nums);
        int n = nums.length;
        // 最大的三个数之和
        return nums[n - 1] + nums[n - 2] + nums[n - 3];
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        System.out.println("Maximum three sum is: " + maxThreeSum(nums));
    }
}

解释：

暴力法：通过三重循环遍历所有可能的三元组，计算它们的和，并记录最大值。这种方法简单直接，但时间复杂度较高。
排序法：先对数组进行排序，然后直接取最后三个数相加，因为它们是数组中最大的三个数。这种方法的时间复杂度主要由排序决定，为 O(n log n)，比暴力法更高效。

测试用例：

public static void main(String[] args) {
    int[] nums1 = {1, 2, 3, 4, 5};
    System.out.println("Maximum three sum is: " + maxThreeSum(nums1)); // 输出 12

    int[] nums2 = {-1, -2, -3, -4, -5};
    System.out.println("Maximum three sum is: " + maxThreeSum(nums2)); // 输出 -6

    int[] nums3 = {0, 0, 0, 0, 0};
    System.out.println("Maximum three sum is: " + maxThreeSum(nums3)); // 输出 0
}

总结：

如果数组长度较小（例如小于 100），可以使用暴力法。
如果数组长度较大，建议使用排序法，因为它更高效。

7、linux基础命令

文件和目录操作：
- ls：列出目录中的文件和子目录。
- cd：改变当前工作目录。
- mkdir：创建新目录。
- rm：删除文件或目录。
- cp：复制文件或目录。
- mv：移动或重命名文件或目录。
文件内容操作：
- cat：显示文件内容。
- head：显示文件开头的内容。
- tail：显示文件结尾的内容。
- grep：在文件中搜索文本。
- sed：对文件进行编辑。
进程管理：
- ps：列出当前正在运行的进程。
- kill：终止进程。
- top：显示实时进程状态。
- bg：将后台进程置于前台运行。
- fg：将后台进程置于前台运行。
网络配置：
- ifconfig：显示网络接口信息。
- ping：测试网络连接。
- netstat：显示网络连接、路由表和网络接口状态。
- ssh：远程登录到另一台计算机。
用户和权限：
- whoami：显示当前用户。
- su：切换用户。
- chmod：更改文件或目录的权限。
- chown：更改文件或目录的所有者。
系统信息：
- uname：显示系统信息。
- uptime：显示
- free：显示系统内存使用情况。
- df：显示磁盘空间使用情况。
文件压缩和解压：
- tar：创建、提取和压缩文件。
- gzip：压缩文件。
- gunzip：解压缩文件。
文件搜索：
- find：在文件系统中搜索文件。
- locate：快速查找文件。
系统管理：
- reboot：重启系统。
- shutdown：关闭系统。
系统日志：
- dmesg：显示系统启动信息。
- journalctl：显示系统日志。
磁盘管理：
- fdisk：管理磁盘分区。
- mkfs：格式化磁盘分区。
- mount：挂载文件系统。
服务管理：
- systemctl：管理系统服务。
- service：管理系统服务（旧版）。
包管理：
- apt：Ubuntu 和 Debian 系统的包管理工具。
- yum：Red Hat 和 CentOS 系统的包管理工具。
系统更新：
- apt-get update：更新软件包列表。
- apt-get upgrade：升级已安装的软件包。
- yum update：更新软件包列表。
- yum upgrade：升级已安装的软件包。
系统监控：
- top：显示实时进程状态。
- htop：交互式进程查看器。
- vmstat：显示虚拟内存统计信息。
- iostat：显示磁盘 I/O 统计信息。
系统优化：
- sysctl：调整系统内核参数。
- tune2fs：调整文件系统参数。
- sysbench：性能测试工具。
系统安全：
- firewall-cmd：管理防火墙。
- iptables：管理防火墙规则。
- auditd：系统审计。

8、spring与springboot注解

Spring 和 Spring Boot 提供了大量的注解来简化开发，以下是一些常见的注解及其用途：

Spring 常用注解

@Component
- 用于标记一个类为 Spring 的组件（Bean），Spring 会自动扫描并管理这些组件。
@Service
- 用于标记一个类为服务层组件，通常用于业务逻辑层。
@Repository
- 用于标记一个类为数据访问层组件，通常用于 DAO 层。
@Controller
- 用于标记一个类为控制器组件，通常用于 MVC 模式中的控制器层。
@Autowired
- 用于自动注入依赖，Spring 会自动找到匹配的 Bean 并注入。
@Qualifier
- 当有多个相同类型的 Bean 时，用于指定具体的 Bean。
@Configuration
- 用于标记一个类为配置类，通常与 @Bean 注解一起使用。
@Bean
- 用于在配置类中定义一个 Bean，Spring 会管理这个 Bean 的生命周期。
@Value
- 用于注入配置文件中的属性值。
@Scope
- 用于指定 Bean 的作用域，如 singleton、prototype 等。
@PostConstruct
- 用于标记一个方法，该方法在 Bean 初始化后执行。
@PreDestroy
- 用于标记一个方法，该方法在 Bean 销毁前执行。
@RequestMapping
- 用于映射 HTTP 请求到控制器方法。
@RequestParam
- 用于将 HTTP 请求参数绑定到方法参数。
@PathVariable
- 用于将 URL 中的模板变量绑定到方法参数。
@ResponseBody
- 用于将方法返回值直接写入 HTTP 响应体。
@RequestBody
- 用于将 HTTP 请求体绑定到方法参数。
@Transactional
- 用于声明事务管理，通常用于服务层方法。

Spring Boot 常用注解

@SpringBootApplication
- 用于标记一个类为 Spring Boot 应用的入口类，相当于 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 的组合。
@EnableAutoConfiguration
- 用于启用 Spring Boot 的自动配置机制。
@ComponentScan
- 用于指定 Spring 扫描组件的包路径。
@RestController
- 用于标记一个类为 RESTful 控制器，相当于 @Controller 和 @ResponseBody 的组合。
@GetMapping
- 用于映射 HTTP GET 请求到控制器方法。
@PostMapping
- 用于映射 HTTP POST 请求到控制器方法。
@PutMapping
- 用于映射 HTTP PUT 请求到控制器方法。
@DeleteMapping
- 用于映射 HTTP DELETE 请求到控制器方法。
@ConfigurationProperties
- 用于将配置文件中的属性绑定到一个 Java 对象。
@ConditionalOnProperty
- 用于根据配置文件中的属性条件来决定是否加载某个 Bean。
@ConditionalOnMissingBean
- 用于在某个 Bean 不存在时加载另一个 Bean。
@ConditionalOnClass
- 用于在某个类存在时加载某个 Bean。
@ConditionalOnMissingClass
- 用于在某个类不存在时加载某个 Bean。
@EnableConfigurationProperties
- 用于启用 @ConfigurationProperties 注解的功能。
@EnableScheduling
- 用于启用 Spring 的定时任务功能。
@Scheduled
- 用于标记一个方法为定时任务。
@Async
- 用于标记一个方法为异步执行。
@EnableCaching
- 用于启用 Spring 的缓存功能。
@Cacheable
- 用于标记一个方法的返回值可以被缓存。
@CacheEvict
- 用于标记一个方法可以清除缓存。
@CachePut
- 用于标记一个方法可以更新缓存。
@EnableWebSecurity
- 用于启用 Spring Security 的 Web 安全配置。
@EnableGlobalMethodSecurity
- 用于启用 Spring Security 的方法级安全配置。
@PreAuthorize
- 用于在方法执行前进行权限检查。
@PostAuthorize
- 用于在方法执行后进行权限检查。
@EnableJpaRepositories
- 用于启用 Spring Data JPA 的仓库功能。
@Entity
- 用于标记一个类为 JPA 实体。
@Table
- 用于指定 JPA 实体对应的数据库表。
@Id
- 用于标记 JPA 实体的主键字段。
@GeneratedValue
- 用于指定 JPA 实体主键的生成策略。
@Column
- 用于指定 JPA 实体字段对应的数据库列。
@Query
- 用于在 Spring Data JPA 中定义自定义查询。
@EnableTransactionManagement
- 用于启用 Spring 的事务管理功能。
@EnableAspectJAutoProxy
- 用于启用 Spring 的 AOP 功能。
@Aspect
- 用于标记一个类为切面。
@Pointcut
- 用于定义切点表达式。
@Before
- 用于在目标方法执行前执行切面逻辑。
@After
- 用于在目标方法执行后执行切面逻辑。
@Around
- 用于在目标方法执行前后执行切面逻辑。
@AfterReturning
- 用于在目标方法成功返回后执行切面逻辑。
@AfterThrowing
- 用于在目标方法抛出异常后执行切面逻辑。
@EnableDiscoveryClient
- 用于启用 Spring Cloud 的服务发现功能。
@EnableFeignClients
- 用于启用 Spring Cloud 的 Feign 客户端功能。
@EnableCircuitBreaker
- 用于启用 Spring Cloud 的断路器功能。
@HystrixCommand
- 用于标记一个方法为 Hystrix 命令。
@EnableZuulProxy
- 用于启用 Spring Cloud 的 Zuul 代理功能。
@EnableConfigServer
- 用于启用 Spring Cloud 的配置服务器功能。
@EnableEurekaServer
- 用于启用 Spring Cloud 的 Eureka 服务器功能。
@EnableHystrixDashboard
- 用于启用 Spring Cloud 的 Hystrix 仪表盘功能。
@EnableTurbine
- 用于启用 Spring Cloud 的 Turbine 功能。

这些注解可以帮助开发者更高效地构建 Spring 和 Spring Boot 应用。

9、重写与重载

重写（Override） 和 重载（Overload） 是 Java 中两个重要的概念，它们都与方法有关，但用途和行为完全不同。

1. 重写（Override）

重写是指子类重新定义父类中已有的方法，以满足子类的特定需求。重写的方法必须与父类方法具有相同的 方法签名（方法名、参数列表和返回类型）。

特点：

发生在继承关系中：子类重写父类的方法。
方法签名必须一致：方法名、参数列表和返回类型必须相同。
访问权限不能更严格：子类方法的访问权限不能比父类方法更严格（例如，父类方法是 protected，子类方法可以是 public，但不能是 private）。
异常不能更宽泛：子类方法抛出的异常不能比父类方法抛出的异常更宽泛。
使用 @Override 注解：建议在重写方法上添加 @Override 注解，以便编译器检查是否正确重写。

示例：

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.makeSound(); // 输出: Dog barks
    }
}

2. 重载（Overload）

重载是指在同一个类中定义多个方法，它们具有相同的名字但不同的参数列表（参数类型、参数数量或参数顺序不同）。重载的方法可以根据传入的参数自动调用合适的方法。

特点：

发生在同一个类中：方法名相同，但参数列表不同。
返回值类型可以不同：重载不关心返回值类型，只关心参数列表。
访问权限可以不同：重载方法的访问权限可以不同。
与继承无关：重载不涉及继承关系。

示例：

class Calculator {
    // 方法 1：两个整数相加
    public int add(int a, int b) {
        return a + b;
    }

    // 方法 2：三个整数相加（参数数量不同）
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // 方法 3：两个浮点数相加（参数类型不同）
    public double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(1, 2));          // 输出: 3
        System.out.println(calc.add(1, 2, 3));      // 输出: 6
        System.out.println(calc.add(1.5, 2.5));      // 输出: 4.0
    }
}

重写 vs 重载

特性	重写（Override）	重载（Overload）
定义位置	子类重写父类的方法	同一个类中定义多个同名方法
方法签名	必须相同（方法名、参数列表、返回类型）	必须不同（参数列表不同）
访问权限	不能比父类方法更严格	可以不同
返回值类型	必须相同	可以不同
异常	不能抛出更宽泛的异常	可以不同
作用	实现多态，子类定制父类行为	提供方法的多版本，适应不同的参数需求

总结

重写用于子类重新定义父类方法，实现多态。
重载用于在同一个类中提供多个方法版本，适应不同的参数需求。

两者都是 Java 中实现代码复用和灵活性的重要机制。

10、接口与抽象类

接口（Interface） 和 抽象类（Abstract Class） 是 Java 中两种重要的抽象机制，它们都可以用来定义规范和约束子类的行为，但它们在设计目的和使用场景上有显著的区别。

1. 接口（Interface）

接口是一种完全抽象的类，用于定义一组方法规范，但不提供具体的实现。接口的核心目的是定义 “能做什么”，而不是 “怎么做”。

特点：

方法默认是抽象的：接口中的方法默认是 public abstract 的（Java 8 之前）。
不能包含具体实现：Java 8 之前，接口中的方法不能有方法体；Java 8 之后，可以使用 default 方法提供默认实现。
支持多继承：一个类可以实现多个接口。
字段默认是常量：接口中的字段默认是 public static final 的（即常量）。
用于定义行为规范：接口通常用于定义一组相关的行为规范，例如 Runnable、Comparable 等。

示例：

interface Animal {
    void makeSound(); // 抽象方法
    default void sleep() { // Java 8 的默认方法
        System.out.println("Animal is sleeping");
    }
}

class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound(); // 输出: Dog barks
        dog.sleep();      // 输出: Animal is sleeping
    }
}

2. 抽象类（Abstract Class）

抽象类是一种介于普通类和接口之间的类，它可以包含抽象方法（没有方法体）和具体方法（有方法体）。抽象类的核心目的是定义 “是什么” 和 “能做什么”。

特点：

可以包含抽象方法和具体方法：抽象类可以定义抽象方法（子类必须实现），也可以定义具体方法（子类可以直接继承）。
不能实例化：抽象类不能直接创建对象，必须通过子类实例化。
单继承：一个类只能继承一个抽象类。
可以包含字段和构造方法：抽象类可以定义字段和构造方法，用于初始化状态。
用于定义通用逻辑：抽象类通常用于定义一些通用的逻辑，供子类复用。

示例：

abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public abstract void makeSound(); // 抽象方法

    public void sleep() { // 具体方法
        System.out.println(name + " is sleeping");
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.makeSound(); // 输出: Dog barks
        dog.sleep();    // 输出: Buddy is sleeping
    }
}

接口 vs 抽象类

特性	接口（Interface）	抽象类（Abstract Class）
方法实现	Java 8 之前只能有抽象方法；Java 8 之后可以有默认方法和静态方法	可以包含抽象方法和具体方法
字段	只能是常量（`public static final`）	可以是普通字段
构造方法	不能有构造方法	可以有构造方法
继承	支持多继承（一个类可以实现多个接口）	单继承（一个类只能继承一个抽象类）
设计目的	定义行为规范（“能做什么”）	定义通用逻辑和部分实现（“是什么”和“能做什么”）
实例化	不能实例化	不能实例化
适用场景	定义一组行为规范，例如 `Runnable`、`Comparable`	定义通用逻辑，例如模板方法模式

如何选择？

使用接口的场景：
- 需要定义一组行为规范，且不关心具体实现。
- 需要实现多继承。
- 希望定义一组常量（接口中的字段默认是常量）。
使用抽象类的场景：
- 需要定义一些通用的逻辑，供子类复用。
- 需要定义部分方法的实现，同时保留一些抽象方法供子类实现。
- 需要定义字段或构造方法。

总结

接口更注重行为规范，适合定义“能做什么”。
抽象类 更注重通用逻辑，适合定义“是什么”和“能做什么”。

在实际开发中，接口和抽象类可以结合使用，例如通过抽象类实现接口的部分方法，再由子类完成剩余的实现。

11、构造方法

构造方法（Constructor） 是 Java 中用于创建和初始化对象的特殊方法。它的名称必须与类名完全相同，且没有返回值类型（连 void 也没有）。构造方法在对象创建时自动调用，用于初始化对象的状态（例如为字段赋值）。

构造方法的特点

名称与类名相同：
- 构造方法的名称必须与类名完全一致。
没有返回值类型：
- 构造方法没有返回值类型，甚至不能写 void。
自动调用：
- 当使用 new 关键字创建对象时，构造方法会自动调用。
可以重载：
- 一个类可以有多个构造方法（重载），只要它们的参数列表不同。
默认构造方法：
- 如果一个类没有显式定义构造方法，Java 会提供一个默认的无参构造方法。
- 如果定义了任意一个构造方法，Java 将不再提供默认的无参构造方法。
可以调用其他构造方法：
- 使用 this() 可以在一个构造方法中调用同一个类的其他构造方法。
不能被继承：
- 构造方法不能被继承，子类必须定义自己的构造方法。

构造方法的语法

public class ClassName {
    // 无参构造方法
    public ClassName() {
        // 初始化代码
    }

    // 带参构造方法
    public ClassName(参数列表) {
        // 初始化代码
    }
}

示例

1. 无参构造方法

public class Dog {
    private String name;

    // 无参构造方法
    public Dog() {
        this.name = "Unknown";
    }

    public void bark() {
        System.out.println(name + " is barking");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog(); // 调用无参构造方法
        dog.bark(); // 输出: Unknown is barking
    }
}

2. 带参构造方法

public class Dog {
    private String name;

    // 带参构造方法
    public Dog(String name) {
        this.name = name;
    }

    public void bark() {
        System.out.println(name + " is barking");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy"); // 调用带参构造方法
        dog.bark(); // 输出: Buddy is barking
    }
}

3. 构造方法重载

public class Dog {
    private String name;
    private int age;

    // 无参构造方法
    public Dog() {
        this.name = "Unknown";
        this.age = 0;
    }

    // 带一个参数的构造方法
    public Dog(String name) {
        this.name = name;
        this.age = 0;
    }

    // 带两个参数的构造方法
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void bark() {
        System.out.println(name + " is barking and is " + age + " years old");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog(); // 调用无参构造方法
        Dog dog2 = new Dog("Buddy"); // 调用带一个参数的构造方法
        Dog dog3 = new Dog("Max", 3); // 调用带两个参数的构造方法

        dog1.bark(); // 输出: Unknown is barking and is 0 years old
        dog2.bark(); // 输出: Buddy is barking and is 0 years old
        dog3.bark(); // 输出: Max is barking and is 3 years old
    }
}

4. 使用 `this()` 调用其他构造方法

public class Dog {
    private String name;
    private int age;

    // 无参构造方法
    public Dog() {
        this("Unknown", 0); // 调用带两个参数的构造方法
    }

    // 带两个参数的构造方法
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void bark() {
        System.out.println(name + " is barking and is " + age + " years old");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog(); // 调用无参构造方法
        dog.bark(); // 输出: Unknown is barking and is 0 years old
    }
}

构造方法的作用

初始化对象状态：
- 构造方法用于为对象的字段赋初始值。
强制初始化：
- 通过定义带参构造方法，可以强制调用者在创建对象时提供必要的参数。
代码复用：
- 使用 this() 可以在构造方法中调用其他构造方法，避免重复代码。

注意事项

默认构造方法：
- 如果类中没有定义任何构造方法，Java 会提供一个默认的无参构造方法。
- 如果定义了任意一个构造方法，Java 将不再提供默认的无参构造方法。
继承中的构造方法：
- 子类的构造方法默认会调用父类的无参构造方法（通过 super()）。
- 如果父类没有无参构造方法，子类必须显式调用父类的带参构造方法。
私有构造方法：
- 如果将构造方法定义为 private，则该类不能通过 new 关键字实例化。通常用于单例模式或工具类。

总结

构造方法是用于创建和初始化对象的特殊方法。
构造方法可以重载，支持多种初始化方式。
使用 this() 可以在构造方法中调用其他构造方法，实现代码复用。
构造方法在对象创建时自动调用，是初始化对象状态的关键机制。

12、静态类

在 Java 中，静态类（Static Class） 并不是一个独立的概念，但可以通过以下两种方式实现类似的功能：

静态内部类（Static Nested Class）：
- 静态内部类是定义在另一个类内部的静态类。
- 它不依赖于外部类的实例，可以直接通过外部类名访问。
工具类（Utility Class）：
- 工具类是一个包含静态方法和静态字段的类，通常用于提供通用的功能。
- 工具类的构造方法通常是私有的，防止实例化。

下面分别详细介绍这两种方式。

1. 静态内部类（Static Nested Class）

静态内部类是定义在另一个类内部的静态类。它与外部类的实例无关，可以直接通过外部类名访问。

特点：

不依赖外部类实例：静态内部类不持有外部类的引用，因此可以直接创建。
可以直接访问外部类的静态成员：静态内部类可以访问外部类的静态字段和方法。
不能访问外部类的非静态成员：静态内部类不能直接访问外部类的实例字段和方法。

示例：

public class OuterClass {
    private static String staticField = "Static Field";
    private String instanceField = "Instance Field";

    // 静态内部类
    public static class StaticNestedClass {
        public void print() {
            System.out.println("Accessing static field: " + staticField);
            // System.out.println(instanceField); // 错误：不能访问外部类的实例字段
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建静态内部类的实例
        OuterClass.StaticNestedClass nested = new OuterClass.StaticNestedClass();
        nested.print(); // 输出: Accessing static field: Static Field
    }
}

2. 工具类（Utility Class）

工具类是一种常见的静态类实现方式。它通常包含一组静态方法和静态字段，用于提供通用的功能。工具类的构造方法通常是私有的，防止实例化。

特点：

构造方法私有化：防止工具类被实例化。
所有方法和字段都是静态的：工具类的方法和字段通常都是静态的，可以直接通过类名调用。
不可继承：工具类通常被声明为 final，防止被继承。

示例：

public final class MathUtils {
    // 私有构造方法，防止实例化
    private MathUtils() {
        throw new UnsupportedOperationException("Utility class cannot be instantiated");
    }

    // 静态方法：计算两个数的和
    public static int add(int a, int b) {
        return a + b;
    }

    // 静态方法：计算两个数的乘积
    public static int multiply(int a, int b) {
        return a * b;
    }
}

public class Main {
    public static void main(String[] args) {
        int sum = MathUtils.add(10, 20); // 调用静态方法
        int product = MathUtils.multiply(10, 20); // 调用静态方法

        System.out.println("Sum: " + sum); // 输出: Sum: 30
        System.out.println("Product: " + product); // 输出: Product: 200
    }
}

静态类的使用场景

静态内部类的使用场景：
- 当某个类只对另一个类有用时，可以将其定义为静态内部类。
- 静态内部类不依赖外部类的实例，适合作为工具类或辅助类。
工具类的使用场景：
- 当需要提供一组通用的静态方法时，可以使用工具类。
- 工具类通常用于数学计算、字符串处理、日期处理等场景。

注意事项

静态内部类与普通内部类的区别：
- 普通内部类持有外部类的引用，而静态内部类不持有。
- 普通内部类不能定义静态成员（除非是常量），而静态内部类可以。
工具类的设计原则：
- 工具类的构造方法应私有化，防止实例化。
- 工具类的方法和字段应尽量设计为静态的。
- 工具类通常声明为 final，防止被继承。

总结

静态内部类：不依赖外部类实例，可以直接访问外部类的静态成员。
工具类：提供一组静态方法，构造方法私有化，防止实例化。
静态类和工具类是 Java 中实现代码复用和模块化的重要方式，适合用于封装通用功能。

13、权限修饰符等等

在 Java 中，权限修饰符（Access Modifiers） 用于控制类、方法、字段和构造方法的访问权限。Java 提供了四种权限修饰符，分别是：

public：公开的，任何地方都可以访问。
protected：受保护的，同一包内或子类中可以访问。
default（包私有）：默认的，同一包内可以访问。
private：私有的，只有本类中可以访问。

下面详细介绍这些权限修饰符的使用场景和规则。

1. `public`

作用范围：任何地方都可以访问。
适用场景：
- 类的公开接口（如工具类的方法）。
- 需要被其他包或类广泛使用的类、方法或字段。

示例：

public class Animal {
    public String name; // 公开字段

    public void eat() { // 公开方法
        System.out.println(name + " is eating");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Animal();
        dog.name = "Buddy"; // 访问公开字段
        dog.eat(); // 调用公开方法
    }
}

2. `protected`

作用范围：
- 同一包内的类可以访问。
- 子类可以访问（即使子类不在同一包中）。
适用场景：
- 需要被子类继承和重写的方法或字段。
- 同一包内的类需要共享的成员。

示例：

package com.example;

public class Animal {
    protected String name; // 受保护字段

    protected void eat() { // 受保护方法
        System.out.println(name + " is eating");
    }
}

package com.example;

public class Dog extends Animal {
    public void bark() {
        System.out.println(name + " is barking"); // 访问父类的受保护字段
        eat(); // 调用父类的受保护方法
    }
}

3. `default`（包私有）

作用范围：同一包内的类可以访问。
适用场景：
- 包内共享的类、方法或字段。
- 不希望被包外访问的成员。

示例：

package com.example;

class Animal { // 默认权限（包私有）
    String name; // 默认权限字段

    void eat() { // 默认权限方法
        System.out.println(name + " is eating");
    }
}

package com.example;

public class Main {
    public static void main(String[] args) {
        Animal dog = new Animal();
        dog.name = "Buddy"; // 访问默认权限字段
        dog.eat(); // 调用默认权限方法
    }
}

4. `private`

作用范围：只有本类中可以访问。
适用场景：
- 类的内部实现细节（如字段、工具方法）。
- 不希望被外部类访问的成员。

示例：

public class Animal {
    private String name; // 私有字段

    private void eat() { // 私有方法
        System.out.println(name + " is eating");
    }

    public void setName(String name) { // 公开方法，用于访问私有字段
        this.name = name;
    }

    public void performAction() {
        eat(); // 调用私有方法
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Animal();
        dog.setName("Buddy"); // 通过公开方法访问私有字段
        dog.performAction(); // 调用公开方法，间接调用私有方法
    }
}

权限修饰符的总结

修饰符	类内部	同一包内	子类（不同包）	其他包
`public`	✔️	✔️	✔️	✔️
`protected`	✔️	✔️	✔️	❌
`default`	✔️	✔️	❌	❌
`private`	✔️	❌	❌	❌

其他相关概念

1. `final` 修饰符

作用：用于修饰类、方法或字段，表示不可改变。
- final 类：不能被继承。
- final 方法：不能被子类重写。
- final 字段：常量，值不能被修改。

示例：

public final class MathUtils { // final 类，不能被继承
    public static final double PI = 3.14; // final 字段，常量

    public final void print() { // final 方法，不能重写
        System.out.println("This is a final method");
    }
}

2. `static` 修饰符

作用：用于修饰类、方法或字段，表示与类相关，而不是与实例相关。
- static 方法：可以直接通过类名调用。
- static 字段：类的所有实例共享同一个字段。
- static 内部类：不依赖外部类的实例。

示例：

public class Counter {
    private static int count = 0; // static 字段，共享

    public static void increment() { // static 方法
        count++;
    }

    public static int getCount() { // static 方法
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter.increment(); // 调用 static 方法
        System.out.println(Counter.getCount()); // 输出: 1
    }
}

3. `abstract` 修饰符

作用：用于修饰类或方法，表示抽象。
- abstract 类：不能实例化，只能被继承。
- abstract 方法：没有方法体，必须由子类实现。

示例：

public abstract class Animal { // 抽象类
    public abstract void makeSound(); // 抽象方法
}

public class Dog extends Animal {
    @Override
    public void makeSound() { // 实现抽象方法
        System.out.println("Dog barks");
    }
}

总结

权限修饰符：控制类、方法、字段和构造方法的访问权限。
final：表示不可改变。
static：表示与类相关，而不是与实例相关。
abstract：表示抽象，需要子类实现。

合理使用这些修饰符可以提高代码的安全性、可维护性和可扩展性。

14、springboot注解

见 8、spring与springboot注解

15、线程命令

Java中的线程命令主要包括以下方法：

start()
run()
join()
join(long millis)
join(long millis, int nanos)
sleep(long millis)
sleep(long millis, int nanos)
yield()
interrupt()
isInterrupted()
static boolean interrupted()
isAlive()
getId()
getName()
setName(String name)
getPriority()
setPriority(int priority)
isDaemon()
setDaemon(boolean on)
currentThread()
getAllStackTraces()
getStackTrace()
holdsLock(Object obj)
enumerate(Thread[] tarray) // 已过时
activeCount() // 已过时
stop() // 已废弃
suspend() // 已废弃
resume() // 已废弃
LockSupport.park()
LockSupport.unpark(Thread thread)

这些方法用于创建、启动、控制和监控线程，以及管理线程的状态和属性。

其中，
start()方法用于启动线程，
run()方法包含线程的执行代码。
join()方法使当前线程等待另一个线程完成执行，
sleep()方法用于暂停当前线程的执行指定时间。
yield()方法则用于暂停当前线程，让其他线程有机会执行。
interrupt()方法用于中断线程的执行，而isInterrupted()方法用于检查线程是否被中断。
currentThread()方法返回当前执行的线程，getName()和setName(String name)方法用于获取和设置线程的名字。getPriority()和setPriority(int priority)方法用于获取和设置线程的优先级。
isDaemon()和setDaemon(boolean on)方法用于检查和设置线程是否为守护线程。
getId()方法返回线程的ID，isAlive()方法检查线程是否还在执行。
getStackTrace()方法获取线程的堆栈跟踪，holdsLock(Object obj)方法检查线程是否持有指定对象的监视器锁。
enumerate(Thread[] tarray)和activeCount()方法用于枚举和计数活动的线程，但它们已过时。
stop()、suspend()和resume()方法用于控制线程，但它们已废弃，不推荐使用。
LockSupport.park()和LockSupport.unpark(Thread thread)方法用于线程的阻塞和唤醒。

Java线程命令主要包括 start()、run()、join()、sleep()、yield()、interrupt()、isInterrupted()、currentThread()、getName()、setName(String name)、getPriority()、setPriority(int priority)、isDaemon()、setDaemon(boolean on)、getId()、isAlive()、getStackTrace()、holdsLock(Object obj)，以及LockSupport类的park()和unpark(Thread thread)方法。

16、接口与抽象类、继承实现

接口与抽象类是Java中实现抽象和多态的两种不同方式，它们在继承和实现方面有一些关键的区别。

抽象类（Abstract Class）

定义：抽象类是用abstract关键字定义的类，它可以包含抽象方法（没有方法体的方法）和具体方法（有方法体的方法）。
继承：其他类可以通过extends关键字继承抽象类。如果一个类继承了抽象类，它必须实现抽象类中所有的抽象方法，除非它自己也是一个抽象类。
构造器：抽象类可以有构造器，子类在继承抽象类时必须调用父类的构造器。
实例化：抽象类不能被实例化，只能被继承。
单继承：Java中的类只能继承一个抽象类，因为Java不支持多继承。

接口（Interface）

定义：接口是用interface关键字定义的，它只包含抽象方法（默认是public abstract）和常量（默认是public static final）。
实现：类通过implements关键字实现接口。一个类可以实现多个接口。
方法体：接口中的方法默认是没有方法体的，但Java 8及以后版本允许接口中包含默认方法（default关键字）和静态方法（static关键字），这些方法有方法体。
构造器：接口不能有构造器。
实例化：接口不能被实例化，只能被实现。
多实现：一个类可以实现多个接口，从而实现多重继承的效果。

继承与实现的比较

继承：一个类只能继承一个抽象类，继承关系表示“是一个”（is-a）的关系。
实现：一个类可以实现多个接口，实现关系表示“具有”（has-a）或“能够做”（can-do）的关系。

示例代码

// 抽象类示例
abstract class Animal {
    abstract void makeSound(); // 抽象方法
    void eat() { // 具体方法
        System.out.println("This animal eats.");
    }
}
// 继承抽象类
class Dog extends Animal {
    void makeSound() {
        System.out.println("Bark");
    }
}
// 接口示例
interface Movable {
    void move();
}
// 实现接口
class Car implements Movable {
    public void move() {
        System.out.println("Car is moving.");
    }
}
// 一个类实现多个接口
interface Flyable {
    void fly();
}
class Bird implements Movable, Flyable {
    public void move() {
        System.out.println("Bird is walking.");
    }
    public void fly() {
        System.out.println("Bird is flying.");
    }
}

总结来说，抽象类和接口都是用于实现抽象和多态的工具，但它们在语法和使用场景上有一些重要的区别。抽象类更适合用于表示类的层次结构，而接口则更适合用于定义类的行为能力。

17、mysql.oracle

MySQL和Oracle是两种不同的关系型数据库管理系统（RDBMS），它们在架构、性能、可扩展性、成本和生态系统等方面都有所不同。以下是MySQL和Oracle的一些关键区别：

1. 开放性与许可

MySQL：MySQL是一个开源数据库，采用GNU通用公共许可证（GPL）发布。这意味着用户可以自由地使用、修改和分发MySQL软件。
Oracle：Oracle数据库是一个闭源商业数据库，用户需要购买许可证才能使用。Oracle提供了多种许可证选项，包括企业版、标准版和Express Edition等。

2. 性能与可扩展性

MySQL：MySQL以其高性能和可扩展性而闻名，特别适合Web应用和中小型应用。它支持多种存储引擎，如InnoDB和MyISAM，可以根据不同的需求选择合适的存储引擎。
Oracle：Oracle数据库以其强大的性能和可扩展性著称，能够处理非常大的数据集和高并发的事务处理。它在企业级应用中广泛使用，特别是在需要高可用性和复杂事务处理的环境中。

3. 成本

MySQL：由于MySQL是开源的，它的使用成本相对较低。除了软件本身免费外，还有大量的社区支持和第三方服务提供商。
Oracle：Oracle数据库的许可证费用较高，尤其是对于企业级用户。此外，还需要考虑硬件、支持和服务的成本。

4. 生态系统与支持

MySQL：MySQL有一个活跃的社区，提供了大量的文档、教程和第三方工具。它也得到了许多开源项目和框架的支持。
Oracle：Oracle数据库拥有一个庞大的生态系统，包括各种工具、应用程序和专业服务。Oracle公司提供了全面的技术支持和咨询服务。

5. 功能与特性

MySQL：MySQL提供了基本的关系型数据库功能，包括事务支持、存储过程、触发器等。它也支持JSON数据类型和全文搜索等功能。
Oracle：Oracle数据库提供了丰富的高级功能，包括复杂的查询优化、高级安全性、数据仓库、商务智能、云计算集成等。

6. 兼容性

MySQL：MySQL兼容多种操作系统，包括Linux、Windows、macOS等。它也支持多种编程语言和开发框架。
Oracle：Oracle数据库同样兼容多种操作系统，并且提供了广泛的编程语言和开发框架支持。

7. 学习曲线

MySQL：由于其简单易用，MySQL的学习曲线相对较陡，适合初学者和小型项目。
Oracle：Oracle数据库功能强大，但也相对复杂，学习曲线较陡峭，适合有经验的数据库管理员和开发人员。

选择MySQL还是Oracle取决于具体的应用需求、预算、技术支持和生态系统等因素。对于许多Web应用和中小型企业，MySQL是一个经济实惠且功能强大的选择。而对于需要高级功能、高可用性和企业级支持的大型企业，Oracle数据库可能是更好的选择。

18、不是基础数据类型的选项

Java是一种静态类型的语言，它有八种基本数据类型，这些类型直接由Java虚拟机（JVM）支持。以下是Java的基本数据类型及其描述：

byte：8位有符号整数类型，范围从-128到127。
short：16位有符号整数类型，范围从-32,768到32,767。
int：32位有符号整数类型，范围从-2,147,483,648到2,147,483,647。
long：64位有符号整数类型，范围从-9,223,372,036,854,775,808到9,223,372,036,854,775,807。
float：32位单精度浮点数类型，遵循IEEE 754标准。
double：64位双精度浮点数类型，遵循IEEE 754标准。
char：16位无符号Unicode字符类型，范围从’\u0000’（即0）到’\uffff’（即65,535）。
boolean：表示真（true）或假（false）的类型。

这些基本数据类型在Java中用于声明变量，它们各自有不同的用途和存储需求。例如，int通常用于大多数整数计算，而float和double用于需要小数的计算。char用于表示单个字符，boolean用于表示逻辑值。

19、属于线程命令多选

见 15、线程命令

20、事务注解生效的选项

在Java中，事务注解通常用于声明性事务管理，特别是在使用Spring框架时。要使事务注解生效，需要满足以下几个条件：

启用事务管理：首先，你需要在Spring配置文件中启用事务管理。可以通过XML配置或Java配置来实现。例如，使用Java配置时，可以创建一个配置类并添加@EnableTransactionManagement注解：

import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration
@EnableTransactionManagement
public class AppConfig {
    // 配置类的内容
}

配置数据源和事务管理器：你需要配置数据源（DataSource）和事务管理器（TransactionManager）。例如，使用Spring JDBC时，可以配置DataSource和DataSourceTransactionManager：

import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
@Configuration
@EnableTransactionManagement
public class AppConfig {
    @Bean
    public DriverManagerDataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
        dataSource.setUsername("user");
        dataSource.setPassword("password");
        return dataSource;
    }
    @Bean
    public DataSourceTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource());
    }
}

使用事务注解：在需要事务管理的方法上使用@Transactional注解。例如：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class MyService {
    @Autowired
    private MyDao myDao;
    @Transactional
    public void myTransactionalMethod() {
        // 业务逻辑代码
        myDao.saveData();
    }
}

注解的传播行为：@Transactional注解可以指定事务的传播行为、隔离级别、超时时间等属性。例如：

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED, timeout = 30)
public void myTransactionalMethod() {
    // 业务逻辑代码
}

事务的异常处理：默认情况下，@Transactional注解会回滚运行时异常（RuntimeException）和错误（Error），但不会回滚检查性异常（Checked Exception）。你可以通过rollbackFor和noRollbackFor属性来指定回滚和不回滚的异常类型。例如：
1
2
3
4
@Transactional(rollbackFor = {SQLException.class}, noRollbackFor = {CustomException.class})
public void myTransactionalMethod() {
// 业务逻辑代码
}
事务的代理机制：Spring使用代理机制来实现事务管理。这意味着事务注解只能作用于公共方法上，并且只有通过代理对象调用这些方法时，事务才会生效。如果你在同一个类内部调用带有@Transactional注解的方法，事务可能不会生效。

通过以上步骤，你可以使事务注解在Spring应用程序中生效，从而实现声明性事务管理。

21、接口与抽象类、继承实现描述正确的

见 16、接口与抽象类、继承实现

22、oracle 分页那些选项是正确的

在 Oracle 数据库中，分页查询通常使用 ROWNUM 或 OFFSET FETCH 子句来实现。以下是这两种方法的详细说明：

使用 `ROWNUM` 进行分页

ROWNUM 是 Oracle 数据库中的一个伪列，用于限制查询结果的行数。要实现分页，可以结合子查询来使用 ROWNUM。

SELECT * FROM (
    SELECT a.*, ROWNUM rnum FROM (
        SELECT * FROM your_table WHERE your_conditions
    ) a
    WHERE ROWNUM <= :endRow
) WHERE rnum >= :startRow;

在这个查询中：

:startRow 是要返回的第一行的行号。
:endRow 是要返回的最后一行的行号。

例如，要获取第 11 到第 20 行，可以将 :startRow 设置为 11，:endRow 设置为 20。

使用 `OFFSET FETCH` 进行分页

Oracle 12c 及以上版本支持 OFFSET FETCH 子句，这使得分页查询更加直观和简洁。

SELECT * FROM your_table
WHERE your_conditions
ORDER BY your_order_columns
OFFSET :offset ROWS FETCH NEXT :pageSize ROWS ONLY;

在这个查询中：

:offset 是要跳过的行数。
:pageSize 是要返回的行数。

例如，要获取第 2 页，每页 10 行，可以将 :offset 设置为 10，:pageSize 设置为 10。

注意事项

性能考虑：对于大数据量的表，使用 ROWNUM 进行分页可能会导致性能问题，因为 Oracle 需要生成所有行的 ROWNUM，然后过滤出需要的行。OFFSET FETCH 在性能上通常更好，因为它可以更有效地利用索引。
排序：无论是使用 ROWNUM 还是 OFFSET FETCH，都应该在 ORDER BY 子句中指定排序条件，以确保分页结果的正确性。
绑定变量：在实际应用中，建议使用绑定变量（:startRow, :endRow, :offset, :pageSize）来防止 SQL 注入，并提高查询的性能。
兼容性：OFFSET FETCH 子句仅在 Oracle 12c 及以上版本中可用。如果使用的是早期版本，只能使用 ROWNUM 进行分页。
通过以上方法，你可以在 Oracle 数据库中实现分页查询。选择哪种方法取决于你的具体需求和 Oracle 数据库的版本。

23、组合索引三个都完全生效的选项

在 Oracle 数据库中，组合索引（也称为复合索引）是由多个列组成的索引。要确保组合索引中的所有列都能完全生效，需要满足以下条件：

查询条件中包含索引的所有列：要让组合索引的所有列都生效，查询的 WHERE 子句中必须包含索引中的所有列。例如，如果有一个组合索引 (A, B, C)，那么查询条件中必须包含 A, B, 和 C 的条件。
查询条件中包含索引的前缀列：组合索引是基于列的顺序创建的，Oracle 可以使用索引的前缀列进行查询。例如，对于组合索引 (A, B, C)，查询条件中包含 A 和 B 的条件时，索引 (A, B, C) 仍然可以被使用，但只有 A 和 B 列会生效，C 列不会被使用。
查询条件中包含索引的全部列，并且列的顺序与索引一致：为了确保组合索引的所有列都生效，查询条件中不仅需要包含索引中的所有列，而且这些列的顺序应该与索引的顺序一致。例如，对于组合索引 (A, B, C)，查询条件应该是 WHERE A = ? AND B = ? AND C = ?。
避免使用函数或表达式：在查询条件中，如果对索引列使用函数或表达式，Oracle 可能无法使用该索引。例如，WHERE UPPER(A) = 'VALUE' 会阻止 Oracle 使用索引 (A, B, C)。
避免使用 OR 条件：如果查询条件中使用 OR 连接不同的条件，Oracle 可能无法有效地使用组合索引。在这种情况下，可能需要考虑使用位图索引或其他优化技术。
确保列的数据类型匹配：查询条件中列的数据类型必须与索引列的数据类型匹配。例如，如果索引列 A 是 VARCHAR2 类型，那么查询条件中 A 的值也应该是 VARCHAR2 类型。
避免使用通配符在前：在 LIKE 查询中，如果通配符（% 或 _）位于搜索模式的开头，Oracle 可能无法使用索引。例如，WHERE A LIKE '%value' 会阻止 Oracle 使用索引 (A, B, C)。
通过满足以上条件，可以确保组合索引中的所有列都能完全生效，从而提高查询性能。在实际应用中，建议使用 EXPLAIN PLAN 或 DBMS_XPLAN 来分析查询计划，确保索引被正确使用。

24、java源文件扩展名

Java源文件的扩展名
- Java源文件的扩展名是 .java。
Java源文件的结构
- 一个Java源文件通常包含一个公共类（public class），类名应与文件名相同。
- 文件中可以包含多个非公共类。
编译和运行
- 使用Java编译器 javac 将 .java 文件编译成字节码文件 .class。
- 使用Java虚拟机 java 运行字节码文件。

结论
Java源文件的扩展名是 .java。

25、类成员访问控制符

类成员访问控制符
- Java提供了四种访问控制符来控制类成员（字段和方法）的访问权限：
  - public: 公共的，可以被任何其他类访问。
  - private: 私有的，只能被同一类中的代码访问。
  - protected: 受保护的，可以被同一包中的类和所有子类访问。
  - 默认（无修饰符）: 可以被同一包中的类访问。
访问控制符的使用
- public 通常用于类、方法和常量，以便它们可以被外部类访问。
- private 通常用于类的内部实现细节，不希望被外部类访问。
- protected 用于允许子类访问某些方法或字段，同时限制外部类的访问。
- 默认访问控制符用于在同一包内共享类成员，而不希望它们被其他包中的类访问。
访问控制的重要性
- 访问控制有助于封装，即隐藏类的内部实现细节，只暴露必要的接口。
- 它提高了代码的可维护性和可扩展性，因为修改内部实现不会影响外部代码。

结论
Java类成员的访问控制符包括 public、private、protected 和默认（无修饰符），它们用于控制类成员的访问权限，从而实现封装和提高代码的可维护性。

26、三种基本控制结构

控制结构概述
- 控制结构决定了程序的执行流程，确保代码按照预定的逻辑顺序执行。
三种基本控制结构
- 顺序结构
  - 程序按照代码的书写顺序依次执行每个语句，没有分支或循环。
- 选择结构
  - 根据条件的真假选择不同的执行路径。
  - 常用的关键字包括 if、if-else 和 switch。
- 循环结构
  - 重复执行某一段代码，直到满足特定条件为止。
  - 常用的关键字包括 for、while 和 do-while。
控制结构的作用
- 顺序结构：确保代码按部就班地执行，是最基础的执行方式。
- 选择结构：使程序能够根据不同的条件做出决策，增强程序的灵活性。
- 循环结构：提高代码的重复利用率，避免冗余代码的出现。

结论
Java中的三种基本控制结构是顺序结构、选择结构和循环结构。

27、Linux文件权限描述、3~4道左右

Linux文件权限概述
- 在Linux文件系统中，每个文件和目录都拥有权限设置，用于控制不同用户对文件或目录的访问和操作。
权限类别
- 用户（User）：文件或目录的所有者，通常是指创建该文件或目录的用户。
- 组（Group）：一组用户，具有相同的权限级别。
- 其他（Others）：系统中不属于用户或组的其他所有用户。
权限类型
- 读（Read）：允许查看文件内容或列出目录内容。
- 写（Write）：允许修改文件内容或目录中的文件。
- 执行（Execute）：允许执行文件或进入目录。
权限表示方法
- 符号表示法
  - 使用10个字符表示，第一个字符表示文件类型（例如，-表示普通文件，d表示目录）。
  - 接下来的九个字符分为三组，每组三个字符，分别表示用户、组和其他的权限。
  - 每个权限用r（读）、w（写）、x（执行）或-（无权限）表示。
  - 例如，-rwxr--r--表示一个普通文件，所有者有读、写、执行权限，组和其他用户只有读权限。
- 数字表示法
  - 使用三位数字表示，每位数字对应用户、组和其他的权限。
  - 读、写、执行权限分别对应4、2、1。
  - 将每类权限的数字相加得到该类的权限值。
  - 例如，rwx对应4+2+1=7，r--对应4+0+0=4，因此-rwxr--r--的数字权限为744。
权限示例
- 符号权限 -rwxr--r--
  - 文件类型：普通文件
  - 所有者权限：读、写、执行（rwx）
  - 组权限：读（r--）
  - 其他用户权限：读（r--）
  - 数字权限：744
- 符号权限 drwxr-xr-x
  - 文件类型：目录
  - 所有者权限：读、写、执行（rwx）
  - 组权限：读、执行（r-x）
  - 其他用户权限：读、执行（r-x）
  - 数字权限：755

结论
Linux文件权限分为用户、组和其他三类，每类包括读、写和执行三种权限。权限可以用符号表示法（如 -rwxr--r--）或数字表示法（如 744）来描述。符号表示法中，第一个字符表示文件类型，后面的字符分为三组，每组三个字符分别表示用户、组和其他的权限。数字表示法中，读、写、执行分别对应4、2、1，每个类别的权限数字相加得到总的权限值。

28、服务器异常码

服务器异常码概述
- 服务器异常码，也称为HTTP状态码，是服务器响应客户端请求时返回的三位数字代码，用于表示请求的处理结果。
常见异常码分类
- 信息性状态码（100-199）
  - 100 Continue：服务器已接收到请求的初始部分，客户端应继续发送剩余部分。
  - 101 Switching Protocols：服务器根据客户端的请求切换协议。
- 成功状态码（200-299）
  - 200 OK：请求成功，服务器已成功处理请求。
  - 201 Created：请求成功，且服务器已创建一个新的资源。
  - 204 No Content：服务器成功处理了请求，但没有返回任何内容。
- 重定向状态码（300-399）
  - 301 Moved Permanently：请求的资源已永久移动到新位置。
  - 302 Found：请求的资源临时移动到新位置。
  - 304 Not Modified：资源未修改，客户端可以使用缓存的版本。
- 客户端错误状态码（400-499）
  - 400 Bad Request：请求语法错误，服务器无法理解。
  - 401 Unauthorized：请求要求用户的身份认证。
  - 403 Forbidden：服务器理解请求，但拒绝执行。
  - 404 Not Found：请求的资源不存在。
  - 405 Method Not Allowed：请求方法不被允许。
- 服务器错误状态码（500-599）
  - 500 Internal Server Error：服务器内部错误，无法完成请求。
  - 502 Bad Gateway：服务器作为网关或代理，从上游服务器收到无效响应。
  - 503 Service Unavailable：服务器暂时无法处理请求，可能过一段时间会恢复正常。
  - 504 Gateway Timeout：服务器作为网关或代理，等待上游服务器响应超时。
异常码的作用
- 诊断问题：帮助开发者和系统管理员诊断和解决网络问题。
- 用户体验：向用户传达请求的结果，如资源未找到或服务器繁忙。
- 自动化处理：允许客户端根据状态码自动重试或采取其他行动。
处理常见异常码的策略
- 404 Not Found：
  - 检查URL是否正确。
  - 确认资源是否已移动或删除。
  - 更新链接或提供替代资源。
- 500 Internal Server Error：
  - 检查服务器日志以获取更多信息。
  - 确认服务器资源是否充足。
  - 重启服务器或应用服务。
- 503 Service Unavailable：
  - 检查服务器负载情况。
  - 增加服务器资源或扩展容量。
  - 提供维护通知或预计恢复时间。

结论
服务器异常码是HTTP协议中用于表示服务器响应状态的三位数字代码，分为信息性、成功、重定向、客户端错误和服务器错误五类。这些码帮助诊断网络问题、改善用户体验，并指导客户端如何处理响应。常见的异常码如404 Not Found和500 Internal Server Error需要根据具体情况采取相应的解决策略。

29、java常量的修饰符

在Java中，常量通常使用final关键字来修饰，表示其值在初始化后不能被改变。为了提高代码的可读性和维护性，常量通常还使用public和static关键字来修饰，使得它们可以被类的实例共享，并且可以通过类名直接访问，而不需要创建类的实例。
因此，一个典型的Java常量定义如下：

1
2
3

public class Constants {
    public static final String MY_CONSTANT = "ConstantValue";
}

在这个例子中：

public修饰符表示该常量是公共的，可以被其他类访问。
static修饰符表示该常量是类级别的，而不是实例级别的，因此可以通过类名直接访问。
final修饰符表示该常量的值在初始化后不能被改变。
需要注意的是，虽然final关键字可以单独使用来创建常量，但通常会与public和static一起使用，以确保常量的可见性和共享性。

30、AOP组成

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，旨在通过将横切关注点（cross-cutting concerns）与业务逻辑分离，来提高代码的模块化和可维护性。AOP通常由以下几个核心概念组成：

切面（Aspect）：
切面是横切关注点的模块化，它封装了与多个类相关的行为。例如，日志记录、事务管理、安全性检查等都可以被封装为切面。
连接点（Join Point）：
连接点是在程序执行过程中能够插入切面代码的点。在Java中，连接点通常是方法的调用、方法的执行、异常的抛出等。
切入点（Pointcut）：
切入点是一个匹配连接点的谓词，它定义了切面将在哪些连接点上执行。切人点通常使用表达式来定义，例如，可以指定在所有以“get”开头的方法上执行切面代码。
通知（Advice）：
通知是切面在切入点执行的代码。根据通知在连接点执行的时间，通知可以分为几种类型：
- 前置通知（Before Advice）：在方法执行之前执行。
- 后置通知（After Advice）：无论方法是否成功完成，都在方法执行之后执行。
- 返回通知（After Returning Advice）：在方法成功完成并返回结果后执行。
- 异常通知（After Throwing Advice）：在方法抛出异常后执行。
- 环绕通知（Around Advice）：在方法执行前后都执行，可以控制方法的执行。
引入（Introduction）：
引入允许切面为现有的类添加新的方法或属性，而不需要修改类的源代码。这可以用来实现接口或添加新的行为。
织入（Weaving）：
织入是将切面代码插入到目标对象中的过程。织入可以在编译时、类加载时或运行时进行。

AOP的实现通常依赖于一个AOP框架，如Spring AOP或AspectJ。这些框架提供了实现AOP所需的基础设施和工具，使得开发者可以更容易地将切面集成到他们的应用程序中。

31、抽象类描述

抽象类（Abstract Class）是面向对象编程中的一种概念，它允许开发者定义一些未实现的方法和成员变量，供子类继承并实现。抽象类不能被实例化，只能被继承。抽象类的主要目的是为了一组相关类提供一个公共的接口和部分实现，从而提高代码的可维护性和可扩展性。

抽象类的特点包括：

抽象方法（Abstract Method）：
抽象方法是没有实现的方法，它们只声明了方法的签名（方法名、参数列表和返回类型），而没有方法体。子类必须实现所有继承的抽象方法，除非子类本身也是抽象类。
具体方法（Concrete Method）：
抽象类中可以包含具体的方法，这些方法有完整的实现，子类可以直接使用或重写这些方法。
构造器（Constructor）：
抽象类可以有构造器，用于初始化抽象类的成员变量。子类在创建实例时，会调用抽象类的构造器。
成员变量：
抽象类可以包含成员变量，这些变量可以是具体变量或抽象变量（通过抽象方法间接定义）。
继承：
抽象类可以被子类继承，子类必须实现抽象类中的所有抽象方法，除非子类本身也是抽象类。
接口实现：
抽象类可以实现一个或多个接口，提供接口方法的部分或全部实现。

抽象类与接口有一些相似之处，但它们在目的和使用上有所不同。接口主要用于定义契约，而抽象类可以提供部分实现和共享代码。在Java中，一个类可以继承多个接口，但只能继承一个抽象类。

使用抽象类可以促进代码的复用和扩展，同时确保子类实现必要的功能。抽象类是实现开闭原则（对扩展开放，对修改关闭）的重要手段之一。

32、SQL查询题5~8道题，考察基础的查询和数据库基础知识

SQL基础查询题目
以下是一些基础的SQL查询题目，旨在考察学生的数据库基础知识和SQL查询能力。

查询所有学生的姓名和年龄。
1
SELECT name, age FROM students;
查询年龄大于18岁的学生的信息。
1
SELECT * FROM students WHERE age > 18;
查询学生的平均年龄。
1
SELECT AVG(age) FROM students;

查询学生信息，并按年龄降序排列。

1	SELECT * FROM students ORDER BY age DESC;

查询每个班级的学生人数。

1	SELECT class_id, COUNT(*) FROM students GROUP BY class_id;

查询姓名中包含“王”字的学生。

1	SELECT * FROM students WHERE name LIKE '%王%';

查询班级ID在1、2、3的学生。

1	SELECT * FROM students WHERE class_id IN (1, 2, 3);

查询所有唯一的班级ID。

1	SELECT DISTINCT class_id FROM students;

假设的数据库表结构：

CREATE TABLE students (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    age INT,
    class_id INT
);

这些题目涵盖了SELECT、FROM、WHERE、ORDER BY、GROUP BY、LIKE、IN以及DISTINCT等基础SQL子句，有助于学生巩固数据库基础知识和提升SQL查询能力。

33、基础算法排序复杂度

基础算法排序复杂度总结
以下是几种常见基础算法的排序复杂度总结：

冒泡排序
- 时间复杂度：
  - 最好情况：O(n)
  - 平均情况：O(n²)
  - 最坏情况：O(n²)
- 空间复杂度：O(1)
选择排序
- 时间复杂度：O(n²)
- 空间复杂度：O(1)
插入排序
- 时间复杂度：
  - 最好情况：O(n)
  - 平均情况：O(n²)
  - 最坏情况：O(n²)
- 空间复杂度：O(1)
快速排序
- 时间复杂度：
  - 最好情况：O(n log n)
  - 平均情况：O(n log n)
  - 最坏情况：O(n²)
- 空间复杂度：O(log n)
归并排序
- 时间复杂度：O(n log n)
- 空间复杂度：O(n)
堆排序
- 时间复杂度：O(n log n)
- 空间复杂度：O(1)

这些排序算法的时间和空间复杂度总结了它们在不同情况下的性能表现，有助于在实际应用中选择合适的排序方法。

34、java设计模式题考察

Java设计模式题考察
Java设计模式是软件开发中常用的一套解决方案，用于解决特定类型的问题。在面试或考试中，Java设计模式的考察通常包括以下几个方面：

单例模式（Singleton Pattern）
- 定义：确保一个类只有一个实例，并提供一个全局访问点。
- 实现方式：
  - 饿汉式（Eager Initialization）
  - 懒汉式（Lazy Initialization）
  - 双重检查锁定（Double-Checked Locking）
  - 静态内部类（Static Inner Class）
- 优缺点：
  - 优点：控制资源的使用，避免资源浪费。
  - 缺点：单例模式可能会隐藏类之间的耦合关系，违反单一职责原则。
工厂模式（Factory Pattern）
- 简单工厂模式（Simple Factory）
  - 定义：一个工厂类根据传入的参数创建不同实例。
- 工厂方法模式（Factory Method）
  - 定义：定义一个创建产品对象的工厂方法，由子类决定实例化哪一个具体类。
- 抽象工厂模式（Abstract Factory）
  - 定义：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
- 优缺点：
  - 优点：增加新的产品族或产品等级结构比较方便。
  - 缺点：增加新的产品族时需要修改抽象工厂的接口。
观察者模式（Observer Pattern）
- 定义：定义对象之间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会收到通知并自动更新。
- 实现方式：
  - 使用java.util.Observable和java.util.Observer接口。
  - 手动实现通知机制。
- 优缺点：
  - 优点：解耦了发布者和观察者，支持广播通信。
  - 缺点：观察者列表的维护需要额外的管理。
策略模式（Strategy Pattern）
- 定义：定义一系列算法，将每个算法封装起来，并使它们可以互换。
- 实现方式：
  - 定义一个策略接口，包含具体算法的方法。
  - 实现具体策略类。
  - 定义一个上下文类，使用具体策略类。
- 优缺点：
  - 优点：算法可以独立于使用它的客户变化，易于扩展。
  - 缺点：增加了系统中类的数量。
装饰器模式（Decorator Pattern）
- 定义：动态地给一个对象添加一些额外的职责，而不改变其接口。
- 实现方式：
  - 定义一个接口，包含组件的行为。
  - 实现具体组件类。
  - 实现装饰器类，继承接口并包含一个组件实例。
- 优缺点：
  - 优点：可以动态地添加或移除职责，保持了系统的灵活性。
  - 缺点：可能会导致类的数量增加。
适配器模式（Adapter Pattern）
- 定义：将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以一起工作。
- 实现方式：
  - 类适配器：使用多继承。
  - 对象适配器：使用组合。
- 优缺点：
  - 优点：提高了类的复用性，减少了类之间的耦合。
  - 缺点：增加了系统的复杂性。
代理模式（Proxy Pattern）
- 定义：为其他对象提供一个代理以控制对这个对象的访问。
- 类型：
  - 远程代理
  - 虚拟代理
  - 保护代理
  - 智能引用代理
- 优缺点：
  - 优点：可以控制对真实对象的访问，增加功能。
  - 缺点：增加了系统的复杂性。
职责链模式（Chain of Responsibility Pattern）
- 定义：将请求沿着链传递，直到有一个处理者处理它。
- 实现方式：
  - 定义一个处理者接口，包含处理请求的方法。
  - 实现具体处理者类，决定是否处理请求并转发给下一个处理者。
- 优缺点：
  - 优点：降低了对象之间的耦合，增强系统的灵活性。
  - 缺点：请求可能不会被处理，难以追踪。
命令模式（Command Pattern）
- 定义：将请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化。
- 实现方式：
  - 定义一个命令接口，包含执行命令的方法。
  - 实现具体命令类，绑定接收者和行为。
  - 定义一个调用者类，持有命令对象并执行命令。
- 优缺点：
  - 优点：解耦了请求的发送者和执行者，支持请求的排队和日志记录。
  - 缺点：可能会导致系统中有大量具体命令类。
迭代器模式（Iterator Pattern）
- 定义：提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露其内部的表示。
- 实现方式：
  - 定义一个迭代器接口，包含访问元素的方法。
  - 实现具体迭代器类。
  - 定义一个聚合接口，包含创建迭代器的方法。
  - 实现具体聚合类。
- 优缺点：
  - 优点：支持以不同的方式遍历聚合对象，增加新的遍历方式比较方便。
  - 缺点：增加了系统的复杂性。

在考察Java设计模式时，通常会要求考生理解各种模式的定义、适用场景、实现方式以及优缺点。此外，还可能要求考生编写代码实现特定的设计模式，或者分析现有代码中使用的设计模式。通过这些考察，可以评估考生对设计模式的理解和应用能力。

35、静态类修饰

在Java中，static关键字用于修饰类的成员，包括方法、变量、块和内部类。使用static修饰的成员属于类本身，而不是类的实例。这意味着无论创建多少个类的实例，static成员在内存中只有一个副本。以下是static修饰的不同成员的详细解释：

静态变量（Static Variables）
- 定义：使用static关键字修饰的变量称为静态变量，也称为类变量。
- 特点：
  - 所有实例共享同一个静态变量。
  - 静态变量在类加载时初始化，优先于实例变量。
  - 可以通过类名直接访问，无需创建类的实例。
- 示例：
  1
  2
  3
  public class MyClass {
  static int count = 0;
  }
静态方法（Static Methods）
- 定义：使用static关键字修饰的方法称为静态方法，也称为类方法。
- 特点：
  - 可以通过类名直接调用，无需创建类的实例。
  - 静态方法只能访问静态成员，不能访问实例成员。
- 示例：
  1
  2
  3
  4
  5
  public class MyClass {
  static void myStaticMethod() {
  System.out.println("This is a static method.");
  }
  }
静态块（Static Blocks）
- 定义：使用static关键字修饰的代码块称为静态块。
- 特点：
  - 静态块在类加载时执行，且只执行一次。
  - 通常用于初始化静态变量。
- 示例：
  1
  2
  3
  4
  5
  public class MyClass {
  static {
  System.out.println("Static block executed.");
  }
  }
静态内部类（Static Nested Classes）
- 定义：使用static关键字修饰的内部类称为静态内部类。
- 特点：
  - 静态内部类不依赖于外部类的实例，可以直接通过外部类名访问。
  - 静态内部类可以访问外部类的静态成员，但不能访问实例成员。
- 示例：
  1
  2
  3
  4
  5
  6
  7
  public class OuterClass {
  static class StaticNestedClass {
  static void myMethod() {
  System.out.println("This is a static nested class method.");
  }
  }
  }

使用static修饰的成员在Java编程中非常常见，它们在不同的场景下提供了便利和优化。例如，静态方法常用于工具类中，提供一些通用的功能；静态变量用于记录类的全局状态；静态块用于执行一次性的初始化代码；静态内部类用于封装与外部类相关的辅助类，且不依赖于外部类的实例。

36、java集合2~3道题

Java集合框架（Java Collections Framework）是一组用于存储和操作对象集合的接口和类。它提供了多种数据结构，包括列表、集合、映射等，以及用于操作这些数据结构的算法。以下是Java集合框架中的一些主要接口和实现类：

主要接口

Collection接口
- 子接口：
  - List接口：有序集合，允许重复元素。
  - Set接口：无序集合，不包含重复元素。
  - Queue接口：通常用于实现先进先出（FIFO）的数据结构。
Map接口
- 子接口：
  - SortedMap接口：维护键的自然顺序或指定的比较器顺序。
  - NavigableMap接口：扩展了SortedMap，提供了导航方法。

实现类

List接口的实现类：
- ArrayList：基于动态数组实现，允许快速随机访问元素。
- LinkedList：基于双向链表实现，允许快速插入和删除元素。
- Vector：类似于ArrayList，但线程安全，支持同步访问。
- Stack：继承自Vector，实现了后进先出（LIFO）的行为。
Set接口的实现类：
- HashSet：基于哈希表实现，不保证元素的顺序。
- LinkedHashSet：基于哈希表和链表实现，保持插入顺序。
- TreeSet：基于红黑树实现，保持自然顺序或指定的比较器顺序。
Queue接口的实现类：
- LinkedList：实现了Queue接口，可以作为队列使用。
- PriorityQueue：基于优先堆实现，元素按照优先级排序。
- ArrayDeque：基于数组的双端队列实现，支持高效的插入和删除操作。
Map接口的实现类：
- HashMap：基于哈希表实现，不保证键值对的顺序。
- LinkedHashMap：基于哈希表和链表实现，保持插入顺序。
- TreeMap：基于红黑树实现，保持键的自然顺序或指定的比较器顺序。
- Hashtable：类似于HashMap，但线程安全，支持同步访问。
- Properties：继承自Hashtable，用于存储属性集，键和值都是字符串。

其他工具类

Collections类：提供了操作集合的静态方法，如排序、查找、同步等。
Arrays类：提供了操作数组的静态方法，包括将数组转换为列表等。

Java集合框架的设计遵循了接口和实现分离的原则，使得代码更加灵活和可扩展。通过使用不同的实现类，可以根据具体的需求选择最适合的数据结构。同时，集合框架还提供了丰富的算法，如排序、查找、同步等，方便开发者进行集合操作。

37、redis相关 2~3道题

38、#{}和${}区别

在Java中，#{}和${} 是MyBatis框架中用于SQL语句占位符的两种不同语法，它们在处理参数时有不同的行为和用途。

#{}（预编译处理）
- 用途：用于将Java对象的属性值插入到SQL语句中，通常用于设置IN参数。
- 处理方式：MyBatis会将#{}中的内容视为一个参数，并使用PreparedStatement的setXXX方法来设置参数值。这种方式能够有效地防止SQL注入，因为参数值会被作为字符串处理，不会被解析为SQL代码的一部分。
- 示例：
  1
  String sql = "SELECT * FROM users WHERE id = #{id}";
  在这个例子中，#{id}会被替换为一个预编译的参数占位符，如?，然后MyBatis会使用setId方法设置实际的ID值。
${}（字符串替换）
- 用途：用于将Java对象的属性值直接插入到SQL语句中，通常用于动态生成SQL语句的一部分，如表名、列名等。
- 处理方式：MyBatis会将${}中的内容直接替换为对应的字符串值，不做任何转义处理。这种方式可能会导致SQL注入漏洞，因为用户输入的内容会被直接拼接到SQL语句中。
- 示例：
  1
  String sql = "SELECT * FROM ${tableName} WHERE id = #{id}";
  在这个例子中，${tableName}会被直接替换为tableName的字符串值，而#{id}则会被作为预编译的参数处理。

总结：

使用#{}可以防止SQL注入，适用于设置IN参数。
使用${}会直接替换字符串，适用于动态生成SQL语句的一部分，但需要谨慎使用，避免SQL注入风险。

在实际开发中，应尽量使用#{}来传递参数，以确保SQL语句的安全性。只有在确实需要动态生成SQL语句的一部分（如表名、列名等）时，才使用${}，并且要确保这些部分的值是可信的，不会被恶意用户篡改。

39、mybatis xml文件中标签问题

在MyBatis的XML映射文件中，标签是用来定义SQL语句和映射关系的。以下是一些常用的标签及其用途：

<mapper>
- 用途：定义一个映射器，通常对应一个Java接口。
- 属性：
  - namespace：指定映射器的命名空间，通常是一个Java接口的全限定名。
<select>
- 用途：定义一个查询语句。
- 属性：
  - id：唯一标识这个查询语句，在Java接口中对应的方法名。
  - resultType：指定查询结果映射到的Java类型。
  - parameterType：指定输入参数的Java类型。
<insert>
- 用途：定义一个插入语句。
- 属性：
  - id：唯一标识这个插入语句，在Java接口中对应的方法名。
  - parameterType：指定输入参数的Java类型。
  - useGeneratedKeys：是否使用数据库生成的主键。
  - keyProperty：指定Java对象中对应主键的属性。
<update>
- 用途：定义一个更新语句。
- 属性：
  - id：唯一标识这个更新语句，在Java接口中对应的方法名。
  - parameterType：指定输入参数的Java类型。
<delete>
- 用途：定义一个删除语句。
- 属性：
  - id：唯一标识这个删除语句，在Java接口中对应的方法名。
  - parameterType：指定输入参数的Java类型。
<resultMap>
- 用途：定义结果集映射，用于复杂的结果集映射。
- 属性：
  - id：唯一标识这个结果集映射。
  - type：指定映射到的Java类型。
<association>
- 用途：定义一对一的关联映射。
- 属性：
  - property：指定Java对象中对应的属性。
  - javaType：指定关联对象的Java类型。
  - column：指定数据库表中的列名。
<collection>
- 用途：定义一对多的关联映射。
- 属性：
  - property：指定Java对象中对应的属性。
  - ofType：指定集合中元素的Java类型。
<sql>
- 用途：定义可重用的SQL代码片段。
- 属性：
  - id：唯一标识这个SQL代码片段。
<include>
- 用途：包含一个已定义的SQL代码片段。
- 属性：
  - refid：引用的SQL代码片段的ID。

这些标签帮助你定义和组织SQL语句，以及它们与Java对象之间的映射关系。通过合理使用这些标签，可以提高代码的可维护性和可读性。

40、@springbootapplication包含哪些注解

@SpringBootApplication 是 Spring Boot 提供的一个注解，它是一个组合注解，包含了以下几个核心注解：

@SpringBootConfiguration
- 用途：这是一个配置类注解，类似于 Spring 框架中的 @Configuration，但它专门用于 Spring Boot 应用程序的配置。
@EnableAutoConfiguration
- 用途：这个注解启用了 Spring Boot 的自动配置机制。Spring Boot 会根据类路径中的依赖和配置文件中的设置，自动配置 Spring 应用程序上下文。
@ComponentScan
- 用途：这个注解启用了组件扫描，Spring Boot 会扫描注解所在类的包及其子包，查找并注册 Spring 组件，如 @Controller、@Service、@Repository 和 @Component。

通过使用 @SpringBootApplication 注解，你可以简化 Spring Boot 应用程序的配置，因为它集成了配置、自动配置和组件扫描的功能。通常，这个注解会应用在你的主应用程序类上，这个类中通常包含 main 方法来启动 Spring Boot 应用程序。

41、Linux文件赋权744是什么意思

在Linux系统中，文件和目录的权限通过一组数字来表示，这组数字被称为权限位。每个权限位代表不同的访问权限，分为三组：用户（User）、组（Group）和其他（Others）。每组权限位由三个数字组成，分别代表读（Read）、写（Write）和执行（Execute）权限。
权限数字的含义如下：

4：代表读权限（Read）
2：代表写权限（Write）
1：代表执行权限（Execute）

这些数字可以相加来组合不同的权限。例如，7是4+2+1，表示读、写和执行权限；6是4+2，表示读和写权限；5是4+1，表示读和执行权限。
当你说一个文件的权限是744时，这意味着：

用户（User）：7，即4+2+1，表示用户拥有读、写和执行权限。
组（Group）：4，表示组成员拥有读权限。
其他（Others）：4，表示其他用户拥有读权限。

总结来说，权限744意味着文件的所有者可以读、写和执行该文件，而组成员和其他用户只能读取该文件。

42、Linux查看当前实时进程的命令是什么

在Linux系统中，查看当前实时进程的命令是ps（process status）命令。ps命令可以显示系统中当前运行的进程的信息。要查看实时进程，可以使用ps命令的-e选项来显示所有进程，-f选项来显示完整的格式，或者使用-aux选项来显示所有进程的详细信息。
例如，要查看所有进程的详细信息，可以使用以下命令：

ps aux

这个命令会显示所有进程的用户、进程ID（PID）、CPU使用率、内存使用率、启动时间、终端和命令等信息。

如果你想要实时监控进程的活动，可以使用top命令或者htop命令（如果已安装）。top命令提供了一个动态的、实时的视图，显示系统中运行的进程及其资源使用情况。htop是一个更高级的交互式进程查看器，提供了更友好的用户界面和更多的功能。

例如，要使用top命令，只需在终端中输入：

top

要使用htop命令，输入：

htop

请注意，htop可能需要单独安装，因为它不是Linux发行版的标准工具。你可以使用包管理器来安装它，例如在Debian/Ubuntu系统中，可以使用以下命令安装：

1	sudo apt-get install htop

43、vi编辑文件模式下删4行跟全删的命令分别是什么

在vi编辑器中，删除行和删除整个文件的命令如下：

删除当前光标所在行：
1
dd
删除4行（从当前光标所在行开始向下删除4行）：
1
4dd
删除整个文件（清空文件内容）：
1
:%d
在执行此命令后，文件内容将被删除，但文件本身仍然存在。如果你想要删除文件本身，你需要使用操作系统的命令，如rm。例如：
1
2
:wq! # 保存并退出vi
rm filename # 删除文件

请注意，这些命令是在vi的命令模式下使用的。如果你在插入模式下，你需要先按Esc键返回到命令模式，然后再输入上述命令。

44、数据库进行数据清理操作如何不影响dml操作

在数据库进行数据清理操作时，通常需要确保这些操作不会影响到正在进行的DML（数据操作语言）操作，如INSERT、UPDATE和DELETE。为了实现这一点，可以采取以下几种策略：

事务隔离级别：
使用适当的事务隔离级别来防止数据清理操作与DML操作之间的冲突。例如，使用Serializable隔离级别可以确保事务在执行期间看到的数据不会被其他事务修改。
锁定机制：
在执行数据清理操作时，可以使用锁定机制来锁定相关的表或行，防止其他事务对其进行修改。但是，这可能会导致其他事务等待，影响性能。
分区表：
如果数据库支持分区表，可以将数据分成多个分区，然后对不活动的分区进行清理。这样可以减少对正在使用的数据的影响。
批量操作：
将数据清理操作分成多个小批量执行，而不是一次性删除大量数据。这可以减少对数据库性能的影响，并降低锁竞争的可能性。
时间窗口：
在数据库负载较低的时间窗口内执行数据清理操作，以减少对在线DML操作的影响。
复制和影子表：
使用数据库复制功能或影子表来创建数据的副本，然后在副本上执行清理操作。清理完成后，可以将副本切换回主表。
使用存储过程或触发器：
编写存储过程或触发器来自动执行数据清理操作，确保它们在不影响DML操作的情况下运行。
监控和调整：
在执行数据清理操作时，监控数据库的性能和锁情况，根据需要调整操作的频率和范围。
备份和恢复：
在执行大规模数据清理操作之前，确保有最新的备份，以便在出现问题时可以恢复数据。
在执行任何数据清理操作之前，都应该仔细规划，并在测试环境中进行测试，以确保操作的安全性和有效性。此外，应该与数据库管理员和其他相关团队成员沟通，确保他们了解即将进行的操作，以便在必要时提供支持。

45、linux命令和权限问题

在Linux系统中，命令和权限管理是确保系统安全和稳定运行的关键。以下是一些关于Linux命令和权限的基本概念和操作：

基本命令

文件和目录操作：
- ls：列出目录内容。
- cd：更改目录。
- pwd：显示当前工作目录。
- mkdir：创建目录。
- rm：删除文件或目录。
- cp：复制文件或目录。
- mv：移动或重命名文件或目录。
文件查看和编辑：
- cat：显示文件内容。
- less：分页显示文件内容。
- vim 或 nano：文本编辑器，用于创建和编辑文件。
系统信息和管理：
- uname：显示系统信息。
- top 或 htop：显示系统进程。
- df：显示磁盘空间使用情况。
- free：显示内存使用情况。
- ps：显示进程状态。
- kill：终止进程。
用户和权限管理：
- useradd 或 adduser：添加用户。
- userdel：删除用户。
- passwd：更改用户密码。
- chmod：更改文件或目录权限。
- chown：更改文件或目录所有者。
- chgrp：更改文件或目录所属组。

权限管理

Linux权限系统基于用户、组和其他用户（others）的三类权限，每类权限有读（r）、写（w）和执行（x）三种权限。

查看权限：
使用 ls -l 命令可以查看文件或目录的权限。
更改权限：
使用 chmod 命令可以更改文件或目录的权限。例如：
- chmod 755 file.txt：设置文件的权限为所有者可读写执行，组和其他用户可读执行。
- chmod u+x file.txt：给文件的所有者添加执行权限。
更改所有者和组：
使用 chown 和 chgrp 命令可以更改文件或目录的所有者和组。例如：
- chown user:group file.txt：更改文件的所有者为"user"，组为"group"。
- chgrp group file.txt：更改文件的组为"group"。
sudo权限：
使用 sudo 命令可以以超级用户权限执行命令。例如：
- sudo apt-get update：以超级用户权限更新包列表。

注意事项

在执行任何可能影响系统稳定性的命令之前，应该确保你了解该命令的作用和潜在影响。
使用 sudo 时要非常小心，因为错误的命令可能会导致系统损坏。
定期备份重要数据，以防万一。
学习和理解Linux命令和权限系统是Linux系统管理的基础，建议通过官方文档和在线教程进行深入学习。

通过理解和掌握这些基本的Linux命令和权限管理知识，你可以更有效地管理和维护Linux系统。

46、java基础语法接口、抽象类、继承关系

在Java编程语言中，接口、抽象类和继承关系是面向对象编程（OOP）的重要概念。它们允许开发者实现代码的重用、扩展和多态性。下面是这些概念的简要介绍：

接口（Interface）

接口是一种完全抽象的类，它只包含抽象方法和常量。接口用于定义类的行为，但不提供方法的具体实现。一个类可以实现多个接口，从而实现多重继承的效果。

public interface Animal {
    void makeSound();
    int getAge();
}

抽象类（Abstract Class）

抽象类是一个不能被实例化的类，它可能包含抽象方法（没有实现的方法）和具体方法（有实现的方法）。抽象类用于提供一个基类，子类可以继承并实现抽象方法。

public abstract class Mammal {
    public abstract void giveBirth();
    public void breathe() {
        System.out.println("Breathing...");
    }
}

继承关系（Inheritance）

继承是OOP的一个关键特性，它允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以重写父类的方法，也可以添加新的方法和属性。

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
    @Override
    public int getAge() {
        return 5;
    }
}

多重继承与接口

Java不支持多重继承，即一个类不能直接继承多个类。但是，一个类可以实现多个接口，从而实现多重继承的效果。

public class Bird implements Animal, Flyable {
    @Override
    public void makeSound() {
        System.out.println("Chirp");
    }
    @Override
    public int getAge() {
        return 2;
    }
    @Override
    public void fly() {
        System.out.println("Flying...");
    }
}

注意事项

接口中的方法默认是抽象的，而抽象类中的方法可以是抽象的也可以是具体的。
一个类可以继承一个抽象类并实现多个接口。
抽象类可以有构造器，而接口不能有构造器。
接口中的变量默认是public static final的，而抽象类中的变量可以有不同的访问修饰符。

通过理解和使用接口、抽象类和继承关系，开发者可以创建出更加模块化、可扩展和易于维护的代码。

1、字符串小写加反转
2、2的幂等
3、预计循环类型，递归
4、冒泡排序

常见题型：

JAVA基础题型
SQL优化题型
Linux命令题型

2025-02-25 该篇文章被 up 打上标签: Java 面试题

1、Spring、事务、AOP相关注解

2、java基础(继承、接口、多线程)

3、正则表达式

4、数据库(索引、三范式、Gbase、大数据)

5、Linux(基础命令、vim操作、权限)

6、编程题 给定一个int数组 数组内三个数相加 求最大值 数据范围为-10000 到10000 数组最少包含3个数字

思路：

方法 1：暴力法

方法 2：排序法

解释：

测试用例：

总结：

7、linux基础命令

8、spring与springboot注解

Spring 常用注解

Spring Boot 常用注解

9、重写与重载

1. 重写（Override）

特点：

示例：

2. 重载（Overload）

特点：

示例：

重写 vs 重载

总结

10、接口与抽象类

1. 接口（Interface）

特点：

示例：

2. 抽象类（Abstract Class）

特点：

示例：

接口 vs 抽象类

如何选择？

总结

11、构造方法

构造方法的特点

构造方法的语法

示例

1. 无参构造方法

2. 带参构造方法

3. 构造方法重载

4. 使用 this() 调用其他构造方法

构造方法的作用

注意事项

总结

12、静态类

1. 静态内部类（Static Nested Class）

特点：

示例：

2. 工具类（Utility Class）

特点：

示例：

静态类的使用场景

注意事项

总结

13、权限修饰符等等

1. public

示例：

2. protected

示例：

3. default（包私有）

示例：

4. private

示例：

权限修饰符的总结

其他相关概念

1. final 修饰符

示例：

2. static 修饰符

示例：

3. abstract 修饰符

示例：

总结

14、springboot注解

15、线程命令

16、接口与抽象类、继承实现

抽象类（Abstract Class）

接口（Interface）

继承与实现的比较

6、编程题给定一个int数组数组内三个数相加求最大值数据范围为-10000 到10000 数组最少包含3个数字

4. 使用 `this()` 调用其他构造方法

1. `public`

2. `protected`

3. `default`（包私有）

4. `private`

1. `final` 修饰符

2. `static` 修饰符

3. `abstract` 修饰符

22、oracle 分页那些选项是正确的

使用 `ROWNUM` 进行分页

使用 `OFFSET FETCH` 进行分页

23、组合索引三个都完全生效的选项

46、java基础语法接口、抽象类、继承关系