主要有以下特点。

• 面向对象。Java 是一门严格的面向对象编程语言，几乎一切都是对象。面向对象编程（OOP）特性使得代码更易于维护和重用，包括类（class）、对象（object）、继承（inheritance）、多态（polymorphism）、抽象（abstraction）和封装（encapsulation）。
• 平台无关性。Java 的“编写一次，运行无处不在”哲学是其最大的特点之一。Java 编译器将源代码编译成字节码（bytecode），该字节码可以在任何安装了 Java 虚拟机（JVM）的系统上运行。
• 自动内存管理。Java 有自己的垃圾回收机制，自动管理内存和回收不再使用的对象。这样，开发者不需要手动管理内存，从而减少内存泄漏和其他内存相关的问题。

• 优势。
  • 跨平台。因为 JVM 的存在，一次编写到处运行。
  • 强大的生态系统。比如 Spring 框架，Hibernate，各种库和工具，社区支持大，企业应用广泛。
  • 自动内存管理。内存管理方面，自动垃圾回收机制，减少了内存泄漏的问题，对开发者友好。
  • 多线程支持。还有多线程支持，内置的线程机制，方便并发编程。
  • 安全。Java 有安全模型，比如沙箱机制，适合网络环境。
  • 稳定性。企业级应用长期使用，版本更新也比较注重向后兼容。
• 劣势。
  • 性能。虽然 JVM 优化了很多，但相比 C++ 或者 Rust 这种原生编译语言，还是有一定开销。特别是启动时间，比如微服务场景下，可能不如 Go 之类的快。
  • 语法繁琐。比如样板代码多，之前没有 lambda 的时候更麻烦，现在有了但比起 Python 还是不够简洁。
  • 内存消耗。JVM 本身占内存，对于资源有限的环境可能不太友好。
  • 面向对象过于严格。有时候写简单程序反而麻烦，虽然 Java8 引入了函数式编程，但不如其他语言自然。
  • 开发效率。相比动态语言如 Python，Java 需要更多代码，编译过程也可能拖慢开发节奏。

 Java 能支持跨平台，主要依赖于 JVM 关系比较大。
 JVM 也是一个软件，不同的平台有不同的版本。我们编写的 Java 源码，编译后会生成一种 .class 文件，称为字节码文件。Java 虚拟机就是负责将字节码文件翻译成特定平台下的机器码然后运行。也就是说，只要在不同平台上安装对应的 JVM，就可以运行字节码文件，运行我们编写的 Java 程序。
 而这个过程中，我们编写的 Java 程序没有做任何改变，仅仅是通过 JVM 这一”中间层“，就能在不同平台上运行，真正实现了”一次编译，到处运行“的目的。
 JVM 是一个”桥梁“，是一个”中间件“，是实现跨平台的关键，Java 代码首先被编译成字节码文件，再由 JVM 将字节码文件翻译成机器语言，从而达到运行 Java 程序的目的。
 编译的结果不是生成机器码，而是生成字节码，字节码不能直接运行，必须通过 JVM 翻译成机器码才能运行。不同平台下编译生成的字节码是一样的，但是由 JVM 翻译成的机器码却不一样。
 所以，运行 Java 程序必须有 JVM 的支持，因为编译的结果不是机器码，必须要经过 JVM 的再次翻译才能执行。即使你将 Java 程序打包成可执行文件（例如 .exe），仍然需要 JVM 的支持。
 跨平台的是 Java 程序，不是 JVM。JVM 是用 C/C++ 开发的，是编译后的机器码，不能跨平台，不同平台下需要安装不同版本的 JVM。

 JDK > JRE > JVM。

• JRE 代表 Java 运行时（Java run-time），是运行 Java 引用所必须的。
• JDK 代表 Java 开发工具（Java development kit），是 Java 程序的开发工具，如 Java编译器，它也包含 JRE。
• JVM 代表 Java 虚拟机（Java virtual machine），它的责任是运行 Java 应用。
• JIT 代表即时编译（Just In Time compilation），当代码执行的次数超过一定的阈值时，会将 Java 字节码转换为本地代码，如，主要的热点代码会被准换为本地代码，这样有利大幅度提高 Java 应用的性能，思考：为什么快很多。

