字符串存储的问题

char 和字符串都是字符的集合，它们之间的确有相似性，但在 Java 中它们有着不同的存储机制和处理方式。让我从 char 和 String 的本质区别入手来解释。

1. char 和 String 的区别

• char 是基本类型：char 是 Java 中的基本数据类型，用来存储单个字符，占用固定的内存空间（2 字节）。因为 char 是基本类型，所以它不存储在常量池或堆中，而是直接在栈上分配内存。

• String 是对象：String 是一个引用类型，本质上是字符数组的封装。字符串存储在堆内存中，并且不可变。

2. 常量与非常量的区别

• 字符串常量：字面量字符串在 Java 中存储在字符串常量池中。只要内容相同，程序中多次使用相同的字符串字面量时，它们都会指向常量池中的同一个对象。

• char 常量：char 可以是常量（例如 'a'），也可以是变量，但它本质上是一个基本数据类型，不是对象。char 常量并没有像字符串那样的“常量池”机制。

3. 为什么 charAt() 不会创建新对象

当你使用 charAt() 获取字符串中的某个字符时，返回的只是一个基本类型的 char 值，不会涉及到对象的创建或字符串的拼接，因此不会像 substring() 那样在堆内存中创建新对象。

String str = "hello";
char ch = str.charAt(1); // 返回 'e'

这里的 charAt(1) 返回的是 'e'，只是从字符串 str 中取出了这个字符，并没有创建新的对象，因为 char 是基本数据类型。

4. substring() 与 charAt() 的不同

• substring()：substring() 方法截取字符串，创建新的字符串对象，并返回这个对象。即使你从一个常量字符串中截取了一部分，substring() 返回的结果仍然是一个新的字符串对象。

• charAt()：charAt() 返回的是一个 char 基本类型的值，而不是一个对象。由于 char 是基本类型，因此不会像字符串对象那样需要额外的内存分配和对象创建。

5. char 和 String 常量的区别

• char 常量：比如 'a'，是基本类型，它的值直接存在栈上，不像字符串那样有常量池的概念。你可以在任何地方直接使用 char 常量，它不会像字符串一样占用大量内存。

• String 常量：字符串常量存储在常量池中，允许多个引用指向相同的内存地址，节省内存空间。

6. 总结：为什么 char 和 String 不一样

• char 是一个基本数据类型，其值直接存储，不涉及对象创建。

• String 是一个引用类型，是对象，涉及到对象的创建和内存管理。

• charAt() 返回一个 char 值，它只是提取字符，不需要创建新的对象。

• substring() 创建并返回的是一个新的字符串对象，即使它是从常量字符串中截取的。

因此，char 和 String 的区别主要在于存储机制和数据类型的不同，这是 Java 为了性能和内存优化做出的设计。

常量字符串我也可以截取里面的部分，当做一个正常的常量字符串使用？

是的，常量字符串中的部分可以通过方法截取

 1.截取常量字符串的部分

当你使用 substring() 等方法从常量字符串中截取一部分时，如果这部分字符串是从一个编译期确定的常量字符串中截取的，并且符合常量表达式的规则，Java 编译器会将其视为一个新的常量字符串，并存储在常量池中。

String str = "hello world";
String subStr = str.substring(0, 5); // 截取 "hello"

在这种情况下，str 是一个常量字符串，subStr 也是从中截取的常量字符串。这里，编译器可能会将 subStr 优化为常量池中的字符串 "hello"，而不创建新的对象。

2. 运行时截取和常量池

如果你是在运行时进行字符串截取（例如操作的不是编译时确定的字符串），那么 Java 会在堆内存中创建一个新的字符串对象，而不是将结果存储在常量池中。

String str1 = new String("hello world");
String subStr1 = str1.substring(0, 5); // 运行时创建一个新的字符串对象 "hello"

