Java的学习(语法相关)

字符串存储的问题

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

1. charString 的区别

  • 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. charString 常量的区别

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

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

6. 总结:为什么 charString 不一样

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

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

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

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

因此,charString 的区别主要在于存储机制和数据类型的不同,这是 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 {@Overridepublic void doSomething() {// 实现代码}
}
 总结

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

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

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

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

构造器

java的访问修饰符

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

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

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

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

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

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

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

java的static

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

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

c的static相关补充

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

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

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

假设有两个文件:file1.cfile2.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 表中,大小写字母并不是紧密相连的

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

中间的 91 到 96

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

小写字母 (az) 对应的码值是 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
  • 整型类型(intbyteshort 等)
  • C# 7 之后,支持模式匹配(switch 表达式的增强)

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

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

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

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

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

#include <stdio.h>enum Color {RED,    // 默认值为 0GREEN,  // 默认值为 1BLUE    // 默认值为 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# 使用 &&||

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

比较运算符

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

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 会被提升为 longfloat 会被提升为 double,等等。

C 和 C++ 中,类型提升也是相似的:

  • char, short 等会被提升为 int
  • int 会提升为 longfloatdouble 等更高精度的类型。
  • 如果一个操作数是 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

在这个例子中,aintbdouble,在 a += b 中:

  • a + b先转换为 double 类型(因为 double 是更高精度的类型)
  • 结果是 7.5,然后由于 aint,最终的结果会被强制转换为 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 可以作为整数类型:在 CC++ 中,char 实际上是一个整数类型,通常占用 8 位(signedunsigned)。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# 支持用户自定义的隐式和显式转换(implicitexplicit 关键字,而 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 变量操作系统的环境变量之一,包含了一系列目录路径,操作系统在运行程序时会在这些目录中查找可执行文件。
  • 例如,当你在命令行中输入 javajavac,操作系统会在 PATH 变量中列出的目录中查找这些命令的可执行文件。

bin

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

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

验证设置

  • 打开命令提示符(cmd),输入 java -versionjavac -version,检查是否能正确输出 Java 版本信息。

更新上下文菜单

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

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

创建关联

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

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

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

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

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/437862.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Java-数据结构-Map和Set(三)-习题 o(´^`)o

目录 ❄️一、习题一(只出现一次的数字)&#xff1a; ❄️二、习题二(随机链表的复制)&#xff1a; ❄️三、习题三(宝石与石头)&#xff1a; ❄️四、习题四(旧键盘)&#xff1a; ❄️五、习题五(前k个高频单词)&#xff1a; ❄️总结&#xff1a; ❄️一、习题一(只出现一…

Python(三)——列表

文章目录 创建列表访问下标遍历列表元素新增元素查找元素删除元素连接列表切片操作 创建列表 创建列表主要有两种方式 [ ]表示一个空的列表 a [] print(type(a)) # <class list> print(a) # []通过list()的方式来创建一个空列表 a list() print(type(a)) # …

Java对象头

一、对象在堆内存中的布局 1.定义 在HotSpot虚拟机中&#xff0c;对象在堆内存的存储布局可以划分为三个部分&#xff1a;对象头&#xff08;Header&#xff09;、实例数据&#xff08;Instance Data&#xff09;、和对齐填充&#xff08;Paddin&#xff09;。 二、对象在堆内…

Rstudio:强大的R语言集成开发环境(IDE)

Rstudio 应该是 R 语言使用的标配&#xff0c;尽管 Rstudio 的母公司 Posit 推出了新一代的集成开发环境 Positron&#xff0c;但其还处于开发阶段。作为用户不妨让其成熟后再使用&#xff0c;现阶段还是 Rstudio 更稳定。 如果你在生物信息学或统计学领域工作&#xff0c;R语言…

【springboot】整合沙箱支付

目录 1. 配置沙箱应用环境2. 配置springboot项目1. 引入依赖2. 配置文件注册下载ngrok 3. 创建支付宝支付服务类4. 支付界面模板5. 控制类实现支付6. 测试 1. 配置沙箱应用环境 使用支付宝账号登录到开放平台控制台。 使用支付宝登录后&#xff0c;看到以下页面&#xff0c;下…

动态内存分配

1. 基本使用 在内存空间中&#xff0c;我们如何做到想用多少内存空间就申请多少内存空间&#xff1f; 使用以下函数可以实现&#xff1a; 如何利用malloc申请一片连续的内存空间&#xff1a; int* p malloc(100 * sizef(int)); 该代码实现了&#xff0c;申请一片空间&#…

VS开发 - 静态编译和动态编译的基础实践与混用

目录 1. 基础概念 2. 直观感受一下静态编译和动态编译的体积与依赖项目 3. VS运行时库包含哪些主要文件&#xff08;从VS2015起&#xff09; 4. 动态库和静态库混用的情况 5. 感谢清单 1. 基础概念 所谓的运行时库&#xff08;Runtime Library&#xff09;就是WINDOWS系统…

828华为云征文|WordPress部署

目录 前言 一、环境准备 二、远程连接 三、WordPress简介 四、WordPress安装 1. 基础环境安装 ​编辑 2. WordPress下载与解压 3. 创建站点 4. 数据库配置 总结 前言 WordPress 是一个非常流行的开源内容管理系统&#xff08;Content Management System, CMS&#xf…

进度条(倒计时)Linux

\r回车(回到当前行开头) \n换行 行缓冲区概念 什么现象&#xff1f; 什么现象&#xff1f;&#xff1f; 什么现象&#xff1f;&#xff1f;&#xff1f; 自己总结&#xff1a; #pragma once 防止头文件被重复包含 倒计时 在main.c中&#xff0c;windows.h是不可以用的&…

CleanMyMac X v4.12.1 中文破解版 Mac优化清理工具

在数字时代&#xff0c;我们的Mac设备承载着越来越多的重要信息和日常任务。然而&#xff0c;随着时间的推移&#xff0c;这些设备可能会变得缓慢、混乱&#xff0c;甚至充满不必要的文件。这就是CleanMyMac X发挥作用的地方。 CleanMyMac X是一款功能强大的Mac优化工具&#…

Python 从入门到实战32(数据库MySQL)

我们的目标是&#xff1a;通过这一套资料学习下来&#xff0c;通过熟练掌握python基础&#xff0c;然后结合经典实例、实践相结合&#xff0c;使我们完全掌握python&#xff0c;并做到独立完成项目开发的能力。 上篇文章我们讨论了数据库编程接口操作的相关知识。今天我们将学习…

CSP-J Day 3 模拟赛补题报告

姓名&#xff1a;王胤皓&#xff0c;校区&#xff1a;和谐校区&#xff0c;考试时间&#xff1a; 2024 2024 2024 年 10 10 10 月 3 3 3 日 9 : 00 : 00 9:00:00 9:00:00~ 12 : 30 : 00 12:30:00 12:30:00&#xff0c;学号&#xff1a; S 07738 S07738 S07738 请关注作者的…

[20241003] 狂飙500天,国产大模型如何突破商业化之困?

大模型加速狂飙&#xff0c;AI商业化却面临巨大鸿沟。 一方面&#xff0c;传统企业不知道怎么将AI融入原始业务&#xff0c;另一方面&#xff0c;AI企业难以找到合适的变现方式。AI企业究竟该如何突破商业化之困&#xff1f;B端和C端&#xff0c;呈现出两种不同的路径。 纵…

Pikachu-暴力破解-验证码绕过(on client)

访问页面&#xff0c; 从burpsuite 上看到返回的源代码&#xff1b; 验证码生成时通过 createCode 方法生成&#xff0c;在前端页面生成&#xff1b; 同时也是在前端做的校验&#xff1b; 直接验证&#xff1b;F12 -- 网络&#xff0c;随便输入个账号、密码、验证码&#xff0…

OceanBase—02(入门篇——对于单副本单节点,由1个observer扩容为3个observer集群)——之前的记录,当初有的问题未解决,目前新版未尝试

OceanBase—02&#xff08;入门篇——对于单副本单节点&#xff0c;由1个observer扩容为3个observer集群&#xff09;——之前的记录&#xff0c;有的问题未解决&#xff0c;新版未尝试 1、前言—安装单副本单节点集群1.1 docker安装OB 2、查看现有集群情况2.1 进入容器&#x…

计算机网络的整体认识---网络协议,网络传输过程

计算机网络背景 网络发展 独立模式: 计算机之间相互独立; 网络互联: 多台计算机连接在一起, 完成数据共享; 局域网LAN: 计算机数量更多了, 通过交换机和路由器连接在一起; 广域网WAN: 将远隔千里的计算机都连在一起;所谓 "局域网" 和 "广域网" 只是一个相…

【EXCEL数据处理】000011 案列 EXCEL带有三角形图标的单元格转换,和文本日期格式转换。

前言&#xff1a;哈喽&#xff0c;大家好&#xff0c;今天给大家分享一篇文章&#xff01;创作不易&#xff0c;如果能帮助到大家或者给大家一些灵感和启发&#xff0c;欢迎收藏关注哦 &#x1f495; 目录 【EXCEL数据处理】000011 案列 EXCEL带有三角形图标的单元格转换。使用…

基于SpringBoot+Vue+MySQL的民宿预订平台

系统展示 用户前台界面 管理员后台界面 商家后台界面 系统背景 随着旅游业的蓬勃发展&#xff0c;民宿作为一种独特的住宿方式&#xff0c;受到了越来越多游客的青睐。然而&#xff0c;传统的民宿预定方式往往存在信息不对称、效率低下等问题&#xff0c;难以满足游客的个性化需…

npm切换到淘宝镜像

1、输入以下命令后回车&#xff0c;npm切换至淘宝镜像 npm config set registry https://registry.npmmirror.com 2、输入以下命令后回车&#xff0c;检查是否切换成功 npm config get registry 若返回此信息&#xff0c;表示切换成功 3、切换后就可使用淘宝镜像加快npm包的…

es6语法

es6语法 let和const命令 let let声明的变量&#xff0c;只在let命令所在的代码块内有效 {let a 10;var b 20; } console.log(a); //a is not defined console.log(b); //202.不存在遍历提升现象 var命令会发生变量提升现象&#xff0c;即变量可以在声明之前使用&#xf…