• 编译。
  • Java 源代码首先被编译成字节码。即 Java 文件编译为 Class 文件。
  • JIT 会把编译过的机器码保存起来,以备下次使用。即 Class 文件编译为本地机器指令。
• 解释。
  • 比如解释器解释执行字节码文件。JVM 中一个方法调用计数器，当累计计数大于一定值的时候，就使用 JIT 进行编译生成机器码文件。

 Java 采用编译与解释相结合的方式运行，主要是为了在跨平台性和执行效率之间取得平衡。

 JVM 是 java 虚拟机，主要工作是解释自己的指令集（即字节码）并映射到本地的 CPU 指令集和 OS 的系统调用。
 JVM 屏蔽了与操作系统平台相关的信息，使得 Java 程序只需要生成在 Java 虚拟机上运行的目标代码（字节码），就可在多种平台上不加修改的运行，这也是 Java 能够“一次编译，到处运行的”原因。

 编译型语言和解释型语言的区别在于。

• 编译型语言：在程序执行之前，整个源代码会被编译成机器码或者字节码，生成可执行文件。执行时直接运行编译后的代码，速度快，但跨平台性较差。
• 解释型语言：在程序执行时，逐行解释执行源代码，不生成独立的可执行文件。通常由解释器动态解释并执行代码，跨平台性好，但执行速度相对较慢。
• 典型的编译型语言如 C、C++，典型的解释型语言如 Python、JavaScript。

 在 Java 中，native 方法是一种特殊类型的方法，它允许 Java 代码调用外部的本地代码，即用 C、C++ 或其他语言编写的代码。native 关键字是 Java 语言中的一种声明，用于标记一个方法的实现将在外部定义。
 要实现 native 方法，你需要完成以下步骤。

• 生成 JNI 头文件：使用 javah 工具从你的 Java 类生成 C/C++ 的头文件，这个头文件包含了所有 native 方法的原型。
• 编写本地代码：使用 C/C++ 编写本地方法的实现，并确保方法签名与生成的头文件中的原型匹配。
• 编译本地代码：将 C/C++ 代码编译成动态链接库（DLL，在 Windows 上），共享库（SO，在 Linux 上）。
• 加载本地库：在 Java 程序中，使用 System.loadLibrary() 方法来加载你编译好的本地库，这样 JVM 就能找到并调用 native 方法的实现了。

• Java 是一种已编译的编程语言，Java 编译器将源代码编译为字节码，而字节码则由 Java 虚拟机执行。
• Python 是一种解释语言，翻译时会在执行程序的同时进行编译。

 Java 支持数据类型分为两类：基本数据类型和引用数据类型。
 基本数据类型共有 8 种，可以分为三类。

• 数值型：整数类型（byte、short、int、long）和浮点类型（float、double）。
• 字符型：char。
• 布尔型：boolean。

 Float 和 Double 的最小值和最大值都是以科学记数法的形式输出的，结尾的“E+数字”表示 E 之前的数字要乘以 10 的多少倍。比如 3.14E3 就是 3.14×1000=3140，3.14E-3 就是 3.14/1000=0.00314。
 引用数据类型如类、接口、数组。
 注意一下几点。

• Java 八种基本数据类型的字节数：1 字节(byte、boolean)、 2 字节(short、char)、4 字节(int、float)、8 字节(long、double)。
• 浮点数的默认类型为 double（如果需要声明一个常量为 float 型，则必须要在末尾加上 f 或 F）。
• 整数的默认类型为 int（声明 Long 型在末尾加上 l 或者 L）。
• 八种基本数据类型的包装类：除了 char 的是 Character、int 类型的是 Integer，其他都是首字母大写。
• char 类型是无符号的，不能为负，所以是 0 开始的。

• int 类型是 32 位（bit），占 4 个字节（byte），int 是有符号整数类型，其取值范围是从 -2^31 到 2^31-1 。例如，在一个简单的计数器程序中，如果使用 int 类型来存储计数值，它可以表示的最大正数是 2,147,483,647。如果计数值超过这个范围，就会发生溢出，导致结果不符合预期。
• long 类型是 64 位，占 8 个字节，long 类型也是有符号整数类型，它的取值范围是从 -2^63 到 2^63 -1 ，在处理较大的整数数值时，如果 int 类型的取值范围不够，就需要使用 long 类型。例如，在一个文件传输程序中，文件的大小可能会很大，使用 int 类型可能无法准确表示，而 long 类型就可以很好地处理这种情况。