这里的 str1 是通过 new String() 创建的，在堆中分配内存，substring(0, 5) 会生成一个新的字符串对象并存储在堆中，不会进入常量池。

1. 字符串常量池的设计目的：优化性能和内存使用

Java 中的字符串常量池（String Pool）是为了优化内存使用。它的作用是避免在程序中创建重复的字符串对象。

• 当你声明一个字符串字面量时，比如：

  String str1 = "hello";

• String str2 = "hello";

  这两个字符串指向的是常量池中同一个字符串对象，不会重复创建。这种机制极大地减少了内存消耗，特别是在字符串频繁出现重复内容时。

• 由于常量字符串是不可变的，同一个字面量字符串可以被多个引用共享而不产生问题。这就是常量池的作用：复用相同的字符串对象，减少内存的使用和垃圾回收的负担。

2. new String() 为什么要创建新的字符串对象？

new String() 会在堆内存中创建一个新的字符串对象，即使内容与常量池中的字符串相同。

• 为什么需要 new String()？因为有时候你需要明确创建一个新的对象，而不是使用共享的常量池对象。比如，在某些特定场景下，程序可能需要对字符串对象的引用进行操作，不希望与其他引用共享相同的对象。

• 堆内存中的对象可以被独立操作和管理，而常量池中的对象则是全局共享的，不能被修改（因为字符串是不可变的）。new String() 提供了一个创建全新对象的方式，避免了在某些场景下的意外副作用。

字符串拼接和内存

当涉及到字符串拼接时，Java 可能会创建新的字符串对象：

• 如果拼接的是常量字符串，Java 会在编译时将它们合并为一个常量，并存储在常量池中，不会创建新的对象。

• 如果拼接的是运行时动态生成的字符串，Java 会在堆内存中创建新的字符串对象。

• String str1 = "hello";
  String str2 = new String(" world");
  String result = str1 + str2; // 运行时生成新的字符串对象
  

  在这种情况下，Java 会在堆中创建一个新的字符串 "hello world"。

在 Java 中，无论是常量字符串还是通过 new String() 创建的字符串，当你使用 charAt() 获取某个字符时，不会创建新的字符串或字符对象。charAt() 的结果是返回该字符串中指定位置的字符，而这个字符是基本数据类型 char，因此不会涉及到新建对象。

1. charAt() 的处理方式

1. 直接声明字符串常量

String str = "sadasd";

2. new String("asdasd") 创建新的字符串 

String str = new String("asdasd");

当你使用 new String("asdasd") 时，虽然 "asdasd" 是一个常量，并且会存储在字符串常量池中，但是 new String() 会在堆内存中再创建一个新的 String 对象。这意味着堆中和常量池中会存在两个不同的字符串对象，虽然它们的值相同，但它们是不同的对象。 

使用字符串常量下标获取字符

String str = "example";
char ch = str.charAt(2); // 获取下标为2的字符

在这里，charAt(2) 是从字符串常量中获取第 3 个字符，它并不会创建新的字符串或字符对象，而是直接从原有的字符串常量中取出对应的字符。 

常量字符串是由常量字符拼接起来的吗？

不完全是这样。常量字符串（字面量）本身存储在字符串常量池中，并不是由单个字符的拼接直接构成的。常量字符串在编译时已经是完整的字符串对象，而不是通过逐个字符拼接成的。

当你声明一个字符串字面量时，Java 会在编译阶段将它存储在字符串常量池中。即使你像下面这样拼接两个字符串常量，Java 也会在编译时优化为一个完整的常量字符串。

String str = "he" + "llo"; // 编译时优化为 "hello"

在这个例子中，"he" 和 "llo" 是常量，它们在编译时被合成为一个新的常量 "hello"，并且直接存储在字符串常量池中。 

匿名内部类

类的访问修饰符

1. public：

   • 类可以被任何其他类访问。
   • 适用于需要在整个应用程序中被广泛使用的类。

