OpenJDK 17 安装与 Java 基础语法笔记

Java环境安装与基础语法

安装 OpenJDK 17（含开发工具）

通过APT命令快速安装OpenJDK 17，适用于Ubuntu等Debian系Linux系统：

1
sudo apt install openjdk-17-jdk

安装过程示意图：

注：若为其他系统，需对应调整安装命令（如CentOS用yum，Windows需手动下载安装包）

验证安装

安装完成后，执行以下命令验证JDK是否安装成功，需同时显示java和javac版本：

1
2
java -version
javac -version

验证成功示意图：

基础语法核心规则

Java中公共类的命名有严格规范，与PHP的PSR - 4自动加载原则逻辑相近，具体规则如下：

  1. 公共类（public修饰）
    文件名必须与public类名完全一致（含大小写），否则编译会直接报错。
    示例：定义public class HelloWorld，对应的文件名必须为HelloWorld.java。
  2. 非公共类（无public修饰）
    文件名可与类名不同，但建议保持一致，便于团队协作时快速定位代码文件。
    示例：文件名Test.java中，可定义class Demo，编译无报错。

一、Java程序基本结构：Hello World

Java程序以类为基本组织单位，所有代码需包裹在类中；程序入口固定为main方法。以下是第一个Java程序的实现：

1. 编写代码

创建HelloWorld.java文件，写入如下代码：

1
2
3
4
5
6
7
public class HelloWorld {
    // 程序入口方法，固定写法
    public static void main(String[] args) {
        // 控制台输出语句
        System.out.println("Hello, World!"); 
    }
}

2. 编译与运行

操作 命令 说明
编译 javac HelloWorld.java 将Java源文件编译为.class字节码文件
运行 java HelloWorld 执行字节码文件，无需加.class后缀

编译效果示意图：

运行效果示意图：

二、注释

注释用于解释代码功能，不参与程序运行，Java支持三种注释方式，具体区别如下：

类型 定义 语法格式 特点 示例代码
单行注释 注释单行内容 // 注释内容 仅作用于当前行，从//到行尾均为注释 // 定义用户年龄变量
int age = 18;
多行注释 注释连续多行内容 /* 注释内容 */ 可跨多行，不支持嵌套 /* 这是用户信息管理模块 包含用户名、年龄等字段的定义 */
文档注释 用于类、方法等，支持生成API文档 /** 注释内容 */ 可跨多行，支持@param等标签，通过javadoc生成文档 /** * 实现两数加法运算 * @param a 第一个加数 * @param b 第二个加数 * @return 两数的和 */ public static int add(int a, int b) { return a + b; }

三、标识符与关键字

1. 标识符

用于给类、变量、方法等命名的符号，需遵循以下规则：

  • 由字母、数字、下划线（_）、美元符号（$）组成，不能以数字开头
  • 大小写敏感（如userName和username是两个不同标识符）
  • 不可使用Java关键字作为标识符

2. 关键字

Java预留的特殊单词，具有固定功能，例如public（公共修饰符）、static（静态修饰符）、int（整数类型）、if（条件判断）等，禁止作为标识符使用。

四、数据类型与转换

Java是强类型语言，变量必须先声明类型再使用，数据类型分为基本类型和引用类型两大类。

1. 基本数据类型

共8种，占用空间和取值范围固定，具体信息如下：

类型 占用空间 范围 示例
byte 1字节 -128 ~ 127 byte a = 100;
short 2字节 -32768 ~ 32767 short b = 2000;
int 4字节 -2³¹ ~ 2³¹-1（约±20亿） int c = 100000;
long 8字节 -2⁶³ ~ 2⁶³-1 long d = 1000000L;（必须加L标识）
float 4字节 单精度浮点数（小数点后6 - 7位） float e = 3.14F;（必须加F标识）
double 8字节 双精度浮点数（小数点后15 - 16位） double f = 3.14159;（默认浮点类型）
char 2字节 0 ~ 65535（Unicode字符） char g = 'A'; 或 char h = '中';
boolean 1字节 仅true（真）或false（假） boolean i = true;

2. 验证基本数据类型特性

