Java基础语法全面解析
目录
一、数据类型
1.1. 基本数据类型
存储实际值：直接存储数据的二进制值。
固定大小：每种类型占用的内存大小由 Java 语言规范明确定义。
性能高效：操作速度快，内存占用小。
| 基本数据类型 | 数据长度 | 最大数据存储量 | 数值范围 | 默认值 | |
| 整型 | byte | 8位（1字节） | 255 | -128 ~ 127 | 0 |
| short | 16（2字节） | 65536 | -32768 ~ 32767 | 0 | |
| int | 32（4字节） | | 0 | ||
| long | 64（8字节） | 0 | |||
| 浮点型 | float | 32（4字节） | 3.4e-45 ~ 1.4e38 | 0.0f | |
| double | 64（8字节） | 4.9e-324 ~ 18e308 | 0.0d | ||
| 布尔型 | boolean | 只有 ture 和 false 两个取值 | false | ||
| 字符型 | char | 16位（2字节） | 存储Unicode码，用单引号赋值 | '\u0000' | |
-
基本类型没有面向对象的特性（如方法调用），但可以通过包装类（如
Integer、Double）转换为对象。 -
默认值仅适用于类的成员变量，局部变量必须显式初始化后才能使用。
1.2. 引用类型
存储引用（地址）：变量存储的是对象在堆内存中的地址，而非实际数据。
动态内存分配：可动态创建和销毁对象。通过
new关键字在堆内存中创建对象，对象实例存储在堆内存中，由 JVM 自动管理（垃圾回收）。支持面向对象：可以调用对象的方法和访问字段，支持继承、多态、封装等特性（如类、接口）。
默认值为
null：未初始化的引用变量值为null，访问会抛出NullPointerException。
| 类型 | 定义方式 | 特点 |
| 类（Class） |
| 实例化对象，支持继承、多态等特性。 |
| 接口（Interface） |
| 不能被直接实例化，需通过实现类创建对象，支持多实现。 |
| 数组（Array） |
| 存储固定大小的同类型元素，本质是对象。 |
| 枚举（Enum） |
| 表示一组固定常量，全局唯一，可定义方法和字段。 |
| 注解（Annotation） |
| 为代码添加元数据（如配置、检查），通过反射读取。 |
| 记录类（Record） |
| 简化不可变数据类的定义，自动生成常用方法。 |
| 类型 | 说明 |
| Lambda 表达式 | 实现函数式接口的匿名方法，本质是接口的实例。 |
| 方法引用 | 简化 Lambda 表达式的语法，指向已有方法。 |
null 引用 | 所有引用类型的默认值，表示未指向任何对象。 |
// 1. 类
class Student {
String name;
int age;
}
Student stu = new Student();
// 2. 接口
interface Flyable {
void fly();
}
Flyable bird = new Flyable() {
public void fly() {
System.out.println("Bird flying");
}
};
// 3. 数组
int[] scores = {90, 85, 95};
// 4. 枚举
enum Weekday { MONDAY, TUESDAY }
Weekday day = Weekday.MONDAY;
// 5. 注解
@Deprecated
class OldClass { }
// 6. 记录类（Java 16+）
record User(String name, int id) { }
User user = new User("Alice", 1001);
// 7. Lambda 表达式（函数式接口）
Runnable task = () -> System.out.println("Task running");
// 8. 方法引用
Consumer<String> printer = System.out::println;1.3. 区别
| 特性 | 基本数据类型 | 引用类型 |
| 存储内容 | 直接存储二进制值 | 内存地址（指向对象） |
| 内存分配位置 | 栈内存 | 堆内存（对象） + 栈内存（引用变量） |
| 默认值 | 有默认值 | 默认 null |
| 操作方式 | 直接操作数值 | 通过引用调用方法或访问字段 |
| 性能 | 高效（内存小，操作快） | 相对较低（涉及堆内存和对象管理） |
| 是否可调用方法 | 否 | 是 |
在 Java 中区分基本数据类型和引用类型是为了在性能效率、内存管理和面向对象特性之间取得平衡。
-
基本数据类型直接存储值，操作时直接在栈内存中进行，且内存占用更小。引用类型存储需要通过对象引用访问堆内存中的数据，涉及额外的内存寻址，性能相对较低，并且需要额外存储对象头、字段对齐等信息，内存开销大。
-
基本类型的值直接存储在栈内存中，生命周期与方法调用绑定，自动销毁，分配和回收效率高，适合频繁操作的简单数据。引用类型的对象存储在堆内存中，由垃圾回收器管理，生命周期不可控。堆内存支持动态内存分配。适合存储大型或复杂对象。
-
基本类型没有方法、无法继承、不支持多态。引用类型支持继承、多态等特性，可以实现复杂业务逻辑和抽象建模。
二、运算符
2.1. 算数运算符
| 运算符 | 说明 |
| + | 加 |
| - | 减 |
| * | 乘 |
| / | 除 |
| % | 取模（取余） |
| ++ | 自增 |
| -- | 自减 |
-
用于基本数学计算，适用于数值类型（
int、double等） -
++a（前置自增）先加后用，a++（后置自增）先用后加。 -
字符串拼接也使用
+（如"Hello" + "World"）。
2.2. 关系运算符
| 运算符 | 说明 |
| == | 等于 |
| != | 不等于 |
| > | 大于 |
| < | 小于 |
| >= | 大于等于 |
| <= | 小于等于 |
2.3. 布尔逻辑运算符
| 运算符 | 说明 |
| && | 与（AND） |
| || | 或（OR） |
| ! | 非（NOT） |
| & | 简化非 |
| | | 简化或 |
| ^ | 异或（XOR） |
-
短路运算符
&&和||若左侧已能确定结果，右侧不再执行。 -
非短路运算符
&和|会执行所有操作。
2.4. 位逻辑运算符
| 运算符 | 说明 |
| ~ | 按位取反 |
| & | 按位与 |
| | | 按位或 |
| ^ | 按位异或 |
| >> | 右移 |
| >>> | 右移并用0填充 |
| << | 左移 |
-
直接操作二进制位，适用于整数类型（
int、long等）。
2.5. 条件运算符
// 条件运算符示例
int max = (a > b) ? a : b;2.6. 赋值运算符
| 运算符 | 说明 |
| = | 赋值 |
| += | 加后赋值 |
| -= | 减后赋值 |
| *= | 乘后赋值 |
| /= | 除后赋值 |
| %= | 取模后赋值 |
| &= | 位与后赋值 |
| |= | 位或后赋值 |
| ^= | 位异或后赋值 |
2.7. 其他运算符
// 1. () ：改变运算的优先级或调用方法
int result = (5 + 3) * 2; // 16
// 2. instanceof ：检查对象是否为某个类的实例
String s = "Hello";
boolean isString = s instanceof String; // true
// 3. 成员访问符. ：访问对象的属性或方法
String s = "Java";
int length = s.length(); // 4
// 4. new ：创建对象实例
Object obj = new Object();2.8. 运算符的优先级
运算符按优先级从高到低执行（部分常见优先级）：
-
()、[]、. -
!、~、++、--（单目运算符） -
*、/、% -
+、- -
<<、>>、>>> -
<、<=、>、>= -
==、!= -
&、^、| -
&&、|| -
?: -
=、+=、-=等赋值运算符
三、类型转换
3.1. 基本数据类型的类型转换
自动类型转换（隐式转换）：当小范围类型的值赋给大范围类型的变量时，Java 会自动完成转换，无需显式操作。
支持的类型范围顺序：
byte → short → int → long → float → double
char → int → long → float → double
强制类型转换（显式转换）：当大范围类型的值赋给小范围类型的变量时，需要显式强制转换，可能丢失精度。
强制转换可能导致数据丢失（如浮点数转整数）或溢出（如大整数转小范围整数）。
编译时不会报错，但需开发者自行确保转换逻辑正确。
// 隐式转换示例
int a = 10;
long b = a; // int → long（自动转换）
float c = 3.14f;
double d = c; // float → double（自动转换）
char ch = 'A';
int code = ch; // char → int（自动转换，'A' 的 ASCII 码为 65）
// 显式转换示例
double x = 3.14;
int y = (int) x; // double → int（强制转换，结果为 3，丢失小数部分）
long num = 1000L;
short s = (short) num; // long → short（若 num 超出 short 范围，结果会溢出）
3.2. 引用数据类型的类型转换
向上转型：将子类对象赋给父类引用，自动完成，安全且无需强制转换。
父类引用只能访问父类中定义的属性和方法。
若子类重写了父类方法，实际调用的是子类的方法（多态）
向下转型：将父类引用转回子类引用，需显式强制转换，存在风险。
前提：父类引用实际指向的是目标子类对象，否则会抛出ClassCastException。
// 示例
class Animal {
void eat() { System.out.println("Animal eats"); }
}
class Dog extends Animal {
void bark() { System.out.println("Dog barks"); }
}
// 向上转型示例
Animal animal = new Dog(); // 向上转型（Dog → Animal）
animal.eat(); // 输出 "Animal eats"
// animal.bark(); 编译错误：Animal 类没有 bark() 方法
// 向下转型示例
Animal animal = new Dog(); // 向上转型
Dog dog = (Dog) animal; // 向下转型（Animal → Dog）
dog.bark(); // 输出 "Dog barks"
// 错误示例
Animal wrongAnimal = new Animal();
// Dog wrongDog = (Dog) wrongAnimal; 运行时抛出 ClassCastException
// 可用instanceof避免异常
if (animal instanceof Dog) {
Dog dog = (Dog) animal; // 安全转换
}3.3. 基本类型和包装类的转换
自动装箱：基本类型自动转换为对应的包装类对象（Java 5+ 支持）。
自动拆箱：包装类对象自动转换为对应的基本类型。
// 自动装箱示例
Integer num = 10; // 自动装箱：int → Integer（等价于 Integer.valueOf(10)）
Double d = 3.14; // 自动装箱：double → Double
// 自动拆箱示例
Integer numObj = 100;
int num = numObj; // 自动拆箱：Integer → int（等价于 numObj.intValue()）-
自动装箱和拆箱由编译器在编译阶段完成。
-
频繁装箱/拆箱可能影响性能（如循环中大量使用包装类）。
-
null拆箱会抛出NullPointerException
3.4. 字符串与其他类型的转换
// 1. 基本类型 → 字符串
// 方法1：String.valueOf()
String s1 = String.valueOf(100); // "100"
String s2 = String.valueOf(3.14); // "3.14"
// 方法2：拼接空字符串
String s3 = 100 + ""; // "100"
// 2. 字符串 → 基本类型
// 方法：使用包装类的 parseXxx() 方法（字符串内容必须符合目标类型的格式）
int num = Integer.parseInt("123"); // 123
double d = Double.parseDouble("3.14"); // 3.14
boolean flag = Boolean.parseBoolean("true"); // true
// 3. 对象 → 字符串
// 方法1：toString()
Integer num = 100;
String s = num.toString(); // "100"
// 方法2：格式化输出
String s = String.format("%d", 100); // "100"
四、常量和变量
4.1. 常量
使用
final关键字声明，且必须初始化。命名规范：全大写字母，单词间用下划线分隔（如
MAX_SIZE）
public class ConstantsDemo {
// 静态常量（类）
public static final double PI = 3.14159;
// 实例常量（对象）
private final String DEFAULT_NAME = "Unknown";
public void printInfo() {
// 局部常量（方法内）
final int MAX_ATTEMPTS = 3;
System.out.println(DEFAULT_NAME + " attempts: " + MAX_ATTEMPTS);
}
}4.2. 变量
public class VariableDemo {
// 静态常量
public static final String APP_NAME = "MyApp";
// 实例变量
private int instanceVar = 3;
// 静态变量
private static int staticVar = 33;
public void method() {
// 局部变量
int localVar = 333;
System.out.println(localVar);
// 局部常量
final int LOCAL_CONST = 3333;
System.out.println(LOCAL_CONST);
}
public static void main(String[] args) {
VariableDemo demo = new VariableDemo();
demo.method();
System.out.println(APP_NAME);
System.out.println(demo.instanceVar);
System.out.println(staticVar);
}
}五、条件语句
5.1. if 语句
// 语法
if(条件){
// 条件为 ture 时执行
}
// 示例
int score = 80;
if (score >= 60) {
System.out.println("及格");
}5.2. if - else 语句
// 语法
if (条件) {
// 条件为 true 时执行
} else {
// 条件为 false 时执行
}
// 示例
int age = 18;
if (age >= 18) {
System.out.println("成年人");
} else {
System.out.println("未成年人");
}5.3. if - else if - else 语句
// 语法
if (条件1) {
// 条件1为 true 时执行
} else if (条件2) {
// 条件2为 true 时执行
} else {
// 所有条件均为 false 时执行
}
// 示例
int score = 85;
if (score >= 90) {
System.out.println("优秀");
} else if (score >= 80) {
System.out.println("良好");
} else {
System.out.println("需努力");
}5.4. switch 语句
// 语法
switch (表达式) {
case 值1:
// 匹配值1时执行
break;
case 值2:
// 匹配值2时执行
break;
default:
// 无匹配时执行
}
// 示例
int day = 3;
switch (day) {
case 1:
System.out.println("周一");
break;
case 2:
System.out.println("周二");
break;
default:
System.out.println("其他日期");
}
// Java 12+ 支持箭头语法（->）和 yield 返回值
int day = 3;
switch (day) {
case 1 -> System.out.println("周一");
case 2 -> System.out.println("周二");
default -> System.out.println("其他日期");
}-
case值必须是常量，且类型与switch表达式兼容。 -
如果不写
break，会继续执行后续case的代码。
六、循环语句
6.1. for 循环
// 语法
for (初始化; 循环条件; 迭代操作) {
// 循环体
}
// 示例
for (int i = 0; i < 6; i++) {
System.out.println(i); // 输出 0~5
}6.2. while 循环
// 语法
while (循环条件) {
// 循环体
}
// 示例
int i = 0;
while (i < 6) {
System.out.println(i); // 输出 0~5
i++;
}6.3. do…while 循环
// 语法
do {
// 循环体（至少执行一次）
} while (循环条件);
// 示例
int i = 0;
do {
System.out.println(i); // 输出 0~5
i++;
} while (i < 6);6.4. 增强型for循环（foreach）
// 语法
for (元素类型 变量名 : 集合或数组) {
// 遍历元素
}
// 示例
int[] nums = {0, 1, 2, 3, 4, 5};
for (int num : nums) {
System.out.println(num); // 输出 0, 1, 2, 3, 4, 5
}七、跳转语句
7.1. break语句
作用：立即退出当前循环或
switch语句。
// 示例
for (int i = 0; i < 10; i++) {
if (i == 6) {
break; // 当 i=6 时退出循环
}
System.out.println(i); // 输出 0~5
}7.2. continue语句
作用：跳过当前循环的剩余代码，进入下一次循环。
// 示例
for (int i = 0; i < 6; i++) {
if (i == 3) {
continue; // 跳过 i=3 的循环
}
System.out.println(i); // 输出 0,1,2,4,5
}7.3. return语句
作用：结束当前方法的执行，并可返回一个值。
// 示例
public int add(int a, int b) {
return a + b; // 返回结果并退出方法
}7.4. 带标签的break和continue
作用：用于跳出多层循环。
// 示例
outerLoop:
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i == 1 && j == 1) {
break outerLoop; // 直接退出外层循环
}
System.out.println(i + "," + j);
}
}
// 输出：0,0; 0,1; 0,2; 1,0
扫一扫
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
