当前位置：首页 > news >正文

Java基础总结上(Ref：JavaGuide)

news 来源：原创 2025/7/5 17:30:35

基础概念与常识

Java语言有哪些特点，优点？

简单易学，是一门面向对象的语言，有封装继承多态三大特性，而且有多重防护机制保证安全性，例如权限修饰符，限制程序直接访问操作系统资源。通过JIT编译器提升了Java语言的运行效率，还有一点就是平台的无关性，Java语言并不依赖系统平台，而是依赖虚拟机，“Write once , Run anywhere"一次编写，随处运行，是Java最大的优势之一，还有就是Java强大的生态。

JavaSE和JavaEE

JavaSE：

是Java平台的标准版，java语言的基础，适合简单的开发。

JavaEE:

Java平台的企业版，也可以说是高级版本，包含了支持企业级开发部署的标准和规范，例如：Servlet,JSP,JDBC等，建立在javaee的基础上，适合开发复杂的企业级应用。

JVM vs JDK vs JRE

JVM：

是运行Java字节码的虚拟机，jvm对于不同的系统有不同的实现，目的就是为了使用相同的字节码给出相同的结果，字节码和不同系统的JVM是java语言一次编译，随处运行的关键所在。

JVM并不是只有一种，只要满足Jvm规范，都可以开发属于自己的JVM。

JVM种类；最常用：HotSpot VM，J9 VM，Zing VM等。

JDK和JRE

jdk是一个功能齐全的Java开发工具包，用于创建和编译Java程序，它包含了JRE，以及编译器javac和其它工具。

JRE是运行已编译的java程序所需要的环境，主要包含两个部分：jvm和Java基础类库，java基础类库就是提供了常用的功能和API，如IO操作，网络通信，数据结构等。

简单来说，JRE只包含了运行Java程序所需要的环境和类库，而JDK不仅包含了JRE，还包括了Java开发和调试的工具。