通过包装类的常量可验证各基本类型的属性，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public class PrimitiveTypeTest {  
    public static void main(String[] args) {  
        // 验证byte类型
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  
        System.out.println("包装类：java.lang.Byte");  
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);  
        System.out.println();  

        // 验证short类型
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);  
        System.out.println("包装类：java.lang.Short");  
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);  
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);  
        System.out.println();  

        // 验证int类型
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
        System.out.println("包装类：java.lang.Integer");  
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  
        System.out.println();  

        // 验证long类型
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  
        System.out.println("包装类：java.lang.Long");  
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);  
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);  
        System.out.println();  

        // 验证float类型
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  
        System.out.println("包装类：java.lang.Float");  
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);  
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);  
        System.out.println();  

        // 验证double类型
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
        System.out.println("包装类：java.lang.Double");  
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);  
        System.out.println();  

        // 验证char类型
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
        System.out.println("包装类：java.lang.Character");  
        System.out.println("最小值：Character.MIN_VALUE=" + (int) Character.MIN_VALUE);  
        System.out.println("最大值：Character.MAX_VALUE=" + (int) Character.MAX_VALUE);  
    }  
}

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127

基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767

基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647

基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807

基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38

基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308

基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535

3. 引用数据类型

引用类型存储对象的内存地址，而非对象本身，常见类型包括类、数组、接口等，示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 定义Student类
class Student {
    String name;
    int age;
}

public class ReferenceTypeDemo {
    public static void main(String[] args) {
        // 创建Student对象，s指向该对象的内存地址
        Student s = new Student();
        s.name = "28.7Blog";
        s.age = 21;
        System.out.println("修改后：" + s.name + "，" + s.age);

        // s重新指向新的Student对象
        s = new Student();
        s.name = "Blog";
        s.age = 367;
        System.out.println("指向新对象后：" + s.name + "，" + s.age);
    }
}

运行效果示意图：

五、变量与常量

1. 变量

值可动态修改的量，声明格式为数据类型 变量名 = 初始值;，示例：

1
2
3
int age; // 声明int类型变量age
age = 18; // 赋值
int score = 90; // 声明并赋值（推荐写法，避免未初始化报错）

2. 常量

程序运行中不可修改的值，用final关键字修饰，命名规范为全大写，多单词用下划线分隔，示例：

1
2
final double PI = 3.14159; // 声明圆周率常量
// PI = 3.14; // 错误：常量不可重新赋值

六、类型转换

仅数值型基本类型（排除boolean）可相互转换，分为自动转换和强制转换两种。

1. 自动类型转换

当目标类型取值范围大于源类型时，Java自动完成转换，无需手动干预，示例：

1
2
3
4
5
6
7
8
9
10
11
public class AutoTypeConvert {
    public static void main(String[] args) {
        char c1 = 'a'; // 'a'对应的Unicode值为97
        int i1 = c1; // char自动转为int
        System.out.println("char自动转为int后：" + i1);

        char c2 = 'A'; // 'A'对应的Unicode值为65
        int i2 = c2 + 1; // char与int运算时自动转int
        System.out.println("char与int运算结果：" + i2);
    }
}

运行结果：

1
2
char自动转为int后：97
char与int运算结果：66

2. 强制类型转换

当目标类型取值范围小于源类型时，需手动指定转换类型，格式为(目标类型)值，但可能导致精度丢失，示例：

正确示例
1
2
3
4
5
6
7
public class ForceTypeConvert {
    public static void main(String[] args) {
        int i1 = 123;
        byte b = (byte) i1; // 强制将int转为byte
        System.out.println("int强制转为byte后：" + b);
    }
}

运行结果：

1
int强制转为byte后：123
错误示例

不兼容类型无法强制转换，如下代码会编译报错：

1
2
3
4
5
6
7
public class ErrorConvert {
    public static void main(String[] args) {
        String str = "Hello World";
        byte b = (byte) str; // 错误：String与byte类型不兼容
        System.out.println(b);
    }
}

编译报错信息：

1
2
3
4
ErrorConvert.java:5: error: incompatible types: String cannot be converted to byte
        byte b = (byte) str;
                       ^
1 error

七、运算符

Java运算符用于数据计算或逻辑判断，常见类型及用法如下：