2. private：

   • 仅能在定义该类的外部类（在嵌套类的情况下）访问。
   • 这样的类通常用于只在特定上下文中使用，其他类无法直接创建或使用它们。

3. protected：

   • 类可以被同一包中的其他类和任何继承该类的子类访问。
   • 适用于希望让子类访问的类，但不希望其他类直接使用的情况。

4. internal（C# 特有）：

   • 类只能在同一程序集内访问。
   • 适用于希望限制访问到特定程序集的类。

5. 默认（无修饰符）（Java 特有）：

   • 类在同一包中可见，其他包中的类无法访问。
   • 用于在包内部共享类，但不想对外部可见。

c#里

• 如果不显式指定访问修饰符，类和接口的默认访问级别都是 internal。
• 要让它们在整个应用程序中可见，您需要显式地将它们声明为 public。

在 Java 中，类和接口的默认访问修饰符是“包私有”（package-private），即如果没有显式指定访问修饰符，类和接口只能在同一包内被访问。

接口

在 C# 中，接口的只读属性是实例成员，每个实现这个接口的类可以独立实现该属性，并返回不同的值。

java里则严格要求，不能让实现类里有接口带来的实例属性，实现类只能使用接口中的常量，而不能修改它们。

public interface MyInterface {
    int CONSTANT_VALUE = 100; // 必须赋值，且是 public static final
}

c#中

• 接口中只能定义方法的签名，不能包含实现。
• 接口中的方法默认是 public，且不能使用其他访问修饰符。

在 C# 中，接口中的成员（包括方法、属性、事件等）默认是 public。如果你没有显式地指定访问修饰符，编译器会将它们视为 public。例如：

public interface IMyInterface
{
    void MyMethod(); // 默认是 public
}

public interface IMyInterface
{
    void MyMethod();
    
    void DefaultMethod()
    {
        // 默认实现
    }
}

常量定义：在 Java 中，你可以定义常量，默认为 public static final。而在 C# 中，接口不允许定义字段或常量，但可以定义只读属性。

关于常量

接口这个东西，可以设置static常量附着在该接口类上，在接口中写的所有，都为public，public为接口特色，

在c#，可以定义只读属性，附着在该接口类上，java里，则是可以定义static final int 常量，通过该方式定义常量

在 Java 中，接口中定义的常量是 public static final 的，必须在接口中赋值，不能在实现类中重新赋值。

java

Java 8，引入了默认方法和静态方法的实现。

属性：

• 接口中可以定义常量（static final），但不能定义实例变量。常量必须是 public static final，通常省略修饰符：

• public interface MyInterface {
      void doSomething();
      
      default void doDefault() {
          // 默认实现
      }
  }
  
  
  public interface MyInterface {
      int MY_CONSTANT = 10; // 默认是 public static final
  }
  
  public interface MyInterface {
      static void myStaticMethod() {
          // 静态方法实现
      }
  }
  

实现接口的类必须提供所有方法的实现（除非类是抽象类）

public class MyClass implements MyInterface {
    @Override
    public void doSomething() {
        // 实现代码
    }
}

 总结

总结一下，所有的接口，全是public是一大特征，

然后在java里，接口更加独立于实现类，对于常量，都static final属于接口且必须赋值，

而在C#里，对于常量，有非静态只读属性，可以只在接口里声明，然后在各个不同的实现类里各自设置只读属性值，

对于方法，两者都可以只定义，也可以在接口里预先实现，并可在实现类中重写

构造器

java的访问修饰符

子类继承之后，父类的私有只是不能访问而已，可是依然存在，

子类不能继承父类的私有成员，意思是子类会开一块区域，父类也开一块区域，两个所处内存位置不同，但因为继承的关系，子类可以调用父类内存区域的方法

父类的数据存储在子类对象的内存中，子类只是不能直接访问父类的 private 成员而已。