• 自动类型转换（隐式转换）：当目标类型的范围大于源类型时，Java 会自动将源类型转换为目标类型，不需要显式的类型转换。例如，将 int 转换为 long、将 float 转换为 double 等。
• 强制类型转换（显式转换）：当目标类型的范围小于源类型时，需要使用强制类型转换将源类型转换为目标类型。这可能导致数据丢失或溢出。例如，将 long 转换为 int、将 double 转换为 int 等。语法为 目标类型 变量名=(目标类型)源类型。
• 字符串转换：Java 提供了将字符串表示的数据转换为其他类型数据的方法。例如，将字符串转换为整型 int，可以使用 Integer.parseInt() 方法；将字符串转换为浮点型 double，可以使用 Double.parseDouble() 方法等。
• 数值之间的转换：Java 提供了一些数值类型之间的转换方法，如将整型转换为字符型、将字符型转换为整型等。这些转换方式可以通过类型的包装类来实现，例如 Character 类、Integer 类提供了相应的转换方法。

• 数据丢失：当将一个范围较大的数据类型转换为一个范围较小的数据类型时，可能会发生数据丢失。例如，将一个 long 类型的值转换为 int 类型时，如果 long 值超出了 int 类型的范围，转换结果将是截断后的低位部分，高位部分的数据将丢失。
• 数据溢出：与数据丢失相反，当将一个范围较小的数据类型转换为一个范围较大的数据类型时，可能会发生数据溢出。例如，将一个 int 类型的值转换为 long 类型时，转换结果会填充额外的高位空间，但原始数据仍然保持不变。
• 精度损失：在进行浮点数类型的转换时，可能会发生精度损失。由于浮点数的表示方式不同，将一个单精度浮点数(float)转换为双精度浮点数(double)时，精度可能会损失。
• 类型不匹配导致的错误：在进行类型转换时，需要确保源类型和目标类型是兼容的。如果两者不兼容，会导致编译错误或运行时错误。

 Double 会出现精度丢失的问题，而 Decimal 是精确计算，所以一般牵扯到金钱的计算，都使用 Decimal。
 而 Decimal 是精确计算，所以一般牵扯到金钱的计算，都使用 Decimal。

 装箱（Boxing）和拆箱（Unboxing）是将基本数据类型和对应的包装类之间进行转换的过程。
 自动装箱主要发生在两种情况，一种是赋值时，另一种是在方法调用的时候。
 自动装箱的弊端如下。

• 性能问题：频繁的装箱和拆箱操作会导致性能开销。例如，在循环中频繁装箱和拆箱可能会产生不必要的对象创建，增加垃圾回收压力。
• 空指针异常：对 null 进行自动拆箱会导致 NullPointerException。在拆箱前，需要确保包装类对象不为 null。
• 对象比较问题：包装类的对象比较需要注意引用和值的区别。使用 equals() 方法进行值比较，而不是使用 ==。
• 内存开销：自动装箱会创建新的对象，对于较大的数据值，每次装箱时都可能会创建新的对象，从而增加了内存的开销。
• 特殊货物处理：虽然自动装箱机提高了效率，但在处理特殊货物时可能还需要人工干预，影响其自动化程度的提升。

 装箱和拆箱发生在编译阶段，可以编译后对比看下 class 文件。

• 引用对象可以将数据跟处理这些数据的方法结合在一起。
• Java 中绝大部分方法或类都是用来处理类类型对象的。
  • 泛型只能使用引用类型，而不能使用基本类型。
  • 基本类型和引用类型不能直接进行转换，必须使用包装类来实现。
  • Java 集合中只能存储对象，而不能存储基本数据类型。

 int 是 Java 中的原始数据类型，而 Integer 是 int 的包装类。
 Integer 和 int 的区别如下。

