跳到主要内容

Java 基础语法完全指南

概述​

Java 是一种面向对象的编程语言，具有简单、健壮、安全、可移植、高性能、多线程等特点。本文档将详细介绍 Java 的基础语法，从入门到进阶的各个知识点。

Java 程序的基本结构​

一个完整的 Java 程序由以下几部分组成：

  1. 类（Class）：Java 程序的基本单位
  2. 方法（Method）：类中的行为单元
  3. 变量（Variable）：存储数据的容器
  4. 语句（Statement）：程序执行的指令
public class HelloWorld {
    // 主方法 - 程序入口
    public static void main(String[] args) {
        // 输出语句
        System.out.println("Hello, World!");
    }
}

面向对象基本概念​

  • 对象：类的一个实例，有状态和行为
  • 类：定义对象属性和行为的模板
  • 方法：定义类的行为
  • 实例变量：每个对象独有的状态

1. Java 关键字​

Java 语言中有 51 个保留关键字，其中包含两个保留字 goto 和 const。

访问控制关键字​

关键字说明
public公共访问，所有类可见
protected受保护访问，同包或子类可见
private私有访问，仅本类可见

类、方法和变量修饰符​

关键字说明
abstract抽象类或抽象方法
class类定义
extends继承
final最终类/方法/变量
implements实现接口
interface接口定义
native本地方法
new创建对象
static静态成员
strictfp严格浮点模式
synchronized同步方法
transient瞬时变量
volatile易失变量
enum枚举类型

程序控制关键字​

关键字说明
break跳出循环
continue跳过本次循环
return返回
dodo-while 循环
whilewhile 循环
if条件判断
else条件判断的否定分支
forfor 循环
instanceof类型检查
switch多分支选择
caseswitch 分支
default默认分支
assert断言

错误处理关键字​

关键字说明
try异常捕获块
catch异常处理块
throw抛出异常
throws声明抛出异常
finally最终执行块

包相关关键字​

关键字说明
import导入包
package包声明

基本类型关键字​

关键字说明
boolean布尔类型
byte字节类型
char字符类型
double双精度浮点
float单精度浮点
int整数类型
long长整数类型
short短整数类型

变量引用关键字​

关键字说明
super父类引用
this当前对象引用
void无返回值

保留字​

关键字说明
goto保留未使用
const保留未使用

注意：虽然 true, false, 和 null 看起来像关键字，但它们是字面值，不能作为标识符使用。

2. 基本数据类型​

Java 中有 8 种基本数据类型，它们是 Java 语言的基础。

数据类型分类​

  1. 6 种数字类型：
    • 4 种整数型：byte、short、int、long
    • 2 种浮点型：float、double
  2. 1 种字符类型：char
  3. 1 种布尔型：boolean

基本数据类型详细表​

类型位数字节默认值取值范围说明
byte810-128 ~ 127字节类型
short1620-32768 ~ 32767短整型
int3240-2147483648 ~ 2147483647整型（默认）
long6480L-9223372036854775808 ~ 9223372036854775807长整型
char162'\u0000'0 ~ 65535Unicode 字符
float3240f1.4E-45 ~ 3.4028235E38单精度浮点
double6480d4.9E-324 ~ 1.7976931348623157E308双精度浮点（默认）
boolean1-falsetrue、false布尔型

重要说明​

  1. 类型一致性：Java 的每种基本类型所占存储空间的大小不随机器硬件架构的变化而变化，这是 Java 程序具有良好可移植性的原因之一。

  2. 数值表示：

    • long 类型数值必须加 L 或 l 后缀
    • float 类型数值必须加 F 或 f 后缀
    • double 类型数值可以加 D 或 d 后缀（可选）

  3. 字符表示：

    • 字符使用单引号：char a = 'A'
    • 字符串使用双引号：String s = "Hello"

  4. 布尔类型：boolean 类型只有 true 和 false 两个值。

变量声明和初始化​

// 基本数据类型声明和初始化
byte b = 127;
short s = 32767;
int i = 1000000;
long l = 123456789012345L;  // 必须加L
float f = 3.14f;            // 必须加f
double d = 3.1415926535;    // 可选加d
char c = 'A';
boolean flag = true;

// 整数的不同进制表示
int binary = 0b1010;        // 二进制
int octal = 012;            // 八进制
int hex = 0xA;              // 十六进制

3. 包装类型​

Java 为每种基本类型都提供了对应的包装类，使得基本类型可以像对象一样使用。

包装类对应关系​

基本类型包装类
byteByte
shortShort
intInteger
longLong
charCharacter
floatFloat
doubleDouble
booleanBoolean

包装类型特点​

  1. 默认值：包装类型默认为 null，基本类型有各自的默认值
  2. 自动拆装箱：
    • 装箱：基本类型 → 包装类型
    • 拆箱：包装类型 → 基本类型