不过从JDK9开始，就不区分二者的关系了，取而代之的是模块系统（JDK 被重新组织成 94 个模块）+ jlink 工具 (随 Java 9 一起发布的新命令行工具。

什么是字节码？采用字节码的好处？

在java中，可以被jvm识别的代码就是字节码，扩展名为.class的文件。字节码并不针对于特定的机器，所以java程序无需重新编译便可以在多种不同操作系统的计算机上运行，其实就是字节码面向JVM，而非操作系统。

.class字节码文件经类加载器加载到JVM中，然后解释器开始逐行解释执行，但是如果让解释器老执行一些热点代码，那么效率就太低了，所以引进了JIT编译器即时编译，JIT会判断哪些是热点代码，然后将他们编译成机器码并保存下来，机器码就是二进制文件，直接由CPU执行，所以机器码的运行效率肯定高于解释器，那么那些热点代码就不用解释器重复解释了，效率也就高了，这也就是为什么说Java是编译与解释共存的语言。

如何判断哪些是热点代码呢？

JVM会设置一个阈值，当方法或者代码块在一定时间内的调用次数超过这个阈值时就会被JIT编译，存入codeCache中，当下次执行时，在遇到这段代码，就会从codeCache中读取机器码，直接执行，以此来提升程序运行的性能。

详情可以：[基本功 | Java即时编译器原理解析及实践]

为什么说Java语言编译与解释并存？

高级编程语言按照程序的执行方式分为两种：

编译型语言：

编译型语言通过编译器将源代码一次性翻译成可以被该平台执行的机器码。一般情况下开发效率较低，但是执行速度较快。常见的编译型语言有：c，cpp，go，rust。

解释型语言：

解释型语言通过解释器一句一句的将代码解释为机器代码后在执行。开发效率较快，执行速度较慢，例如python，js，php。

而Java具有这二者的特征，因为Java编写的程序要先被编译为字节码文件，然后这种字节码文件必须由Java解释器来执行，这就是为什么java编译与解释共存。

AOT有什么优点？为什么不全部使用AOT？

从图中我们可以看到到一个Java程序从启动到被JIT动态编译优化会经过好几个过程（VM init，App init 和 App active 几个阶段），冷启动问题比较严重，而且在这几个过程中，运行内存占用较高，因为JVM会并不知道哪些是热点代码，所以会将所有代码全部加载，这就造成了实际加载的代码比实际需要运行的代码多很多的情况，这就是因为Java程序的编译优化在程序运行时，但是如果可以将编译优化这一步骤提前到运行前，就可以避免加载不必要的代码，这就是AOT（提前编译、静态编译）。

AOT的核心思想就是：将Java程序的编译阶段提前到程序启动前，然后在编译阶段进行代码编译优化，也就是说在程序被执行前就将其编译成机器码，让程序启动即巅峰，消除冷启动，降低运行时内存消耗，而且AOT编译后的代码不容易被反编码和修改，特别适合云原生的场景。

但是并不是所有场景都可以使用AOT，因为AOT无法支持Java的一些动态特性，如反射，动态代理，动态加载等，然而很多的框架都用到了这些特性，例如Spring，CGLIB。举个例子，CGLIB动态代理使用的是ASM技术，而这种技术大致原理是运行时直接在内存中生成并加载修改后的字节码文件，如果全部使用AOT提前编译，也就不能使用ASM技术，为了支持类似的动态特性，所以选择使用JIT即时编译。

Java和C++的区别

Java不提供指针来直接访问内存，程序内存更加安全。

Java的类是单继承的，C++支持多继承，虽然Java的类不可以多继承，但是接口可以多继承。

Java有自动内存管理垃圾回收机制（GC），不需要程序员去手动释放无用内存。

C++增加了操作符的重载，而Java只支持方法的重载。

基本语法

注释有哪几种形式？

单行注释：通常用于解释方法内某单行代码的作用。

多行注释: 通常用于解释一段代码的作用。

文档注释：通常用于生成Java开发文档。（使用相对较少）

注释是我们的代码说明书，能够帮助看代码的热能快速的理清代码之间的逻辑关系。因此，在写程序的时候随后加上注释是一个非常好的习惯。但是注释不是越详细越好，因为好的代码本身就是注释，我们要尽量规范和美化自己的代码来减少不要的注释。如果编程语言足够有表达能力，就不需要注释，尽量通过代码来阐述。

标识符和关键字的区别？

标识符就是一个名字，比如类，变量，方法的名字，这些就是标识符，但是有一些标识符，Java语言已经赋予了他们特殊的意义，而且只能用在特定的地方，这些特殊的标识符就是关键字，简单来说，关键字就是有特殊含义的标识符。

Java中的关键字有哪些？

访问控制：private，protected，public

类，方法，变量修饰符：abstract，class，extend，final，implement，new等

程序控制类：break，continue，return，do，while，for，switch，case等

错误处理：try，catch，throw，finally等

包相关：import，package

基本类型：boolean，byte，char，double，float，short。

变量引用：super，this，void。

保留字：goto，const。

自增自减运算符

++和--是Java提供的自增自减运算符，既可以放在变量之前，也可以放在变量之后。

前缀形式：++a或--a先自增/自减变量的值，然后再使用该变量，例如：b=++a先将a增加1，然后把增加后的值赋值b

后缀形式：a++或a--先使用变量的当前值，然后再自增或自减变量的值，例如，b=a++先将a的值赋值给b，然后再将a增加1

口诀：符号在前就先加减，符号在后就后加减

移位运算符

移位操作中，被操作的数据被视为二进制数，移位就是将其向左或向右移动若干位的运算。

Java中有三种移位运算符：

左移运算符（<<）
- 作用：将操作数的所有位向左移动指定的位数。
- 格式：value << num
- 示例：int a = 8; // 二进制表示为 1000 int b = a << 2; // 结果为 32，二进制表示为 100000
右移运算符（>>）
- 作用：将操作数的所有位向右移动指定的位数。对于正数，左侧空出的位用0填充；对于负数，左侧空出的位用1填充（保持符号位不变）。
- 格式：value >> num
- 示例：int a = 8; // 二进制表示为 1000 int b = a >> 2; // 结果为 2，二进制表示为 10
无符号右移运算符（>>>）
- 作用：将操作数的所有位向右移动指定的位数。左侧空出的位总是用0填充，不考虑符号位。
- 格式：value >>> num
- 示例：int a = -8; // 二进制表示为 11111111111111111111111111111000 int b = a >>> 2; // 结果为 1073741822，二进制表示为 00111111111111111111111111111110

使用移位运算符的主要原因：

高效：移位运算符直接对应于处理器的移位指令。

节省内存：通过移位操作，可以使用一个整数（如int或long）来存储多个布尔值或标志位，从而节省内存。

需要注意的是移位运算符不会改变原来的数值，而是返回一个新的值。

continue，break和return的区别？

当我们在循环之中，达到某种条件需要提前结束循环时，就需要用到以下三个：

continue：跳出当前这一次循环，继续执行下一次循环。

break：跳出整个循环体，继续执行下面的语句。

return一般有两种用法：

1.直接使用return结束方法执行，用于没有返回值函数的方法

2.return一个特定值，即方法的返回值，用于有返回值函数的方法

Java中的基本数据类型

Java'中有八种基本数据类型：

6种数字类型：整数型：byte，int，short，long 浮点型：float，double

1种字符类型：char

1种布尔型：boolean

可以从图中看到byte、short、int、long能表示的最大正数都减 1 了，因为在二进制补码的表示法中，最高位是用来表示符号的（0表示正数，1表示负数），其余位表示数值部分，所以如果我们要表示最大的正数，那么只需要把除了最高魏之外的所有位都设为1，如果再加上1，就会导致溢出，变成一个负数。

注意：

Java 里使用 long 类型的数据一定要在数值后面加上 L，否则将作为整型解析。
Java 里使用 float 类型的数据一定要在数值后面加上 f 或 F，否则将无法通过编译。
char a = 'h'char :单引号，String a = "hello" :双引号。

这八种基本类型都有对应的包装类分别为：Byte、Short、Integer、Long、Float、Double、Character、Boolean 。

基本数据类型和包装类型的区别？

用途：在定义常量和局部变量时，会使用基本数据类型，在其他地方比如方法参数，对象属性中很少会使用基本类型来定义变量。并且，包装类型可用于泛型，而基本类型不可以。

存储方式：基本数据类型的局部变量存放在Java虚拟机栈中的局部变量表中，基本数据类型的成员变量（未被static修饰）存放在Java虚拟机的堆中。包装类型属于对象类型，几乎所有的对象实例都存在于堆中。

占用空间：相比于包装类型（对象类型），基本数据类型占用的空间往往非常小。

默认值：成员变量包装类型不赋值就是null，而基本类型有默认值且不是null。

比较方式：对于基本数据类型来说，==比较的是值。对于包装数据类型来说，==比较的是对象的内存地址。所有整型包装类对象之间值的比较，全部使用equals()方法。

并不是所有的基本数据类都存放在栈中：基本数据类型的存储位置取决他们的作用域和声明方式。如果是局部变量，会存放在栈中，如果是成员变量，会存储在堆/方法区/元空间中

public class Test {// 成员变量，存放在堆中int a = 10;// 被 static 修饰的成员变量，JDK 1.7 及之前位于方法区，1.8 后存放于元空间，均不存放于堆中。// 变量属于类，不属于对象。static int b = 20;
public void method() {// 局部变量，存放在栈中int c = 30;static int d = 40; // 编译错误，不能在方法中使用 static 修饰局部变量}
}

包装类型的缓存机制

Java基本数据类型的包装类型的大部分都用到了缓存机制来提升性能。

Byte，Short，Integer，Long这四种包装类默认创建了数值[-128，127]的相应类型的缓存数据，Character创建了数值在[0,127]范围的缓存数据，Boolean直接返回True和False。浮点数的包装类型并没有实现缓存机制。

public class IntegerCacheExample {public static void main(String[] args) {Integer a = 100;Integer b = 100;
Integer c = 200;Integer d = 200;
// 输出true，因为a和b引用的是缓存中的同一个对象System.out.println(a == b);
// 输出false，因为c和d超出了缓存范围，所以它们是不同的对象System.out.println(c == d);}
}

在这个例子中，当我们执行Integer a = 100;和Integer b = 100;时，由于100在默认的缓存范围内（-128到127），所以a和b引用的是同一个Integer对象。因此，当我们使用==比较a和b时，结果是true。

然而，当我们执行Integer c = 200;和Integer d = 200;时，由于200超出了默认的缓存范围，所以c和d引用的是两个不同的Integer对象。因此，当我们使用==比较c和d时，结果是false。

Integer i1 = 40;
Integer i2 = new Integer(40);
//输出false
System.out.println(i1==i2);

Integer i1=40 这一行代码会发生装箱，也就是说这行代码等价于 Integer i1=Integer.valueOf(40) 。因此，i1 直接使用的是缓存中的对象。而Integer i2 = new Integer(40) 会直接创建新的对象。

所有整型包装类对象之间值的比较，全部使用equals比较：因为==比较的是引用的地址，而并非是一个值，如果对象是在缓存范围内产生，那么比较就相同，例如Integer类型在[-127,128]内，就可以在==比较，但是如果在范围之外的所有数据，都会在堆中产生，我们也并不知道是否有缓存存在，所以推荐使用equals比较。

自动装箱与拆箱及其原理

装箱：将基本类型用他们对应的引用类型包装起来。

拆箱：将包装类型转换为基本数据类型。

Integer i = 10;  //装箱
int n = i;   //拆箱

上面这两行代码对应的字节码文件为：

   L1
LINENUMBER 8 L1
ALOAD 0
BIPUSH 10
INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
PUTFIELD AutoBoxTest.i : Ljava/lang/Integer;
L2
LINENUMBER 9 L2
ALOAD 0
ALOAD 0
GETFIELD AutoBoxTest.i : Ljava/lang/Integer;
INVOKEVIRTUAL java/lang/Integer.intValue ()I
PUTFIELD AutoBoxTest.n : I
RETURN

从字节码中我们发现装箱其实就是调用了包装类的valueOf()方法，拆箱其实就是调用了 xxxValue()方法。

因此，

Integer i = 10 等价于 Integer i = Integer.valueOf(10)
int n = i 等价于 int n = i.intValue();

如果频繁拆装箱的话，也会严重影响性能，应该避免不变要拆装箱操作。

为什么浮点数运算的时候会有精度丢失的风险？

精度丢失示例：

float a = 2.0f - 1.9f;
float b = 1.8f - 1.7f;
System.out.println(a);// 0.100000024
System.out.println(b);// 0.099999905
System.out.println(a == b);// false

计算机是二进制的，而且计算机在表示一个数字的时候宽度是有限的，无限循环的小数存储在计算机时，只能被截断，所以就会导致小数精度发生损失的情况，所以就会导致小数精度损失的情况，这就解释了为什么浮点数没有办法用二进制精确表示。

// 0.2 转换为二进制数的过程为，不断乘以 2，直到不存在小数为止，
// 在这个计算过程中，得到的整数部分从上到下排列就是二进制的结果。
0.2 * 2 = 0.4 -> 0
0.4 * 2 = 0.8 -> 0
0.8 * 2 = 1.6 -> 1
0.6 * 2 = 1.2 -> 1
0.2 * 2 = 0.4 -> 0（发生循环）
...

深度了解：计算机系统基础（四）浮点数

如何解决浮点数运算精度丢失问题？

BigDecimal可以实现对浮点数的精确运算，不会造成精度丢失问题，通常情况下大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过BigDecimal来做的

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("1.00");
BigDecimal c = new BigDecimal("0.8");

BigDecimal x = a.subtract(c);
BigDecimal y = b.subtract(c);

System.out.println(x); /* 0.2 */
System.out.println(y); /* 0.20 */
// 比较内容，不是比较值
System.out.println(Objects.equals(x, y)); /* false */
// 比较值相等用相等compareTo，相等返回0
System.out.println(0 == x.compareTo(y)); /* true */

超过long整型的数据应该如何表示？

可以使用BigInteger，它可以表示任意精度的整数，BigInteger 支持所有基本的数学运算，并且可以处理比 long 类型更大范围的整数。

变量

成员变量与局部变量的区别？

语法形式：成员变量是属于类的，而局部变量是在代码块或方法中定义的变量或是方法的参数，成员变量可以被public，private，static等修饰符修饰，而局部变量不能被权限修饰符及static所修饰，但是成员变量和局部变量都可以被final所修饰，一经修饰就成为了常量。

存储方式：从变量在内存中的存储方式看，如果成员变量是使用static修饰的，那么这个成员变量是属于类的，在方法区中存储，若没有static修饰，这个成员变量属于对象，存在于堆内存中，局部变量则存在于栈内存。

生存时间：从变量在内存中的生存时间看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动生成，随着方法的调用结束而消亡。

默认值：从变量是否有默认值来看，成员变量如果没有被赋初始值，则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

为什么成员变量有默认值？为什么局部变量没有？

成员变量：成员变量属于类的实例，它们在对象创建时分配内存，并在对象的生命周期内持续存在。因此，成员变量可以有一个默认值，这个值在对象创建时自动赋给成员变量，确保了对象状态的完整性。
局部变量：局部变量仅在方法调用或代码块执行时存在，它们的生命周期是短暂的。局部变量的作用域限定在声明它们的代码块内，一旦代码块执行完毕，局部变量就会被销毁。由于局部变量的生命周期如此短暂，自动赋值可能会导致不必要的赋值操作，影响性能，并且可能导致程序员忽略变量的实际用途。

public class VariableExample {// 成员变量private String name;private int age;// 方法中的局部变量public void method() {int num1 = 10; // 栈中分配的局部变量String str = "Hello, world!"; // 栈中分配的局部变量System.out.println(num1);System.out.println(str);}// 带参数的方法中的局部变量public void method2(int num2) {int sum = num2 + 10; // 栈中分配的局部变量System.out.println(sum);}// 构造方法中的局部变量public VariableExample(String name, int age) {this.name = name; // 对成员变量进行赋值this.age = age; // 对成员变量进行赋值int num3 = 20; // 栈中分配的局部变量String str2 = "Hello, " + this.name + "!"; // 栈中分配的局部变量System.out.println(num3);System.out.println(str2);}
}

静态变量有什么作用？

静态变量也就是被 static 关键字修饰的变量。它可以被类的所有实例（对象）共享，无论一个类创建了多少个对象，它们都共享同一份静态变量。也就是说，静态变量只会被分配一次内存，即使创建多个对象，这样可以节省内存。静态变量可以直接通过类名访问，如果被private修饰就不行了。

通常情况下，静态变量会被 final 关键字修饰成为常量。

public class ConstantVariableExample {// 常量public static final int constantVar = 0;
}

字符型常量和字符串常量的区别？

形式 : 字符常量是单引号引起的一个字符，字符串常量是双引号引起的 0 个或若干个字符。
含义 : 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)。
占内存大小：字符常量只占 2 个字节; 字符串常量占若干个字节。

⚠️ 注意 char 在 Java 中占两个字节。

public class StringExample {// 字符型常量public static final char LETTER_A = 'A';// 字符串常量public static final String GREETING_MESSAGE = "Hello, world!";public static void main(String[] args) {System.out.println("字符型常量占用的字节数为："+Character.BYTES);System.out.println("字符串常量占用的字节数为："+GREETING_MESSAGE.getBytes().length);}
}

方法

什么是方法的返回值？方法有哪几种类型？

方法的返回值是指我们获取到的某个方法体中的代码执行后产生的结果！前提是该方法可以产生结果，返回值的作用是接收结果，使得它可以用于其他操作！

静态方法为什么不能调用非静态成员？

结合JVM的知识，主要原因如下：

静态方法是属于类的，在类加载的时候分配内存，可以通过类名直接访问。而非静态成员属于实例对象，只有在对象实例化之后才存在，需要通过类的实例对象去访问。
在类的非静态成员不存在的时候静态方法就已经存在了，此时调用在内存中还不存在的非静态成员属于非法操作。

静态方法和实例方法有何不同？

调用方式：静态方法，也就是经static修饰的方法，可以通过 对象.方法名和 类名.方法名去调用，调用静态方法可以无需创建对象。但是实例方法必须通过 对象.方法名这种方法去调用。
静态方法在访问本类的时候，只能访问静态成员（静态方法和静态成员变量），不允许访问实例成员（实例成员变量和实例方法），而实例方法不存在这个限制。

重载和重写的区别？

重载：同样的一个方法能够根据输入数据的不同，做出不同的处理。重载可发生在同一个类中，或父子类之间，但方法名必须相同，参数类型，个数，顺序均不同，方法返回值和访问修饰符可以不同。

//无参构造方法
StringBuilder sb = new StringBuilder();
//有参构造方法
StringBuilder sb2 = new StringBuilder("HelloWorld");
//上述构造方法的方法名相同，但是一个无参一个有参 就发生了方法的重载

所以综上所述，重载就是一个类中多个同名方法根据不同的传参来执行不同的逻辑处理。

重写：重写发生在运行期，是子类对父类的非private方法的实现过程进行重新编写，会有@override注解

方法名，参数列表必须相同，子类方法返回值类型应比父类方法返回值类型更小或相等，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。
如果父类方法访问修饰符为 private/final/static 则子类就不能重写该方法，但是被 static 修饰的方法能够被再次声明。
构造方法无法被重写

所以综上所述，重写就是子类对父类方法的重新改造，外部样子不能改变，内部逻辑可以改变。

需要注意的是：如果方法的返回类型是 void 和基本数据类型，则返回值重写时不可修改。但是如果方法的返回值是引用类型，重写时是可以返回该引用类型的子类的。

什么是可变长参数？

所谓可变长参数就是允许在调用方法时传入不定长度的参数。就比如下面这个方法就可以接受 0 个或者多个参数。

public static void method1(String... args) {//......
}

另外，可变参数只能作为函数的最后一个参数，但其前面可以有也可以没有任何其他参数。

public static void method2(String arg1, String... args) {//......
}

遇到方法重载，会优先匹配固定参数的方法，因为固定参数的方法匹配度更高。

public class VariableLengthArgument {public static void printVariable(String... args) {for (String s : args) {System.out.println(s);}}public static void printVariable(String arg1, String arg2) {System.out.println(arg1 + arg2);}public static void main(String[] args) {printVariable("a", "b");printVariable("a", "b", "c", "d");}
}

输出：

ab
a
b
c
d

另外，Java 的可变参数编译后实际会被转换成一个数组，我们看编译后生成的 class文件就可以看出来了。

public class VariableLengthArgument {public static void printVariable(String... args) {String[] var1 = args;int var2 = args.length;for(int var3 = 0; var3 < var2; ++var3) {String s = var1[var3];System.out.println(s);}}// ......
}

（详情请参考：Java集合使用注意事项总结 | JavaGuide）