• 基本类型和引用类型。即使用 int 类型时，不需要任何额外的内存分配，而使用 Integer 时，必须为对象分配内存。在性能方面，基本数据类型的操作通常比相应的引用类型快。
• 自动装箱和拆箱。Integer 可以使得程序员更加方便地进行数据类型转换。
• 空指针异常。即 int 无法表示 null 值，null 值是无法进行字段拆箱的。

 包装类是引用类型，对象的引用和对象本身是分开存储的，而对于基本类型数据，变量对应的内存块直接存储数据本身。
 因此，基本类型数据在读写效率方面，要比包装类高效。除此之外，在 64 位 JVM 上，在开启引用压缩的情况下，一个 Integer 对象占用 16 个字节的内存空间，而一个 int 类型数据只占用 4 字节的内存空间，前者对空间的占用是后者的 4 倍。
 也就是说，不管是读写效率，还是存储效率，基本类型都比包装类高效。

 Java 的 Integer 类内部实现了一个静态缓存池，用于存储特定范围内的整数值对应的 Integer 对象。
 默认情况下，这个范围是 -128 至 127。当通过 Integer.valueOf(int) 方法创建一个在这个范围内的整数对象时，并不会每次都生成新的对象实例，而是复用缓存中的现有对象，会直接从内存中取出，不需要新建一个对象。

 基本类型对应的缓冲池如下。

• boolean values true and false
• all byte values
• short values between -128 and 127
• int values between -128 and 127
• char in the range \u0000 to \u007F

 见 JVM - 一个案例反推不同 JDK 版本的 intern 机制以及 intern C++ 源码解析open in new window。

 面向对象是一种编程范式，它将现实世界中的事物抽象为对象，对象具有属性（称为字段或属性）和行为（称为方法）。面向对象编程的设计思想是以对象为中心，通过对象之间的交互来完成程序的功能，具有灵活性和可扩展性，通过封装和继承可以更好地应对需求变化。
 Java面向对象的三大特性包括：封装、继承、多态。

• 封装：封装是指将对象的属性（数据）和行为（方法）结合在一起，对外隐藏对象的内部细节，仅通过对象提供的接口与外界交互。封装的目的是增强安全性和简化编程，使得对象更加独立。
• 继承：继承是一种可以使得子类自动共享父类数据结构和方法的机制。它是代码复用的重要手段，通过继承可以建立类与类之间的层次关系，使得结构更加清晰。
• 多态：多态是指允许不同类的对象对同一消息作出响应。即同一个接口，使用不同的实例而执行不同操作。多态性可以分为编译时多态（重载）和运行时多态（重写）。它使得程序具有良好的灵活性和扩展性。

• 方法重载。是指同一类中可以有多个同名方法，它们具有不同的参数列表（参数类型、数量或顺序不同）。虽然方法名相同，但根据传入的参数不同，编译器会在编译时确定调用哪个方法。
• 方法重写。是指子类能够提供对父类中同名方法的具体实现。在运行时，JVM 会根据对象的实际类型确定调用哪个版本的方法。这是实现多态的主要方式。
• 接口与实现。多态也体现在接口的使用上，多个类可以实现同一个接口，并且用接口类型的引用来调用这些类的方法。这使得程序在面对不同具体实现时保持一贯的调用方式。
• 向上转型和向下转型。在 Java 中，可以使用父类类型的引用指向子类对象，这是向上转型。通过这种方式，可以在运行时期采用不同的子类实现。

 多态是指子类可以替换父类，在实际的代码运行过程中，调用子类的方法实现。多态这种特性也需要编程语言提供特殊的语法机制来实现，比如继承、接口类。
 多态可以提高代码的扩展性和复用性，是很多设计模式、设计原则、编程技巧的代码实现基础。比如策略模式、基于接口而非实现编程、依赖倒置原则、里式替换原则、利用多态去掉冗长的 if-else 语句等。

• 重载（Overloading）指的是在同一个类中，可以有多个同名方法，它们具有不同的参数列表（参数类型、参数个数或参数顺序不同），编译器根据调用时的参数类型来决定调用哪个方法。
• 重写（Overriding）指的是子类可以重新定义父类中的方法，方法名、参数列表和返回类型必须与父类中的方法一致，通过 @Override 注解来明确表示这是对父类方法的重写。

 重载是指在同一个类中定义多个同名方法，而重写是指子类重新定义父类中的方法。

• 实例化：普通类可以直接实例化对象，而抽象类不能被实例化，只能被继承。
• 方法实现：普通类中的方法可以有具体的实现，而抽象类中的方法可以有实现也可以没有实现。
• 继承：一个类可以继承一个普通类，而且可以继承多个接口；而一个类只能继承一个抽象类，但可以同时实现多个接口。
• 实现限制：普通类可以被其他类继承和使用，而抽象类一般用于作为基类，被其他类继承和扩展使用。