// 自动装箱
Integer num = 100;  // 自动将int转换为Integer

// 自动拆箱
int value = num;    // 自动将Integer转换为int

// 手动装箱
Integer obj1 = Integer.valueOf(100);

// 手动拆箱
int primitive = obj1.intValue();

缓存机制​

  • Byte、Short、Integer、Long：缓存数值范围 [-128, 127]
  • Character：缓存数值范围 [0, 127]
  • Boolean：直接返回 TRUE 或 FALSE 实例
  • Float、Double：没有实现缓存机制
Integer a1 = 100;
Integer a2 = 100;
System.out.println(a1 == a2);  // true（缓存范围内）

Integer b1 = 128;
Integer b2 = 128;
System.out.println(b1 == b2);  // false（缓存范围外）

常用包装类方法​

// 字符串转数值
int num1 = Integer.parseInt("123");
double num2 = Double.parseDouble("3.14");

// 数值转字符串
String str1 = Integer.toString(100);
String str2 = String.valueOf(100);

// 其他常用方法
Integer max = Integer.MAX_VALUE;  // 最大值
Integer min = Integer.MIN_VALUE;  // 最小值
boolean isDigit = Character.isDigit('5');  // 是否为数字

4. 运算符​

Java 提供了丰富的运算符，用于操作变量和执行计算。

4.1 算术运算符​

运算符描述示例
+加法10 + 20 = 30
-减法20 - 10 = 10
*乘法10 * 20 = 200
/除法20 / 10 = 2
%取余20 % 3 = 2
++自增int i = 5; i++; // i = 6
--自减int i = 5; i--; // i = 4

自增自减运算符注意点：

  • 前缀形式：++i 先自增再使用
  • 后缀形式：i++ 先使用再自增
int a = 5;
int b = ++a;  // a先变为6，再赋值给b，结果：a=6, b=6

int x = 5;
int y = x++;  // x先赋值给y，再自增，结果：x=6, y=5

4.2 关系运算符​

运算符描述示例
==等于5 == 5 // true
!=不等于5 != 3 // true
>大于5 > 3 // true
<小于3 < 5 // true
>=大于等于5 >= 5 // true
<=小于等于3 <= 5 // true

4.3 逻辑运算符​

运算符描述示例
&&逻辑与（短路）true && false // false
``
!逻辑非!true // false
&逻辑与（非短路）true & false // false
``逻辑或（非短路）
^逻辑异或true ^ false // true

短路与非短路区别：

  • && 和 || 具有短路特性
  • & 和 | 不具有短路特性
int a = 0;
if (a > 0 && a++ > 0) {  // 不会执行a++，因为a > 0为false
    System.out.println("不会执行");
}
System.out.println(a);  // 输出：0

int b = 0;
if (b > 0 & b++ > 0) {  // 会执行b++，即使b > 0为false
    System.out.println("不会执行");
}
System.out.println(b);  // 输出：1

4.4 位运算符​

运算符描述示例
&按位与5 & 3 // 1
``按位或
^按位异或5 ^ 3 // 6
~按位取反~5 // -6
<<左移5 << 1 // 10
>>右移5 >> 1 // 2
>>>无符号右移5 >>> 1 // 2

4.5 赋值运算符​

运算符描述示例
=赋值int a = 5;
+=加法赋值a += 5; // a = a + 5
-=减法赋值a -= 5; // a = a - 5
*=乘法赋值a *= 5; // a = a * 5
/=除法赋值a /= 5; // a = a / 5
%=取余赋值a %= 5; // a = a % 5

4.6 三元运算符​

// 语法：condition ? expr1 : expr2
int a = 10;
int b = (a > 5) ? 20 : 30;  // 如果a > 5，b=20，否则b=30

// 字符串比较
String result = (age >= 18) ? "成年人" : "未成年";

5. 数组​

数组是存储固定大小、相同类型数据的容器。

5.1 数组的声明和初始化​

// 声明方式
int[] array1;          // 推荐
int array2[];          // 不推荐

// 创建和初始化
int[] arr1 = new int[5];                    // 指定长度
int[] arr2 = {1, 2, 3, 4, 5};              // 直接初始化
int[] arr3 = new int[]{1, 2, 3, 4, 5};      // 匿名数组

// 多维数组
int[][] matrix1 = new int[3][4];           // 3行4列
int[][] matrix2 = {{1, 2}, {3, 4}, {5, 6}}; // 直接初始化

5.2 数组的基本操作​

int[] arr = {10, 20, 30, 40, 50};

// 访问元素（索引从0开始）
System.out.println(arr[0]);  // 输出：10

// 修改元素
arr[2] = 35;

