Java-第一章-编程基础

Note

Java作为计算机学生的必修课，我们将以一种基础且简单的方式，向大家介绍Java，带领大家一步一步学习Java语言！

因为Java与C语言的基础语法相似，我们之前已经学习过C语言，所以我们将会以很简单的方式和简单的示例来讲解Java的相关基础语法，但是在开始前我们还是要提醒各位，Java最难的部分并非基础语法，而是后续的JDBC、网络、面向对象这些内容，但是基础语法是基础中的基础，所以一定要认真学习哦！

Java是什么？#

Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的 Java 面向对象程序设计语言和 Java 平台的总称。由 James Gosling和同事们共同研发，并在 1995 年正式推出。

后来 Sun 公司被 Oracle （甲骨文）公司收购，Java 也随之成为 Oracle 公司的产品。

Java分为三个体系：

JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）
JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)
JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。

2005 年 6 月，JavaOne 大会召开，SUN 公司公开 Java SE 6。此时，Java 的各种版本已经更名，以取消其中的数字 “2”：J2EE 更名为 Java EE，J2SE 更名为Java SE，J2ME 更名为 Java ME。

Java的特点是什么？#

Java 语言是简单的：Java 语言的语法与 C 语言和 C++ 语言很接近，使得大多数程序员很容易学习和使用。另一方面，Java 丢弃了 C++ 中很少使用的、很难理解的、令人迷惑的那些特性，如操作符重载、多继承、自动的强制类型转换。特别地，Java 语言不使用指针，而是引用。并提供了自动分配和回收内存空间，使得程序员不必为内存管理而担忧。
Java 语言是面向对象的：Java 语言提供类、接口和继承等面向对象的特性，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为 implements）。Java 语言全面支持动态绑定，而 C++语言只对虚函数使用动态绑定。总之，Java语言是一个纯的面向对象程序设计语言。
Java语言是分布式的：Java 语言支持 Internet 应用的开发，在基本的 Java 应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括 URL、URLConnection、Socket、ServerSocket 等。Java 的 RMI（远程方法激活）机制也是开发分布式应用的重要手段。
Java 语言是健壮的：Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证。对指针的丢弃是 Java 的明智选择。Java 的安全检查机制使得 Java 更具健壮性。
Java语言是安全的：Java通常被用在网络环境中，为此，Java 提供了一个安全机制以防恶意代码的攻击。除了Java 语言具有的许多安全特性以外，Java 对通过网络下载的类具有一个安全防范机制（类 ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类 SecurityManager）让 Java 应用设置安全哨兵。
Java 语言是体系结构中立的：Java 程序（后缀为 java 的文件）在 Java 平台上被编译为体系结构中立的字节码格式（后缀为 class 的文件），然后可以在实现这个 Java 平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。
Java 语言是可移植的：这种可移植性来源于体系结构中立性，另外，Java 还严格规定了各个基本数据类型的长度。Java 系统本身也具有很强的可移植性，Java 编译器是用 Java 实现的，Java 的运行环境是用 ANSI C 实现的。
Java 语言是解释型的：如前所述，Java 程序在 Java 平台上被编译为字节码格式，然后可以在实现这个 Java 平台的任何系统中运行。在运行时，Java 平台中的 Java 解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中。
Java 是高性能的：与那些解释型的高级脚本语言相比，Java 的确是高性能的。事实上，Java 的运行速度随着 JIT(Just-In-Time）编译器技术的发展越来越接近于 C++。
Java 语言是多线程的：在 Java 语言中，线程是一种特殊的对象，它必须由 Thread 类或其子（孙）类来创建。通常有两种方法来创建线程：其一，使用型构为 Thread(Runnable) 的构造子类将一个实现了 Runnable 接口的对象包装成一个线程，其二，从 Thread 类派生出子类并重写 run 方法，使用该子类创建的对象即为线程。值得注意的是 Thread 类已经实现了 Runnable 接口，因此，任何一个线程均有它的 run 方法，而 run 方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。Java 语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为 synchronized）。
Java 语言是动态的：Java 语言的设计目标之一是适应于动态变化的环境。Java 程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。另外，Java 中的类有一个运行时刻的表示，能进行运行时刻的类型检查。

Java 程序的基本结构#

Java 程序有固定的编写规范，一个最基础的可运行 Java 程序结构如下：

1.语法规则#

Java 程序的基本单位是类（class），代码必须写在类里面
类名必须和文件名一致（大小写也要相同），且首字母建议大写
程序入口是 main 方法（固定格式：public static void main(String[] args)）
语句以分号 ; 结束，代码块用大括号 {} 包裹

示例

1
// 单行注释：这是一个基础的Java程序结构示例
2
/*
3
 * 多行注释：
4
 * HelloWorld 是类名，必须和文件名 HelloWorld.java 一致
5
 */
6
public class HelloWorld {
7
    public static void main(String[] args) {
8
        System.out.println("Hello, Java!");
9
    }
10
}

运行说明

将代码保存为 HelloWorld.java
打开命令行，进入文件所在目录
执行编译命令：javac HelloWorld.java（生成字节码文件）
执行运行命令：java HelloWorld（输出：Hello, Java!）

运行效果

1
Hello, Java!

基本数据类型#

Java 数据类型分为基本数据类型（8种）和引用数据类型，基本数据类型是构成程序的基础，直接存储数值。

1.byte 类型#

基础语法：byte 是8位有符号整数类型，取值范围 -128 ~ 127，占用1个字节，常用于节省内存（如存储文件流、网络数据）。示例：

1
public class ByteDemo {
2
    public static void main(String[] args) {
3
        byte age = 20;
4
        System.out.println("byte类型变量age的值：" + age);
5
        // 测试取值范围（超过范围会编译报错）
6
        // byte error = 128; // 编译报错：数值超出byte范围
7
    }
8
}

运行效果：

1
byte类型变量age的值：20

2.short 类型#

基础语法：short 是16位有符号整数类型，取值范围 -32768 ~ 32767，占用2个字节，适用于小整数场景。示例：

1
public class ShortDemo {
2
    public static void main(String[] args) {
3
        short score = 95;
4
        System.out.println("short类型变量score的值：" + score);
5
    }
6
}

运行效果：

1
short类型变量score的值：95

3.int 类型#

基础语法：int 是32位有符号整数类型，取值范围 -2^31 ~ 2^31-1（约±21亿），占用4个字节，是Java中最常用的整数类型。示例：

1
public class IntDemo {
2
    public static void main(String[] args) {
3
        int num = 100000;
4
        System.out.println("int类型变量num的值：" + num);
5
    }
6
}

运行效果：

1
int类型变量num的值：100000

4.long 类型#

基础语法：long 是64位有符号整数类型，取值范围 -2^63 ~ 2^63-1，占用8个字节，用于存储大整数（如时间戳），定义时需加后缀 L/l。示例：

1
public class LongDemo {
2
    public static void main(String[] args) {
3
        long timestamp = 1741000000000L;
4
        System.out.println("long类型变量timestamp的值：" + timestamp);
5
    }
6
}

运行效果：

1
long类型变量timestamp的值：1741000000000

5.float 类型#

基础语法：float 是32位单精度浮点数，占用4个字节，定义时需加后缀 F/f，适用于精度要求不高的小数场景。示例：

1
public class FloatDemo {
2
    public static void main(String[] args) {
3
        float price = 9.9F;
4
        System.out.println("float类型变量price的值：" + price);
5
    }
6
}

运行效果：

1
float类型变量price的值：9.9

6.double 类型#

基础语法：double 是64位双精度浮点数，占用8个字节，是Java默认的小数类型，精度高于float。示例：

1
public class DoubleDemo {
2
    public static void main(String[] args) {
3
        double pi = 3.1415926535;
4
        System.out.println("double类型变量pi的值：" + pi);
5
    }
6
}

运行效果：

1
double类型变量pi的值：3.1415926535

7.char 类型#

基础语法：char 是16位字符类型，占用2个字节，存储单个字符（Unicode编码），用单引号 '' 包裹。示例：

1
public class CharDemo {
2
    public static void main(String[] args) {
3
        char ch = 'A';
4
        System.out.println("char类型变量ch的值：" + ch);
5
    }
6
}

运行效果：

1
char类型变量ch的值：A

8.boolean 类型#

基础语法：boolean 表示布尔值，只有 true（真）和 false（假）两个值，占用1个字节，常用于条件判断。示例：

1
public class BooleanDemo {
2
    public static void main(String[] args) {
3
        boolean isSuccess = true;
4
        System.out.println("boolean类型变量isSuccess的值：" + isSuccess);
5
    }
6
}

运行效果：

1
boolean类型变量isSuccess的值：true

运算符#

运算符是用于执行运算的符号，Java 运算符主要分为算术、赋值、比较、逻辑、位运算符等，以下是常用类型：

1.算术运算符#

基础语法：包括 +（加）、-（减）、*（乘）、/（除）、%（取余）、++（自增）、--（自减）。示例：

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

运行效果：

1
a + b = 13
2
a - b = 7
3
a * b = 30
4
a / b = 3
5
a % b = 1
6
a++ = 10
7
++a = 12

2.赋值运算符#

基础语法：基础赋值 =，复合赋值 +=、-=、*=、/=、%=。示例：

1
public class AssignDemo {
2
    public static void main(String[] args) {
3
        int x = 5;
4
        x += 3; // 等价于 x = x + 3
5
        System.out.println("x += 3 后的值：" + x);
6
        x *= 2; // 等价于 x = x * 2
7
        System.out.println("x *= 2 后的值：" + x);
8
    }
9
}

运行效果：

1
x += 3 后的值：8
2
x *= 2 后的值：16

3.比较运算符#

基础语法：==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于），返回布尔值。示例：

1
public class CompareDemo {
2
    public static void main(String[] args) {
3
        int m = 8, n = 8;
4
        System.out.println("m == n：" + (m == n));
5
        System.out.println("m > n：" + (m > n));
6
    }
7
}

运行效果：

1
m == n：true
2
m > n：false

4.逻辑运算符#

基础语法：&&（短路与）、||（短路或）、!（非），操作布尔值，短路特性：&& 左边为false时右边不执行，|| 左边为true时右边不执行。示例：

1
public class LogicDemo {
2
    public static void main(String[] args) {
3
        boolean flag1 = true, flag2 = false;
4
        System.out.println("flag1 && flag2：" + (flag1 && flag2));
5
        System.out.println("flag1 || flag2：" + (flag1 || flag2));
6
        System.out.println("!flag1：" + (!flag1));
7
    }
8
}

运行效果：

1
flag1 && flag2：false
2
flag1 || flag2：true
3
!flag1：false

输入与输出（I/O）#

1.输出#

最常用的两种输出方式：

语法	说明	示例
`System.out.println()`	输出内容后换行	`System.out.println("换行输出");`
`System.out.print()`	输出内容后不换行	`System.out.print("不换行输出");`
`System.out.printf()`	输出格式化内容后不换行	`System.out.printf("%d\n",a);`

2.输入#

需要导入 java.util.Scanner 类，步骤：

导入 Scanner 类（写在类定义上方）
创建 Scanner 对象
使用 Scanner 的方法读取不同类型的数据
关闭 Scanner

示例

1
import java.util.Scanner;
2

3
public class InputOutputDemo {
4
    public static void main(String[] args) {
5

6
        Scanner scanner = new Scanner(System.in);
7

8
        System.out.println("=== Java输入输出示例 ===");
9

10
        System.out.print("请输入你的姓名：");
11
        String name = scanner.next();
12

13
        System.out.print("请输入你的年龄：");
14
        int age = scanner.nextInt();
15

16
        System.out.print("请输入你的身高（米）：");
17
        double height = scanner.nextDouble();
18

19
        System.out.println("\n你的信息：");
20
        System.out.println("姓名：" + name);
21
        System.out.println("年龄：" + age + "岁");
22
        System.out.println("身高：" + height + "米");
23

24
        scanner.close();
25
    }
26
}

运行效果

1
=== Java输入输出示例 ===
2
请输入你的姓名：张三
3
请输入你的年龄：20
4
请输入你的身高（米）：1.75
5

6
你的信息：
7
姓名：张三
8
年龄：20岁
9
身高：1.75米

条件判断结构#

1.if 语句#

基础语法

1
if (条件表达式) {
2
    // 条件为true时执行的代码
3
}

示例

1
public class IfDemo {
2
    public static void main(String[] args) {
3
        int score = 85;
4

5
        if (score >= 60) {
6
            System.out.println("成绩及格！");
7
            System.out.println("你的分数是：" + score);
8
        }
9
    }
10
}

运行效果

1
成绩及格！
2
你的分数是：85

2. if-else 语句#

语法

1
if (条件表达式) {
2
    // 条件为true时执行
3
} else {
4
    // 条件为false时执行
5
}

示例

1
public class IfElseDemo {
2
    public static void main(String[] args) {
3
        int score = 55;
4

5
        if (score >= 60) {
6
            System.out.println("成绩及格！");
7
        } else {
8
            System.out.println("成绩不及格，需要补考！");
9
        }
10
    }
11
}

运行效果

1
成绩不及格，需要补考！

3.if-else if-else 语句#

语法

1
if (条件1) {
2
    // 条件1为true时执行
3
} else if (条件2) {
4
    // 条件2为true时执行
5
} else {
6
    // 所有条件都为false时执行
7
}

示例

1
public class IfElseIfDemo {
2
    public static void main(String[] args) {
3
        int score = 88;
4

5
        if (score >= 90) {
6
            System.out.println("优秀");
7
        } else if (score >= 80) {
8
            System.out.println("良好");
9
        } else if (score >= 70) {
10
            System.out.println("中等");
11
        } else if (score >= 60) {
12
            System.out.println("及格");
13
        } else {
14
            System.out.println("不及格");
15
        }
16
    }
17
}

运行效果

1
良好

4.switch 语句#

适用于固定值匹配的场景（如：数字、字符串），比多层 if-else 更简洁。

语法

1
switch (表达式) {
2
    case 值1:
3
        // 表达式等于值1时执行
4
        break; // 跳出switch（必须加，否则会穿透到下一个case）
5
    case 值2:
6
        // 表达式等于值2时执行
7
        break;
8
    // 更多case...
9
    default:
10
        // 表达式不匹配任何case时执行
11
        break;
12
}

示例

1
public class SwitchDemo {
2
    public static void main(String[] args) {
3
        int week = 3;
4

5
        switch (week) {
6
            case 1:
7
                System.out.println("星期一：开始上班");
8
                break;
9
            case 2:
10
                System.out.println("星期二：努力搬砖");
11
                break;
12
            case 3:
13
                System.out.println("星期三：再坚持两天");
14
                break;
15
            case 4:
16
                System.out.println("星期四：快周末了");
17
                break;
18
            case 5:
19
                System.out.println("星期五：准备放假");
20
                break;
21
            case 6:
22
            case 7:
23
                System.out.println("周末：休息啦！");
24
                break;
25
            default:
26
                System.out.println("输入的星期数无效！");
27
                break;
28
        }
29
    }
30
}

运行效果

1
星期三：再坚持两天

循环结构#

1. while 循环#

适合循环次数不确定的场景，先判断条件，满足才执行循环体。

语法

1
while (条件表达式) {
2
    // 循环体：条件为true时重复执行的代码
3
    // 必须有让条件变为false的语句，否则会无限循环
4
}

示例

1
public class WhileDemo {
2
    public static void main(String[] args) {
3
        int i = 1;
4

5
        while (i <= 5) {
6
            System.out.println("当前数字：" + i);
7
            i++;
8
        }
9

10
        System.out.println("循环结束！");
11
    }
12
}

运行效果

1
当前数字：1
2
当前数字：2
3
当前数字：3
4
当前数字：4
5
当前数字：5
6
循环结束！

2. do-while 循环#

至少执行一次循环体，适合必须先做一次的场景。

语法

1
do {
2
    // 循环体
3
} while (条件表达式);

示例

1
import java.util.Scanner;
2

3
public class DoWhileDemo {
4
    public static void main(String[] args) {
5
        Scanner scanner = new Scanner(System.in);
6
        int target = 7;
7
        int guess;
8

9
        do {
10
            System.out.print("猜一个1-10之间的数字：");
11
            guess = scanner.nextInt();
12

13
            if (guess < target) {
14
                System.out.println("猜小了，再试试！");
15
            } else if (guess > target) {
16
                System.out.println("猜大了，再试试！");
17
            }
18
        } while (guess != target);
19

20
        System.out.println("恭喜你，猜对了！");
21
        scanner.close();
22
    }
23
}

运行效果

1
猜一个1-10之间的数字：1
2
猜小了，再试试！
3
猜一个1-10之间的数字：9
4
猜大了，再试试！
5
猜一个1-10之间的数字：7
6
恭喜你，猜对了！

3. for 循环#

最常用的循环，适合循环次数明确的场景，语法更简洁。

语法

1
for (初始化表达式; 条件表达式; 更新表达式) {
2
    // 循环体
3
}

示例

1
public class ForDemo {
2
    public static void main(String[] args) {
3
        int sum = 0;
4

5
        for (int i = 1; i <= 5; i++) {
6
            sum += i;
7
            System.out.println("累加 " + i + " 后，和为：" + sum);
8
        }
9

10
        System.out.println("\n1-5的总和是：" + sum);
11
    }
12
}

运行效果

1
累加1后，和为：1
2
累加2后，和为：3
3
累加3后，和为：6
4
累加4后，和为：10
5
累加5后，和为：15
6

7
1-5的总和是：15

4. 循环控制关键字#

break：跳出当前循环（结束整个循环）
continue：跳过本次循环，直接进入下一次循环

示例

1
public class LoopControlDemo {
2
    public static void main(String[] args) {
3
        System.out.println("=== break示例 ===");
4
        for (int i = 1; i <= 5; i++) {
5
            if (i == 3) {
6
                break;
7
            }
8
            System.out.println("i = " + i);
9
        }
10

11
        System.out.println("\n=== continue示例 ===");
12
        for (int i = 1; i <= 5; i++) {
13
            if (i == 3) {
14
                continue;
15
            }
16
            System.out.println("i = " + i);
17
        }
18
    }
19
}

运行效果

1
=== break示例 ===
2
i = 1
3
i = 2
4

5
=== continue示例 ===
6
i = 1
7
i = 2
8
i = 4
9
i = 5

Java 数组#

数组是存储相同类型数据的有序集合，分为一维、二维、多维数组，数组长度固定，索引从0开始。

1.一维数组#

基础语法：

声明：数据类型[] 数组名; 或 数据类型数组名[];（推荐前者）
初始化：静态初始化 数据类型[] 数组名 = {值1, 值2, ...};；动态初始化 数据类型[] 数组名 = new 数据类型[长度]; 示例：

1
public class OneDArrayDemo {
2
    public static void main(String[] args) {
3
        int[] nums = {1, 2, 3, 4, 5};
4
        System.out.println("一维数组元素：");
5
        for (int i = 0; i < nums.length; i++) {
6
            System.out.print(nums[i] + " ");
7
        }
8

9
        String[] names = new String[3];
10
        names[0] = "Java";
11
        names[1] = "Python";
12
        names[2] = "C++";
13
        System.out.println("\n动态初始化数组元素：");
14
        for (String name : names) {
15
            System.out.print(name + " ");
16
        }
17
    }
18
}

运行效果：

1
一维数组元素：
2
1 2 3 4 5
3
动态初始化数组元素：
4
Java Python C++

2.二维数组#

基础语法：本质是“数组的数组”，声明 数据类型[][] 数组名;，初始化分为规则二维数组和不规则二维数组。示例：

1
public class TwoDArrayDemo {
2
    public static void main(String[] args) {
3
        int[][] matrix = {{1, 2}, {3, 4}, {5, 6}};
4
        System.out.println("规则二维数组元素：");
5
        for (int i = 0; i < matrix.length; i++) {
6
            for (int j = 0; j < matrix[i].length; j++) {
7
                System.out.print(matrix[i][j] + " ");
8
            }
9
            System.out.println();
10
        }
11

12
        int[][] irregularArr = new int[2][];
13
        irregularArr[0] = new int[2];
14
        irregularArr[1] = new int[3];
15
        irregularArr[0][0] = 10;
16
        irregularArr[1][1] = 20;
17
        System.out.println("不规则二维数组指定元素：");
18
        System.out.println(irregularArr[0][0] + " " + irregularArr[1][1]);
19
    }
20
}

运行效果：

1
规则二维数组元素：
2
1 2
3
3 4
4
5 6
5
不规则二维数组指定元素：
6
10 20

3.多维数组#

基础语法：三维及以上数组，本质是嵌套的二维数组，语法 数据类型[][][] 数组名;，使用场景较少（如三维坐标、多维数据建模）。示例：

1
public class MultiDArrayDemo {
2
    public static void main(String[] args) {
3
        int[][][] cube = {
4
            {{1, 2}, {3, 4}, {5, 6}},
5
            {{7, 8}, {9, 10}, {11, 12}}
6
        };
7
        System.out.println("三维数组中cube[1][2][1]的值：" + cube[1][2][1]);
8
    }
9
}

运行效果：

1
三维数组中cube[1][2][1]的值：12

Java 方法#

方法（函数）是封装特定功能的代码块，可重复调用，提高代码复用性和可读性。

1.方法的定义与调用#

基础语法：

1
修饰符 返回值类型 方法名(参数类型1 参数名1, 参数类型2 参数名2, ...) {
2
    // 方法体（功能逻辑）
3
    return 返回值; // 无返回值时（void）无需return
4
}

示例：

1
public class MethodDemo {
2
    public static void sayHello() {
3
        System.out.println("Hello, Java!");
4
    }
5

6
    public static int add(int num1, int num2) {
7
        return num1 + num2;
8
    }
9

10
    public static void main(String[] args) {
11
        sayHello();
12
        int sum = add(10, 20);
13
        System.out.println("10 + 20 = " + sum);
14
    }
15
}

运行效果：

1
Hello, Java!
2
10 + 20 = 30

2.方法的重载#

基础语法：同一个类中，方法名相同、参数列表（个数/类型/顺序）不同，与返回值无关，用于处理同一类功能的不同参数场景。示例：

1
public class MethodOverloadDemo {
2
    public static int add(int a, int b) {
3
        return a + b;
4
    }
5

6
    public static int add(int a, int b, int c) {
7
        return a + b + c;
8
    }
9

10
    public static double add(double a, double b) {
11
        return a + b;
12
    }
13

14
    public static void main(String[] args) {
15
        System.out.println("两个int求和：" + add(1, 2));
16
        System.out.println("三个int求和：" + add(1, 2, 3));
17
        System.out.println("两个double求和：" + add(1.5, 2.5));
18
    }
19
}

运行效果：

1
两个int求和：3
2
三个int求和：6
3
两个double求和：4.0

总结#

Java 基础语法规范：代码需包裹在类中，程序执行入口为 main 方法；语句以分号结尾，代码块用 {} 界定；支持int、char、double、boolean等基础变量类型的直接定义与使用。
输入输出核心用法：输出依赖 System.out.println()（换行）/System.out.print()（不换行）；输入需导入 java.util.Scanner 类，通过 next()（字符串）、nextInt()（整数）等方法读取控制台数据。
条件判断使用场景：if 语句适配范围性条件判断（如数值区间），switch 语句适配固定值匹配场景；switch 中 break 可终止分支避免穿透，default 处理未匹配到的默认情况。
循环结构选择原则：while 循环适合循环次数不确定的场景（先判断后执行），for 循环适合循环次数明确的场景（初始化、条件、步长一体化）；break 强制终止整个循环，continue 跳过当前循环轮次。
Java 基本数据类型特性：共8种基础类型，整数型（byte/short/int/long）、浮点型（float/double）、字符型（char）、布尔型（boolean）各有专属取值范围，需根据场景选择适配类型。
数组核心特性：存储同类型数据的固定长度集合，一维数组为基础形式，二维/多维数组本质是“数组嵌套数组”；数组索引从0开始，长度不可动态修改。
方法设计与复用：方法是封装特定功能的代码块，支持方法重载（同名不同参数列表）；通过方法封装可降低代码冗余，是Java实现模块化编程的核心基础。

音乐

Pigeons2023

音乐

Java是什么？#

Java的特点是什么？#

Java 程序的基本结构#

1.语法规则#

基本数据类型#

1.byte 类型#

2.short 类型#

3.int 类型#

4.long 类型#

5.float 类型#

6.double 类型#

7.char 类型#

8.boolean 类型#

运算符#

1.算术运算符#

2.赋值运算符#

3.比较运算符#

4.逻辑运算符#

输入与输出（I/O）#

1.输出#

2.输入#

条件判断结构#

1.if 语句#

2. if-else 语句#

3.if-else if-else 语句#

4.switch 语句#

循环结构#

1. while 循环#

2. do-while 循环#

3. for 循环#

4. 循环控制关键字#

Java 数组#

1.一维数组#

2.二维数组#

3.多维数组#

Java 方法#

1.方法的定义与调用#

2.方法的重载#

总结#

支持与分享

评论区

音乐

目录