• 特点。
  • 抽象类用于描述类的共同特性和行为，可以有成员变量、构造方法和具体方法。适用于有明显继承关系的场景。
  • 接口用于定义行为规范，可以多实现，只能有常量和抽象方法（Java 8 以后可以有默认方法和静态方法）。适用于定义类的能力或功能。
• 区别。
  • 实现方式：实现接口的关键字为 implements，继承抽象类的关键字为 extends。一个类可以实现多个接口，但一个类只能继承一个抽象类。所以，使用接口可以间接地实现多重继承。
  • 方法方式：接口只有定义，不能有方法的实现，java 1.8 中可以定义 default 方法体，而抽象类可以有定义与实现，方法可在抽象类中实现。
  • 访问修饰符：接口成员变量默认为 public static final，必须赋初值，不能被修改；其所有的成员方法都是 public、abstract 的。抽象类中成员变量默认 default，可在子类中被重新定义，也可被重新赋值；抽象方法被 abstract 修饰，不能被 private、static、synchronized 和 native 等修饰，必须以分号结尾，不带花括号。
  • 变量：抽象类可以包含实例变量和静态变量，而接口只能包含常量（即静态常量）。

 不能，Java 中的抽象类是用来被继承的，而 final 修饰符用于禁止类被继承或方法被重写，因此，抽象类和 final 修饰符是互斥的，不能同时使用。

• 抽象方法。抽象方法是接口的核心部分，所有实现接口的类都必须实现这些方法。抽象方法默认是 public 和 abstract，这些修饰符可以省略。
• 默认方法。默认方法是在 Java 8 中引入的，允许接口提供具体实现。实现类可以选择重写默认方法。
• 静态方法。静态方法也是在 Java 8 中引入的，它们属于接口本身，可以通过接口名直接调用，而不需要实现类的对象。
• 私有方法。私有方法是在 Java 9 中引入的，用于在接口中为默认方法或其他私有方法提供辅助功能。这些方法不能被实现类访问，只能在接口内部使用。

 在 Java 中，抽象类本身不能被实例化。
 这意味着不能使用 new 关键字直接创建一个抽象类的对象。抽象类的存在主要是为了被继承，它通常包含一个或多个抽象方法（由 abstract 关键字修饰且无方法体的方法），这些方法需要在子类中被实现。
 抽象类可以有构造器，这些构造器在子类实例化时会被调用，以便进行必要的初始化工作。然而，这个过程并不是直接实例化抽象类，而是创建了子类的实例，间接地使用了抽象类的构造器。简而言之，抽象类不能直接实例化，但通过继承抽象类并实现所有抽象方法的子类是可以被实例化的。

 在接口中，不可以有构造方法,在接口里写入构造方法时，编译器提示：Interfaces cannot have constructors，因为接口不会有自己的实例的，所以不需要有构造函数。
 为什么呢？构造函数就是初始化 class 的属性或者方法，在 new 的一瞬间自动调用，那么问题来了 Java 的接口，都不能 new 那么要构造函数干嘛呢？根本就没法调用。

 在 Java 中，静态变量和静态方法是与类本身关联的，而不是与类的实例（对象）关联。它们在内存中只存在一份，可以被类的所有实例共享。

 静态变量（也称为类变量）是在类中使用 static 关键字声明的变量。它们属于类而不是任何具体的对象。主要的特点。

• 共享性：所有该类的实例共享同一个静态变量。如果一个实例修改了静态变量的值，其他实例也会看到这个更改。
• 初始化：静态变量在类被加载时初始化，只会对其进行一次分配内存。
• 访问方式：静态变量可以直接通过类名访问，也可以通过实例访问，但推荐使用类名。

 静态方法是在类中使用 static 关键字声明的方法。类似于静态变量，静态方法也属于类，而不是任何具体的对象。主要的特点。

• 无实例依赖：静态方法可以在没有创建类实例的情况下调用。对于静态方法来说，不能直接访问非静态的成员变量或方法，因为静态方法没有上下文的实例。
• 访问静态成员：静态方法可以直接调用其他静态变量和静态方法，但不能直接访问非静态成员。
• 多态性：静态方法不支持重写（Override），但可以被隐藏（Hide）。

 使用场景。