// 获取数组长度
System.out.println(arr.length);  // 输出：5

// 遍历数组
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

// 增强for循环（foreach）
for (int value : arr) {
    System.out.println(value);
}

5.3 数组的常用操作​

import java.util.Arrays;

int[] arr = {3, 1, 4, 1, 5, 9};

// 数组复制
int[] copy = Arrays.copyOf(arr, arr.length);
int[] copyRange = Arrays.copyOfRange(arr, 1, 4);  // 复制索引1-3

// 数组排序
Arrays.sort(arr);

// 数组查找
int index = Arrays.binarySearch(arr, 4);  // 二分查找，需要先排序

// 数组比较
boolean equal = Arrays.equals(arr, copy);

// 数组转字符串
String str = Arrays.toString(arr);  // "[1, 1, 3, 4, 5, 9]"

6. 控制流程​

6.1 条件语句​

if-else 语句​

// 单分支
if (score >= 90) {
    System.out.println("优秀");
}

// 双分支
if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

// 多分支
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

switch 语句​

// switch 语法
switch (expression) {
    case value1:
        // 代码块1
        break;
    case value2:
        // 代码块2
        break;
    default:
        // 默认代码块
}

// 示例
String day = "MONDAY";
switch (day) {
    case "MONDAY":
        System.out.println("星期一");
        break;
    case "TUESDAY":
        System.out.println("星期二");
        break;
    case "WEDNESDAY":
        System.out.println("星期三");
        break;
    default:
        System.out.println("其他");
        break;
}

// Java 14+ 新语法（箭头语法）
switch (day) {
    case "MONDAY" -> System.out.println("星期一");
    case "TUESDAY" -> System.out.println("星期二");
    case "WEDNESDAY" -> System.out.println("星期三");
    default -> System.out.println("其他");
}

6.2 循环语句​

for 循环​

// 基本for循环
for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}

// 增强for循环（for-each）
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    System.out.println(num);
}

// 嵌套循环
for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        System.out.println("i=" + i + ", j=" + j);
    }
}

while 循环​

// while 循环（先判断，后执行）
int count = 1;
while (count <= 5) {
    System.out.println(count);
    count++;
}

// 死循环示例
int sum = 0;
int num = 1;
while (true) {
    sum += num;
    if (sum > 1000) {
        break;  // 跳出循环
    }
    num++;
}

do-while 循环​

// do-while 循环（先执行，后判断）
int i = 1;
do {
    System.out.println(i);
    i++;
} while (i <= 5);

// 至少执行一次的例子
Scanner scanner = new Scanner(System.in);
int input;
do {
    System.out.println("请输入一个数字（输入0退出）：");
    input = scanner.nextInt();
    System.out.println("您输入的是：" + input);
} while (input != 0);

6.3 跳转语句​

// break 语句：跳出当前循环
for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break;  // 跳出循环
    }
    System.out.println(i);  // 输出1-4
}

// continue 语句：跳过本次循环
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;  // 跳过偶数
    }
    System.out.println(i);  // 输出奇数
}

// 标签跳转（在嵌套循环中使用）
outer: for (int i = 1; i <= 3; i++) {
    inner: for (int j = 1; j <= 3; j++) {
        if (i == 2 && j == 2) {
            break outer;  // 跳出外层循环
        }
        System.out.println("i=" + i + ", j=" + j);
    }
}

7. 方法​

方法（在其他语言中也称为函数）是类中定义的行为单元。

7.1 方法的定义​

// 方法语法
修饰符 返回类型 方法名(参数列表) {
    // 方法体
    return 返回值;  // 如果有返回值
}

// 示例
public int add(int a, int b) {
    return a + b;
}

// 无返回值的方法
public void printMessage(String message) {
    System.out.println(message);
    // 不需要return语句
}

// 无参数的方法
public String getGreeting() {
    return "Hello, World!";
}

7.2 方法的重载​

方法重载是指在同一个类中，可以定义多个同名但参数列表不同的方法。

public class Calculator {

    // 加法：两个整数
    public int add(int a, int b) {
        return a + b;
    }

    // 加法：三个整数
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // 加法：两个浮点数
    public double add(double a, double b) {
        return a + b;
    }

    // 可变参数
    public int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
}

// 使用示例
Calculator calc = new Calculator();
System.out.println(calc.add(5, 3));        // 8
System.out.println(calc.add(5, 3, 2));     // 10
System.out.println(calc.add(5.5, 3.2));     // 8.7
System.out.println(calc.sum(1, 2, 3, 4, 5)); // 15

7.3 递归方法​

递归方法是指方法调用自身的情况。