这是因为子类对象不仅包含子类自己的成员，还包含父类的成员——无论是 private、protected 还是 public 成员，尽管 private 成员只能在父类内部访问。

子类只能继承父类的非私有成员

父类中的私有成员和方法不能被子类继承

父类中的私有也不能被子类重写

java的static

在Java中，可以使用类对象来访问静态变量，但实际上这是不推荐的

在C#中，静态变量必须通过类名来访问，不能通过对象来访问

c的static相关补充

c中的静态变量是属于定义的函数的，只不过是全局存在的

如果在外部定义，和直接定义的变量不同的是，静态变量只限于本文件内可以用，

• static局部变量：生命周期是整个程序运行期间，但作用域限制在函数内。
• static全局变量：作用域限制在当前源文件，生命周期是整个程序。
• 非static全局变量：可以被整个程序中的其他源文件引用。

假设有两个文件：file1.c 和 file2.c。

• 在 file1.c 中定义一个全局变量。
• 在 file2.c 中使用 extern 关键字来声明该全局变量，这样就可以在 file2.c 中访问和修改 file1.c 中的全局变量。

• 文件1: file1.c
  #include <stdio.h>
  
  int sharedVariable = 42;  // 定义全局变量
  
  void modifyVariable() {
      sharedVariable++;  // 修改全局变量
      printf("In file1.c, sharedVariable = %d\n", sharedVariable);
  }
  ---------------------------------------------------------------------
  文件2: file2.c
  #include <stdio.h>
  
  extern int sharedVariable;  // 声明 file1.c 中的全局变量
  
  void printVariable() {
      printf("In file2.c, sharedVariable = %d\n", sharedVariable);
  }
  
  int main() {
      printVariable();   // 输出 file1.c 中的 sharedVariable 值
      sharedVariable += 10;  // 修改该变量
      printVariable();   // 输出修改后的 sharedVariable 值
      return 0;
  }
  

  使用 extern 引用其他文件中的变量时，变量名必须与定义时保持一致。这是因为 C 语言在编译和链接时，依赖变量的名称来关联不同源文件中的全局变量。

• 例如，在文件 file1.c 中定义了全局变量 int a;，那么在 file2.c 中，使用 extern 时必须写作 extern int a;，这样才能正确引用到 file1.c 中的变量 a。

• 如果没有使用 static 修饰符，全局变量在同一个程序的不同源文件中不能重名，否则会导致重定义错误。编译器在链接阶段会报错，因为它发现同名的全局变量在不同文件中有多个定义。

• 如果你希望在不同文件中使用同名的全局变量，就用 static 修饰符将变量的作用域限制在各自的文件内，这样即使同名变量在不同文件中定义，它们也不会冲突。static 关键字会将变量的作用域限制在定义它的文件中，从而避免冲突。

Java中，类中的成员变量（也称为字段）默认并不是private

访问修饰符的默认行为：

• private: 变量只能在类的内部访问。
• default（没有修饰符）: 变量只能在同一个包内的类中访问。
• protected: 变量可以在同一个包内，或者在其他包中的子类中访问。
• public: 变量可以在任何地方访问。

ASCII 表中

ASCII 表中，大小写字母并不是紧密相连的

大写字母 (A 到 Z) 对应的码值是 65 到 90

中间的 91 到 96

