Java的学习（语法相关）

red_redemption2024-10-03 19:11

字符串存储的问题

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

  1. char 和 String 的区别

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

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

  1. 常量与非常量的区别

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

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

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

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

java 复制代码 
String str = "hello";
char ch = str.charAt(1); // 返回 'e'

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

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

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

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

  1. char 和 String 常量的区别

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

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

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

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

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

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

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

因此，char 和 String 的区别主要在于存储机制和数据类型的不同，这是 Java 为了性能和内存优化做出的设计。
常量字符串我也可以截取里面的部分，当做一个正常的常量字符串使用？

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

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

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

java 复制代码 
String str = "hello world";
String subStr = str.substring(0, 5); // 截取 "hello"

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

  1. 运行时截取和常量池

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

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";

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

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

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

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

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

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

字符串拼接和内存

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

  • 如果拼接的是常量字符串，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() 的处理方式

  2. 直接声明字符串常量

java 复制代码 
String str = "sadasd";
  1. new String("asdasd") 创建新的字符串
java 复制代码 
String str = new String("asdasd");

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

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

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

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

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

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

当你声明一个字符串字面量时，Java 会在编译阶段将它存储在字符串常量池中。即使你像下面这样拼接两个字符串常量，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里则严格要求，不能让实现类里有接口带来的实例属性，实现类只能使用接口中的常量，而不能修改它们。

java 复制代码 
public interface MyInterface {
    int CONSTANT_VALUE = 100; // 必须赋值，且是 public static final
}
c#中
  • 接口中只能定义方法的签名，不能包含实现。
  • 接口中的方法默认是 public，且不能使用其他访问修饰符。

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

cs 复制代码 
public interface IMyInterface
{
    void MyMethod(); // 默认是 public
}
cs 复制代码 
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，通常省略修饰符：
java 复制代码 
public interface MyInterface {
    void doSomething();
    
    default void doDefault() {
        // 默认实现
    }
}


public interface MyInterface {
    int MY_CONSTANT = 10; // 默认是 public static final
}

public interface MyInterface {
    static void myStaticMethod() {
        // 静态方法实现
    }
}

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

java 复制代码 
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 中的全局变量。
cpp 复制代码 
文件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 类型通过整型强制转换

java 复制代码 
Color myColor = Color.RED; // 正确
// Color myColor = 0; // 编译错误

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

cs 复制代码 
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语句中++ ，必须通过强制类型转换将枚举值转换为整数类型。

cpp 复制代码 
#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. 位运算直接操作的是数据的二进制位，所以只能用于整数类型。

都可以进行位运算

java 复制代码 
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++ 中，&, |, ^ 只能作为按位运算符 ，它们对整数的每一位进行操作，不能用于逻辑运算。逻辑运算必须使用 &&（逻辑与）和 ||（逻辑或）。

比较运算符

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

cs 复制代码 
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

java 复制代码 
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 是你直接使用的。

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

java 复制代码 
List<String> list = new ArrayList<>();
list.add("Hello");

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

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

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

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

自动类型转换

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

java 复制代码 
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）

java 复制代码 
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 类型互换，因此可以直接进行算术运算而不需要显式转换。
cpp 复制代码 
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之上

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

java 复制代码 
int a = 5;
double b = 2.0;
double result = a / b;  // 结果为 2.5
  • C# 和 Java 的自动类型转换大体相似，都能隐式地从较小范围类型转换为较大范围类型。
  • C# 支持用户++自定义的隐式和显式转换（++ implicit 和 explicit 关键字++）++ ，而 Java 不允许用户定义类型转换。
cs 复制代码 
//隐式转换
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。

相关推荐
爱编程的小生4 分钟前
Easyexcel（2-文件读取）
java·excel
带多刺的玫瑰21 分钟前
Leecode刷题C语言之统计不是特殊数字的数字数量
java·c语言·算法
计算机毕设指导61 小时前
基于 SpringBoot 的作业管理系统【附源码】
java·vue.js·spring boot·后端·mysql·spring·intellij-idea
Gu Gu Study1 小时前
枚举与lambda表达式，枚举实现单例模式为什么是安全的，lambda表达式与函数式接口的小九九~
java·开发语言
Chris _data1 小时前
二叉树oj题解析
java·数据结构
牙牙7051 小时前
Centos7安装Jenkins脚本一键部署
java·servlet·jenkins
paopaokaka_luck1 小时前
[371]基于springboot的高校实习管理系统
java·spring boot·后端
以后不吃煲仔饭2 小时前
Java基础夯实——2.7 线程上下文切换
java·开发语言
进阶的架构师2 小时前
2024年Java面试题及答案整理（1000+面试题附答案解析）
java·开发语言
The_Ticker2 小时前
CFD平台如何接入实时行情源
java·大数据·数据库·人工智能·算法·区块链·软件工程
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作