// 阶乘的递归实现
public long factorial(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

// 斐波那契数列
public int fibonacci(int n) {
    if (n <= 1) {
        return n;
    }
    return fibonacci(n - 1) + fibonacci(n - 2);
}

8. 变量和作用域​

8.1 变量类型​

public class VariableExample {

    // 成员变量（实例变量）
    private int instanceVar = 10;

    // 静态变量（类变量）
    private static int staticVar = 20;

    public void methodExample() {
        // 局部变量
        int localVar = 30;

        // 参数变量
        public void anotherMethod(int paramVar) {
            int innerLocal = 40;
            System.out.println("实例变量: " + instanceVar);
            System.out.println("静态变量: " + staticVar);
            System.out.println("局部变量: " + localVar);
            System.out.println("参数变量: " + paramVar);
            System.out.println("内部局部变量: " + innerLocal);
        }
    }
}

8.2 变量作用域​

public class ScopeExample {

    private static int globalVar = 100;  // 类作用域

    public void method1() {
        int localVar = 10;  // 方法作用域

        if (localVar > 5) {
            int blockVar = 20;  // 块作用域
            System.out.println("块内: " + blockVar);
        }
        // System.out.println(blockVar);  // 编译错误：超出作用域
    }

    public void method2() {
        // localVar 在这里不可见
        System.out.println("全局变量: " + globalVar);
    }
}

9. 字符串处理​

9.1 String 类​

// 字符串创建
String str1 = "Hello";              // 字符串字面量
String str2 = new String("Hello");  // 通过构造函数
String str3 = str1 + " World";      // 字符串拼接

// 字符串常用方法
String text = "Java Programming";

// 长度
int length = text.length();  // 16

// 字符访问
char firstChar = text.charAt(0);  // 'J'

// 子字符串
String sub = text.substring(5);    // " Programming"
String subRange = text.substring(0, 4);  // "Java"

// 查找
int index = text.indexOf("Pro");   // 5
int lastIndex = text.lastIndexOf("a");  // 11

// 替换
String replaced = text.replace("Java", "Python");  // "Python Programming"

// 大小写转换
String upper = text.toUpperCase();  // "JAVA PROGRAMMING"
String lower = text.toLowerCase();  // "java programming"

// 去除空格
String trimmed = "  Hello  ".trim();  // "Hello"

// 分割
String[] words = text.split(" ");  // ["Java", "Programming"]

9.2 StringBuilder 和 StringBuffer​

// StringBuilder（线程不安全，但效率更高）
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
sb.append("!");
String result = sb.toString();  // "Hello World!"

// StringBuilder 链式调用
String message = new StringBuilder()
    .append("姓名：")
    .append(name)
    .append("，年龄：")
    .append(age)
    .toString();

// StringBuffer（线程安全，但效率较低）
StringBuffer sbf = new StringBuffer("Hello");
sbf.append(" World");

// StringBuilder 的其他方法
sb.insert(5, " Beautiful");  // 插入
sb.delete(5, 15);            // 删除
sb.reverse();                // 反转
sb.setLength(0);             // 清空

10. 常见面试题​

10.1 自动拆装箱​

// 面试题：以下代码输出什么？
Integer a = 100;
Integer b = 100;
System.out.println(a == b);      // true（缓存机制）

Integer c = 200;
Integer d = 200;
System.out.println(c == d);      // false（超出缓存范围）

Integer e = new Integer(100);
Integer f = new Integer(100);
System.out.println(e == f);      // false（不同对象）
System.out.println(e.equals(f)); // true（值相等）

int g = 100;
Integer h = 100;
System.out.println(g == h);      // true（自动拆箱比较）

10.2 字符串​

// 面试题：String、StringBuilder、StringBuffer 区别
String s1 = "Hello";
String s2 = "Hello";
System.out.println(s1 == s2);     // true（字符串常量池）

String s3 = new String("Hello");
String s4 = new String("Hello");
System.out.println(s3 == s4);     // false（不同对象）

String s5 = s1 + " World";        // 创建了新对象
String s6 = "Hello World";
System.out.println(s5 == s6);     // false

10.3 数组和集合​

// 面试题：数组和 ArrayList 的区别
String[] array = new String[3];  // 固定大小
ArrayList<String> list = new ArrayList<>();  // 动态大小

// 数组长度固定，不能动态增删
// ArrayList 可以动态增删元素
// 数组可以存储基本类型，ArrayList 只能存储对象类型

总结​

本文档涵盖了 Java 基础语法的核心内容，包括：

  • Java 关键字和数据类型
  • 基本类型和包装类型
  • 运算符和表达式
  • 数组和字符串处理
  • 控制流程和循环
  • 方法的定义和重载
  • 变量作用域
  • 常见面试题

掌握这些基础知识点是学习 Java 的重要基础。建议结合实际编程练习来巩固这些概念，为后续学习面向对象编程、集合框架、多线程等高级主题打下坚实的基础。