• 静态变量：常用于需要在所有对象间共享的数据，如计数器、常量等。
• 静态方法：常用于助手方法（utility methods）、获取类级别的信息或者是没有依赖于实例的数据处理。

 区别包括。

• 非静态内部类依赖于外部类的实例，而静态内部类不依赖于外部类的实例。
• 非静态内部类可以访问外部类的实例变量和方法，而静态内部类只能访问外部类的静态成员。
• 非静态内部类不能定义静态成员，而静态内部类可以定义静态成员。
• 非静态内部类在外部类实例化后才能实例化，而静态内部类可以独立实例化。
• 非静态内部类可以访问外部类的私有成员，而静态内部类不能直接访问外部类的私有成员，需要通过实例化外部类来访问。

 非静态内部类可以直接访问外部方法是因为编译器在生成字节码时会为非静态内部类维护一个指向外部类实例的引用。
 这个引用使得非静态内部类能够访问外部类的实例变量和方法。编译器会在生成非静态内部类的构造方法时，将外部类实例作为参数传入，并在内部类的实例化过程中建立外部类实例与内部类实例之间的联系，从而实现直接访问外部方法的功能。

 final 关键字主要有以下三个方面的作用：用于修饰类、方法和变量。

• 修饰类：当 final 修饰一个类时，表示这个类不能被继承，是类继承体系中的最终形态。例如，Java 中的 String 类就是用 final 修饰的，这保证了类的不可变性和安全性，防止其他类通过继承来改变类的行为和特性。
• 修饰方法：用修饰的方法不能在子类中被重写。比如，java.lang.Object 类中的 getClass 方法就是的，因为这个方法的行为是由 Java 虚拟机底层实现来保证的，不应该被子类修改。
• 修饰变量：当修饰基本数据类型的变量时，该变量一旦被赋值就不能再改变。例如 final int num = 10;，这里的 num 就是一个常量，不能再对其进行重新赋值操作，否则会导致编译错误。对于引用数据类型，final 修饰意味着这个引用变量不能再指向其他对象，但对象本身的内容是可以改变的。例如 final StringBuilder sb = new StringBuilder("Hello");，不能让 sb 再指向其他 StringBuilder 对象，但可以通过 sb.append(" World"); 来修改字符串的内容。

 可以参考 一口气读完 Java 8 ~ Java 21 所有新特性open in new window。

 Java 中只有值传递（pass by value），没有引用传递（pass by reference）。但根据传递的是基本类型还是对象类型，表现行为有所不同。
 关键点如下。

• Java 总是按值传递。
  • 基本类型：传递值的副本。
  • 对象类型：传递引用的副本（不是对象本身）。
• 对象传递的特殊表现。
  • 可以修改对象的状态（因为副本引用指向同一个对象）。
  • 但不能改变原始引用变量的指向。
• 常见误区。
  • 误以为对象是"引用传递"（实际是引用值的传递）。
  • 误以为方法内重新赋值会影响原始引用（不会）。

 示例对比如下。

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    modifyArray(arr);
    System.out.println(Arrays.toString(arr)); // [1, 2, 99]
    
    reassignArray(arr);
    System.out.println(Arrays.toString(arr)); // [1, 2, 99] (未改变)
}

static void modifyArray(int[] a) {
    a[2] = 99; // 修改会影响原数组
}

static void reassignArray(int[] a) {
    a = new int[]{10, 20, 30}; // 重新赋值不影响原引用
}

 顺序如下。

• 父类静态成员和静态代码块（按代码顺序）。
• 子类静态成员和静态代码块（按代码顺序）。
• 父类实例变量和普通代码块（按代码顺序）。
• 父类构造器。
• 子类实例变量和普通代码块（按代码顺序）。
• 子类构造器。

 Java 称其为"伪随机数"是因为。

• 它们不是真正的随机，而是算法生成的。
• 具有可预测性和可重复性。
• 只要知道算法和种子，就能预测整个序列。
• 对计算机来说效率高且实用。

 Java 的伪随机数生成器足够满足大多数应用场景的需求，但在需要真正随机数的场合(如赌博、加密等)，应考虑使用专门的硬件随机数生成器。

 略。

 略。

 deepseek 问。