1. 算术运算符

运算符 说明 示例 结果
+ 加法运算 5 + 3 8
- 减法运算 5 - 3 2
* 乘法运算 5 * 3 15
/ 除法运算（整数相除取整） 5 / 2 2
% 取余运算 5 % 2 1
++ 自增（前++先加后用，后++先用后加） int a=2; int b=++a; a=3，b=3
-- 自减（规则同自增） int a=2; int b=a--; a=1，b=2

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ArithmeticDemo {
    public static void main(String[] args) {
        int a = 10, b = 20, c = 25, d = 25;
        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("b / a = " + (b / a));
        System.out.println("c % a = " + (c % a));
        System.out.println("a++ = " + (a++));
        System.out.println("a-- = " + (a--));
        System.out.println("d++ = " + (d++));
        System.out.println("++d = " + (++d));
    }
}

运行结果：

1
2
3
4
5
6
7
8
9
a + b = 30
a - b = -10
a * b = 200
b / a = 2
c % a = 5
a++ = 10
a-- = 11
d++ = 25
++d = 27

2. 赋值运算符

基础赋值符为=，扩展赋值符会自动隐含强制类型转换，常见扩展运算符如下：

运算符 示例 等价写法
+= a += 3 a = (a的类型)(a + 3)
-= a -= 3 a = (a的类型)(a - 3)
*= a *= 3 a = (a的类型)(a * 3)

3. 比较运算符

运算结果为boolean类型（true或false），常用运算符：==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于），示例：

1
2
3
4
5
6
7
public class CompareDemo {
    public static void main(String[] args) {
        int a = 5, b = 3;
        System.out.println(a > b); // true
        System.out.println(a == b); // false
    }
}

4. 逻辑运算符

仅操作boolean类型，支持短路特性（左边结果可确定时，右边不执行）：

运算符 说明 示例 结果
&& 逻辑与（两边均为true才为true） true && false false
` ` 逻辑或（一边为true即为true）
! 逻辑非（取反） !true false

5. 三元运算符

格式：条件表达式 ? 表达式1 : 表达式2，条件为true时执行表达式1，否则执行表达式2，示例：

1
2
3
4
5
6
7
public class TernaryDemo {
    public static void main(String[] args) {
        int a = 10, b = 20;
        int max = a > b ? a : b; // 取a和b中的最大值
        System.out.println("最大值：" + max);
    }
}

运行结果：

1
最大值：20

八、控制流语句

控制程序执行顺序，分为条件语句、循环语句和跳转语句三类。

1. 条件语句（if - else）

1
2
3
4
5
6
7
8
9
10
public class IfElseDemo {
    public static void main(String[] args) {
        int x = 30;
        if (x < 20) {
            System.out.print("这是if语句");
        } else {
            System.out.print("这是else语句");
        }
    }
}

运行结果：

1
这是else语句

2. 循环语句（while）

1
2
3
4
5
6
7
8
9
10
public class WhileDemo {
    public static void main(String[] args) {
        int x = 10;
        // x小于20时循环执行
        while (x < 20) {
            System.out.println("value of x : " + x);
            x++; // x自增1
        }
    }
}

运行结果：

1
2
3
4
5
6
7
8
9
10
value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19

3. 跳转语句

语句 作用
break 跳出当前循环或switch语句
continue 跳过本次循环剩余代码，直接进入下次循环
return 结束当前方法的执行

九、switch - case语句

用于多条件匹配，匹配成功后执行对应逻辑，break语句用于跳出switch，否则会继续执行后续case，示意图：

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class SwitchCaseDemo {
    public static void main(String[] args) {
        char grade = 'C'; // 待匹配的等级

        switch (grade) {
            case 'A':
                System.out.println("优秀");
                break; // 跳出switch
            case 'B':
            case 'C': // B和C等级均执行该逻辑
                System.out.println("良好");
                break;
            case 'D':
                System.out.println("及格");
                break;
            case 'F':
                System.out.println("你需要再努力努力");
                break;
            default: // 无匹配项时执行
                System.out.println("未知等级");
        }
        System.out.println("你的等级是 " + grade);
    }
}

运行结果：

1
2
良好
你的等级是 C