• 91: [
• 92: \
• 93: ]
• 94: ^
• 95: _
• 96: `

小写字母 (a 到 z) 对应的码值是 97 到 122。

java输出

随机数的生成

 Math.random生成0到1之间的随机小数

Random r=new Random();//生成一个随机数对象

通过r.nextInt(int整数);生成0到int数之间的随机一个数

注：绝大多数的随机数都是包前不包后

enum

Java 不允许将整数直接赋给 enum 类型变量。你必须使用 enum 类型定义的常量。

也不允许 enum 类型通过整型强制转换

Color myColor = Color.RED; // 正确
// Color myColor = 0; // 编译错误

C# 不能直接整数赋值，如果要赋值要强制转换。

Color myColor = (Color)0; // 强制转换
// Color myColor = 0; // 编译错误

 C和C++可以直接整数赋值

C#和C和C++都可以给枚举赋超出范围的整数值，该枚举变量会记住这个值，

只不过表现的更像一个数而不是枚举

switch

java

C#也一样不能用float，double，long 

c和c++本质是把switch当做整数接受器，enum只是另外一种整型的表现方式，所以，c的switch传入的enum要强转回整数，c++虽然优化了不用强转回整数接受，但本质上还是接受整数

而java和c#则是把switch当做类型接受器，传入的类型一定要和case标签类型相同，不同的是，在enum的传入上，java必须传入enum类型不能用整数强转，而c#支持整数的强转成对应的enum

Java 的 switch 语句支持的类型有：

• byte
• short
• char
• int
• enum（从 Java 5 开始）
• String（从 Java 7 开始）
• var（Java 12 中的增强型 switch 表达式）

C# 中的 switch 语句支持的类型类似于 Java，包括：

• char
• string
• bool
• enum
• 整型类型（int、byte、short 等）
• C# 7 之后，支持模式匹配（switch 表达式的增强）

在所有语言中，switch 不会自动进行类型转换，类型必须严格匹配。

都不支持float和double作为case标签的数据类型

c#和java：支持整数、枚举、字符串等类型作为 switch 表达式和 case 标签

c和c++：只支持整数和枚举

枚举类型在C和C++中有所不同。在C语言中，枚举类型（enum）虽然本质上是整数，但不能直接用于switch语句中，必须通过强制类型转换将枚举值转换为整数类型。

#include <stdio.h>

enum Color {
    RED,    // 默认值为 0
    GREEN,  // 默认值为 1
    BLUE    // 默认值为 2
};

int main() {
    enum Color myColor = 0; // 设置为 0，相当于 RED
    /*在c++中
    Color myColor = GREEN;

    或者
    Color myColor = static_cast<Color>(0);//设置为RED

    也可以将整数值 0 直接赋给 enum 类型的变量
    Color mycolor=0;    

    */
    
    //c++仅仅是优化了不用强转int的操作，本质上仍与c相同
    switch (1) {//会进入GREEN//这与在c++中相同
        case RED:
            printf("Color is RED\n");
            break;
        case GREEN:
            printf("Color is GREEN\n");
            break;
        case BLUE:
            printf("Color is BLUE\n");
            break;
        default:
            printf("Unknown color\n");
            break;
    }

    return 0;
}

&, |, ^

C, C++, Java, C# 等语言中，按位运算符（&, |, ^）遵循类型提升规则：

1. 整数类型提升：如果操作数是小于 int 的类型（如 char, short 等），它们会先提升为 int。
2. 如果操作数有不同的宽度（比如一个是 int，另一个是 long），较窄的类型会被提升为较宽的类型。
3. 如果一个操作数是有符号类型，另一个是无符号类型，通常会将有符号类型提升为无符号类型（具体规则依赖于语言的实现）。
4. 位运算直接操作的是数据的二进制位，所以只能用于整数类型。

都可以进行位运算

int a = 5;  // 0101
int b = 3;  // 0011
int result = a & b; // 0001, result is 1
int result = a | b; // 0111, result is 7
int result = a ^ b; // 0110, result is 6

C# 和 Java 类似，& 和 | 额外可以判断bool运算，但不具备短路特性。如果需要短路逻辑运算，C# 使用 && 和 ||。

在 C 和 C++ 中，&, |, ^ 只能作为按位运算符，它们对整数的每一位进行操作，不能用于逻辑运算。逻辑运算必须使用 &&（逻辑与）和 ||（逻辑或）。

比较运算符

关系运算符比较，如果两边的类型不一样也会转成最高类型再比较

int a = 5;
double b = 5.5;
boolean result = a < b; // a 被提升为 double 进行比较

是的，在大多数编程语言中，关系运算符（如 <, >, <=, >=, ==, !=）比较时，如果两边的类型不同，会先进行类型转换，然后再进行比较。这个过程叫做类型提升（type promotion），通常会将较低精度的类型转换为较高精度的类型。

在 Java 中，不同类型之间进行关系运算时，会遵循自动类型提升的规则：

• 如果一个操作数是 byte, short, char，则它们会先提升为 int 类型。
• 如果一个操作数是 int 而另一个是 long，则 int 会被提升为 long。
• 如果一个操作数是 float 而另一个是 double，则 float 会被提升为 double。
• 数值类型（如 int, long, float, double）会根据两边的最大类型进行提升。

在 C# 中，类似的规则也适用：

• 如果两边类型不同，较小的类型将提升为较大的类型，以进行比较。
• int 会被提升为 long，float 会被提升为 double，等等。

在 C 和 C++ 中，类型提升也是相似的：

• char, short 等会被提升为 int。
• int 会提升为 long、float、double 等更高精度的类型。
• 如果一个操作数是 float，另一个是 double，则 float 会被提升为 double。

+运算符

从前往后算，能相加优先相加，不能相加则拼接

char是可以转成数相加的，在没有拼接需求之前，char都可以看做数去相加

java的Scanner输入

（需要先导包）import java.util.Scanner

Scanner scanner = new Scanner(System.in);

常用方法：

• next(): 读取下一个以空格或换行分隔的字符串。
• nextLine(): 读取一整行输入，直到遇到换行符。
• nextInt(): 读取下一个整数。
• nextDouble(): 读取下一个浮点数。
• hasNext(), hasNextInt(), hasNextDouble(): 用于检测是否有下一个可读取的输入数据。

注意事项：

• 输入不匹配：当用户输入与预期的数据类型不匹配时，可能会抛出 InputMismatchException。例如，调用 nextInt() 时输入了一个字符串。
• 资源管理：在读取输入完成后，建议调用 scanner.close() 关闭 Scanner，防止资源泄露。

通过创建Scanner类的对象，调用对象的next方法

字面量，字面上的量

一个方法中，该方法名和其中的变量名可以相同

API为什么叫API

API（应用程序接口，Application Programming Interface）

规范化的交互方式

面向对象编程中的接口是你必须实现的，而 API 是你直接使用的。

但两者的相似点在于：它们都提供了一组明确的规则和方法来与其他代码或系统进行交互。

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

这里的 ArrayList 是一个现成的类，add 方法是它提供的 API。你无需知道它内部如何实现，只需调用它提供的功能（当然，arraylist也是API）

一组可以让不同软件组件或系统之间进行交互的定义和协议

提供现成的功能供开发者使用，不是为了让你去实现，而是为了调用，从而完成特定任务。

API 可能包括库、函数、类、或者在线服务的调用

自动类型转换

扩展运算符自带强转自身类型（适用多种语言c，c++，c#）

int a = 5;
double b = 2.5;
a += b;  // a = (int)(a + b)，结果是 7

在这个例子中，a 是 int，b 是 double，在 a += b 中：

• a + b 会先转换为 double 类型（因为 double 是更高精度的类型），
• 结果是 7.5，然后由于 a 是 int，最终的结果会被强制转换为 int，舍弃小数部分，变为 7。

结果最终一定会匹配左侧变量的类型 

 在java中，如果想byte之间相加，不用扩展赋值运算符，赋值给byte时必须强转，因为相加时默认都转为int了，必须转回来否则报错，在c#也相同

Java 和 C#: byte （char类型也一样）类型相加结果会提升为 int，必须显式 强制转换回 byte（或者char）  

char a = 'A'; // Unicode 65
char b = 'B'; // Unicode 66
int sum = a + b; // sum 是 int 类型
char result = (char) (a + b); // 需要强制转换回 char

java和C#中char和int并不一体，而c++和c中char和int似乎可以一体 

C 和 C++

• char 可以作为整数类型：在 C 和 C++ 中，char 实际上是一个整数类型，通常占用 8 位（signed 或 unsigned）。char 类型的变量在算术运算中可以与 int 类型互换，因此可以直接进行算术运算而不需要显式转换。

• char a = 'A'; // ASCII 65
  char b = 'B'; // ASCII 66
  int sum = a + b; // sum 是 int 类型
  char result = a + b; // 结果会被隐式转换为 char，但可能会有溢出

但扩展赋值运算符，这些语言都一样，会最后进行强转

表达式中运算，小范围byte，short，char，优先转为int后，再开始判断运算

即使是byte+byte也会得到int

double在float之上，而float在long之上

结果取决于整个运算表达式的最高类型，无论顺序

int a = 5;
double b = 2.0;
double result = a / b;  // 结果为 2.5

• C# 和 Java 的自动类型转换大体相似，都能隐式地从较小范围类型转换为较大范围类型。
• C# 支持用户自定义的隐式和显式转换（implicit 和 explicit 关键字），而 Java 不允许用户定义类型转换。

• //隐式转换
  class Celsius
  {
      public double Degrees { get; set; }
  
      public static implicit operator Celsius(double d)
      {
          return new Celsius { Degrees = d };
      }
  }
  
  Celsius temp = 36.5;  // 隐式转换

• 泛型协变与逆变 是 C# 特有的功能，而 Java 使用通配符来实现类似功能。
• 装箱和拆箱 在两者中都存在，但 Java 的自动装箱/拆箱机制更加简便。

PATH

• PATH 变量 是操作系统的环境变量之一，包含了一系列目录路径，操作系统在运行程序时会在这些目录中查找可执行文件。
• 例如，当你在命令行中输入 java 或 javac，操作系统会在 PATH 变量中列出的目录中查找这些命令的可执行文件。

bin

bin 文件夹：Java Development Kit (JDK) 安装目录下的 bin 文件夹包含了 Java 编译器（javac）、Java 运行时环境（java）等命令行工具。

添加到 PATH：将 bin 文件夹添加到 PATH 变量中，可以让你在任何命令行窗口中直接运行 Java 相关的命令，而不需要每次都导航到 JDK 的安装目录。

验证设置：

• 打开命令提示符（cmd），输入 java -version 和 javac -version，检查是否能正确输出 Java 版本信息。

更新上下文菜单

上下文菜单 是指在操作系统的文件资源管理器中，右键点击文件或文件夹时弹出的菜单。这个选项的作用是将一些功能（如打开特定文件类型的 IDE）添加到文件的右键菜单中。

• 作用：通过选择"更新上下文菜单"，你可以将 IntelliJ IDEA（或其他工具）集成到操作系统的上下文菜单中。例如，你可以右键点击一个 .java 文件，然后选择“用 IntelliJ IDEA 打开”来快速启动 IDE 并打开该文件。
• 方便性：这使得文件和项目的管理更加便捷，尤其是在处理多个文件时。

创建关联

文件关联 指的是将特定文件类型与一个程序关联，使得在打开该文件时，操作系统会默认使用这个程序。

• 作用：选择"创建关联"可以将 IntelliJ IDEA 设置为打开特定类型文件的默认应用。例如，你可以将 .java、.xml 或 .html 文件与 IntelliJ IDEA 关联，这样双击这些文件时会自动用 IntelliJ IDEA 打开。
• 方便性：这种关联使得文件打开变得更加高效，无需每次都手动选择程序来打开文件。

更新上下文菜单：将 IDE 或其他工具添加到文件资源管理器的右键菜单中，方便快速打开文件。

创建关联：将特定类型的文件与 IDE 关联，使得打开这些文件时自动使用 IDE。