Java基础教程-Java基础语法【下】（附源码课件）免费白嫖，需要的私信

本文链接：https://blog.youkuaiyun.com/jmysql/article/details/125208095

这篇博客详细介绍了Java的基础语法，包括程序流程控制的顺序、判断、选择和循环结构，以及函数的定义、特点和应用。还探讨了数组的定义、内存分配和常见操作，特别讲解了二维数组的表示和使用。博客提供了丰富的示例代码，适合Java初学者学习。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【尚学堂】Java300集零基础适合初学者视频教程_Java300集零基础教程_Java初学入门视频基础巩固教程_Java语言入门到精通_哔哩哔哩_bilibili

程序流程控制

顺序结构

判断结构

三种格式：

/*=======第一种格式=======*/if(条件表达式){ 执行语句;}/*=======第二种格式=======*/if(条件表达式){ 执行语句;}else{ 执行语句;}/*=======第三种格式=======*/if(条件表达式){ 执行语句;}else if(条件表达式){ 执行语句;}...else{ 执行语句;}

注意：

if语句后若未写大括号，那就只能控制离它最近的单条语句。
if else与三元运算符的区别在于：三元运算符由于是运算符，因此必须有结果。
Java语言中语句一般有两种结束方式：以分号;或后大括号}结束，以}结束的一般为流程控制语句。
Example1：if语句无控制体的情况
if(false);{ System.out.println("Hello World!"); //会打印Hello World!，实际上if没有控制体，大括号内容叫做局部代码块}
Example2：局部代码块
{ int m = 89; System.out.println("Hello World!..."+m);}System.out.println("Over..."+m); //编译报错
局部代码块一执行完，m变量在内存中就会被释放，因此局部代码块可以定义局部变量的生命周期。为了节约内存空间，在确保后面不会在使用此变量的情况下，可以使用局部代码块的形式，执行完后，其空间就会被腾出来（虚拟机在内存当中开辟的空间是有限的，除非在启动虚拟机的时候设置需要的空间）。

选择结构

格式：

switch(表达式){ case 取值1: 执行语句; break; case 取值2: 执行语句; break; ... default：执行语句; break;}

特点：

switch能判断的数据类型有限，只有四种：byte, short, int, char（Java1.5 为switch增加了枚举类型，Java1.7 增加了字符串类型）。
程序一执行到switch，会把大括号内所有的语句加载到内存中。
switch中条件放置无顺序，但执行有顺序。
Example1：即使default放在第一位，也会先判断case
switch(表达式){ default：执行语句; break; case 取值1: 执行语句; break; case 取值2: 执行语句; break; ...}
程序遇到满足条件的值后，如果没有break，则会继续向下执行，之后的case不再进行判断，直接执行里面的语句，直到遇到break或执行到大括号终结。
Example2
int x = 2;swtich(x){ default: System.out.println("d"); //break; case 4: System.out.println("a"); //break; case 1: System.out.println("b"); break; case 3: System.out.println("c"); break;}//输出结果为d, a, b
Example3：多个值，对应相同执行语句
int month = 3;switch(month){ case 3: case 4: System.out.println(month+"月对应的是春季"); break;}
执行到case 3，满足条件，但没有执行语句和break，继续往下执行并且不判断，执行完case 4中的语句再break。

if和swtich的应用：

if
1. 对具体的值进行判断
2. 对值的区间进行判断
3. 对运算结果是boolean类型的表达式进行判断
switch
1. 对具体的值进行判断
2. 值的个数通常是固定的

对于几个固定的值判断，建议使用switch语句，因为其会将具体的答案都加载进内存，效率相对高一点。
常用的为if，不建议用switch语句，因为其功能性较差，且书写麻烦。

循环结构

三种格式：

/*=======while语句格式=======*/while(条件表达式){ 执行语句;}/*=======do while语句格式=======*/do{ 执行语句;}while(条件表达式);/*=======for语句格式=======*/for(初始化表达式;循环条件表达式;循环后的操作表达式){ 执行语句;（循环体）}

特点:

do while：无论条件是否满足，循环体至少执行一次。
for的三个表达式运行顺序：初始化表达式只执行一次；判断循环条件，为真就执行循环体，再执行循环后的操作表达式，接着继续判断循环条件，重复整个过程，直到条件不满足为止。
while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就在内存中释放，而while循环使用的变量在循环结束后还可以继续使用。
最简单无限循环格式：while(true)，for(;;)，无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环（for两边的表达式可以不写，中间不写会默认为true）。
Example1：while语句错误写法
while(条件表达式); //while语句后加分号，会一直循环{ 执行语句;}
Example2： for第一和第三个表达式的非常规写法
int x = 1;for(System.out.println("a");x<3;System.out.println("c")){ System.out.println("d"); x++;}//输出 a d c d c//注意能执行成功，只要满足表达式的条件即可

应用：
Example3: 打印九九乘法表

for(int x = 1; x <= 9; x++){ for(int y = 1; y <= x; y++) { System.out.print(y + "*" + x + "=" + y * x + "\t"); // "\t"：制表符，可以用来对齐 } System.out.println();}

输出结果为

常用转义符：

n：回车
t：制表符
b：退格
r：按下回车键
windows系统中回车符其实是由rn这两个符号组成的，linux中回车符是n，dos可以识别n和rn，但是windows的一些软件中只能识别rn。
Example4：打印带双引号的hello world
System.out.println(""hello world"");//错误写法，会识别成前两个双引号为一对System.out.println("\"hello world\"");//正确写法
Example5：打印带反斜杠的hello world
System.out.println("\\hello world");

其他流程控制语句

break(跳出)：应用于选择结构(swtich)和循环结构(loop)
contine(继续)：应用于循环结构(loop)

注意：

这两个语句离开应用范围就无意义。
这两个语句单独存在下面都不可以有语句，因为执行不到。
如果出现了循环嵌套，break要跳出指定循环，可以通过标号实现——标号的出现，可以让这两个语句作用于指定的范围（标号用得并不多）。
Example
xiaoqiang:for(int x=0; x<3; x++){ wangcai:for(int y=0; y<4; y++) { System.our.println("x=" + x); break xiaoqiang; }}xiaoqiang:for(int x=0; x<3; x++){ wangcai:for(int y=0; y<4; y++) { System.our.println("x=" + x); continue xiaoqiang; }}

函数

函数的定义

什么是函数？

函数就是定义在类中的具有特定功能的一段独立小程序
函数也称为方法

函数的格式：

修饰符返回值类型函数名(参数类型形式参数1, 参数类型形式参数2, ...){ 执行语句; return 返回值;}

Example

class FunctionDemo{ public static void main(String[] args) { int c = add(3,4); System.out.println("c="+c); } int add(int a, int b) { return a+b; }}

编译报错：无法从静态上下文中引用非静态方法add(int, int)，需要在add()函数前加static修饰符（注意是在编译过程中失败）。

函数的特点

定义函数可以将功能代码进行封装
便于对该功能进行复用，函数的出现提高了代码的复用性
函数只有被调用才会被执行
对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写

注意：

函数中只能调用函数，不可以在函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交由调用者处理。
Example

class Demo { public static void main(String[] args) { System.out.println(add(3,5)); } public static void add(int a, int b) { System.out.println(a + b); return; }}

编译出错： System.out.println(add(3,5));此处不允许使用void类型。

函数的应用

Example：判断成绩所属的等级

public static char getLevel1(int num){ char level; if(num>=90 && num<=100) level = 'A'; else if(num>=80 && num<=89) level = 'B'; else if(num>=70 && num<=79) level = 'C'; else if(num>=60 && num<=69) level = 'D'; else if(num<60) level = 'E'; return level;}public static char getLevel2(int num){ char level; if(num>=90 && num<=100) level = 'A'; else if(num>=80 && num<=89) level = 'B'; else if(num>=70 && num<=79) level = 'C'; else if(num>=60 && num<=69) level = 'D'; else if(num<60 || num>100) level = 'E'; return level;}

两个函数均编译错误：可能尚未初始化变量level；编译时不会判断数值（即使涵盖了所有的情况），只管语法错误，所以最后应加else语句。

函数的重载(overload)

重载的概念：在同一类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
重载的特点：与返回值类型无关，只看参数列表。
重载的好处：方便于阅读，优化了程序设计（函数的功能一样，仅仅是参与运算的未知内容不同时，可以定义多函数，却使用统一函数名称，这样方便阅读，在调用时，虚拟机通过参数列表的不同来区分同名函数）。

Example1

public static int add(int a, int b){ return a+b;}public static double add(int a, int b){ return a+b;}

编译报错：已在XX中定义add(int, int)…，Java是严谨性语言，如果函数出现调用的不确定性，会编译失败。

Example2：打印乘法表

/** 打印指定参数的任意乘法表 */public static void printCFB(int num){ for(int x=1; x<=num; x++) { for(int y=1; y<=x; y++) { System.our.print(y+"*"+x+"="+y*x+"t"); } System.out.println(); }}/** 打印标准乘法表（不指定参数的情况下） */public static void printCFB(){ for(int x=1; x<=9; x++) { for(int y=1; y<=x; y++) { System.our.print(y+"*"+x+"="+y*x+"t"); } System.out.println(); }}

如上，一般只要一重载，代码就会重复；可以通过调用的方式，减少重复代码。

/** 打印指定参数的任意乘法表 */public static void printCFB(int num){ for(int x=1; x<=num; x++) { for(int y=1; y<=x; y++) { System.our.print(y+"*"+x+"="+y*x+"t"); } System.out.println(); }}/** 打印标准乘法表。 */public static void printCFB(){ printCFB(9);}

一般由于参数个数的原因重载，都能复用；而如果是参数类型，则不行。

函数调用

栈的形式

数组

数组的定义

概念：同一类型数据的集合，其实数组就是一个容器。

好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

格式：

/*=======第一种格式=======*/元素类型[] 数组名 = new 元素类型[元素个数或数组长度];/*=========示例========*/int[] arr = new int[5];/*=======第二种格式=======*/元素类型[] 数组名 = new 元素类型[]{元素1, 元素2, ...};/*=========示例========*/int[] arr = new int[]{3,5,1,7}; //用new，常规初始化方式int[] arr = {3,5,1,7}; //静态初始化方式//以上两种方式在大部分情况下都是通用的，但它们在重新赋值或传参时会有一点小差别

Example

int[] arr = new int[3];System.out.println(arr[0]);System.out.println(arr[1]);//均输出0（默认赋值为0）

数组的内存分配及特点

Java内存分为五片：

寄存器（CPU使用）
本地方法区（调用系统底层内容）
方法区（别名【数据区、共享区、share data】，存储方法）
栈内存（基本数据类型）：存储的都是局部变量，变量所属的作用域一旦结束，该变量就会自动释放。
堆内存（引用数据类）：存储数组和对象（其实数组也是对象），凡是new建立的对象都在堆中。

堆的特点：

每一个实体都有首地址值。
堆内存中的每一个变量都有默认初始化值，根据类型的不同而不一样，整数：0，小数：0.0或者0.0f，boolean：false，char ：‘u0000’，实体：null。
垃圾回收机制：当堆中的实体没有被任何变量指向时，不像栈一样，会立刻被释放，而是会被视作垃圾，被自动回收，垃圾回收机制会不定时的，自动检测堆里的垃圾，进行回收。C++需要程序员手动回收堆里的垃圾，析构函数。

Example1

int[] arr = new int[3];//arr在栈中，new int[3]在堆中，堆中存的是实体，实体的用途：用于封装数据，存储很多数据

Example2

sytem.out.print(arr[0]);//先找arr，再根据地址找数组，找到数组后找对应的元素arr = null; //让arr不指向任何实体对象

数组操作常见问题

Example1：ArrayIndexOutOfBoundsException异常

int[] arr = new int[3];System.out.println(arr[3]);

编译完，不会出错，因为编译时不会在内存中建立数组，因此也不会找角标
运行时，产生问题，当访问到数组中不存在的角标/索引时，就会产生ArrayIndexOutOfBoundsException异常。

Example2：NullPointerException异常

int[] arr = new int[3];arr = null;System.out.println(arr[0]);

运行出错，当引用型变量没有任何实体指向时，还在用其操作实体，就会产生NullPointerException异常。

Example3

int[] arr = new int[3];System.out.println(arr); //[I@c17164

@右边：哈希值，哈希本身是一种算法，由这个算法来定义数组实体在内存中存储的位置，可以简单理解为是一个地址值，windows支持的，Java调用。
@左边：代表实体的类型， [：数组型， I：int型。
测试的时候用，当我们不知道这个变量接收的数据是什么类型时，可以打印出来看看。

数组常见操作

Example1：获取最值（最大值，最小值）

class Demo{ public static void main(String[] args) { int[] arr = {-34,-19,-11,-109,-3,-56}; int max = getMax(arr); System.out.println("max="+max); } public static int getMax(int[] arr) { int max = arr[0]; for(int x=1; x<arr.length; x++) { if(arr[x]>max) max = arr[x]; } return max; }}

注意max初始化的问题，若初始化为0，则判断不出最大值。

Example2-1：选择排序，特定位置和其他位置比较

public static void selectSort(int[] arr){ for(int i = 0; i < arr.length-1; i++) { for(int j = i+1; j < arr.length; j++) { if(arr[i]>arr[j]) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } }}//性能问题//在selectSort中，每次把最小的元素放到固定位置的过程中，会进行大量元素的交换，实际上只要找到值最小的元素，再与固定位置交换即可public static void selectSort_2(int[] arr){ for(int x=0; x<arr.length-1; x++) { int num = arr[x]; int idex = x; for(int y=x+1; y<arr.length; y++) { if(num>arr[y]) { num = arr[y]; index = y; } } if(index!=x) { int temp = arr[x]; arr[x] = arr[index]; arr[index] = temp; } }}

Example2-2：冒泡排序，相邻元素比较

public static void bubbleSort(int[] arr){ for(int x=0; x<arr.length-1; x++)//每次循环将此次比较的元素中最大的元素移到此次序列的最后 { for(int y=0; y<arr.length-1-x; y++)//-1避免角标越界，-x外循环增加一次，比较的元素个数递减 { if(arr[y]>arr[y+1]) { int temp = arr[y]; arr[y] = arr[y+1]; arr[y+1] = temp; } } }}//数组中元素的交换可以提取出来，写作函数public static void swap(int[] arr,int a,int b){ int temp = arr[a]; arr[a] = arr[b]; arr[b] = temp;}public static void bubbleSort_2(int[] arr){ for(int x=0; x<arr.length-1; x++) { for(int y=0; y<arr.length-1-x; y++) { if(arr[y]>arr[y+1]) swap(arr,y,y+1); } }}//其中的for循环也可以写成以下形式for(int x=arr.length-1; x>0; x--){ for(int y=0; y<x; y++) { ... }}

注意：
1、可以通过调用Arrays.sort(arr);实现排序功能
2、操作的是同一空间

Example3：折半查找（二分查找）

public static int func(int[] arr, int value){ int min, max, mid; min = 0; max = arr.length; mid = (min+max)/2; while(min <= max) { mid = (min+max)/2;//mid = (a+b)>>2; if(arr[mid] < value) min = mid+1; else if(arr[mid] > value) max = mid-1; else return mid; } return -1;}

注意：

给定一个有序数组，若往该数组中存储一个元素，并保证数组仍然是有序的，那么这个元素存储的角标如何获取-->return min。
int[] arr = {13,15,19,27,33,45,78,106};Arrays.binarySearch(arr,45);//若元素存在，返回元素所在的位置；//若元素不存在，返回的是-插入点-1；之所以-1，是因为避免返回0，例如Arrays.binarySearch(arr,5)

Example4：进制转换：利用与运算实现

public static void main(String[] args){ toHex(60);}//0,1,2,3,4,5,6,7,8,9,A, B, C, D, E, F//0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15public static void toHex(int num){ for(int x = 0; x < 8; x++) { int temp = num & 15; if(temp > 9) System.out.print((char)(temp-10+'A')); else System.out.print(temp); num = num >>> 4; }}/* 什么时候使用数组呢？如果数据出现了对应关系，而且对应关系的一方是有序的数字编号，可作为角标使用。将这些数据存储到数组中，根据运算的结果作为角标直接去查数组中对应的元素即可。这种方式：称为查表法。（存在对应关系，但无序，可以使用map） */public static void toHex_2(int num){ if(num == 0) { System.out.print("0"); return; } char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; char[] arr = new char[8]; int pos = arr.length; while(num != 0) { int temp = num & 15; arr[--pos] = chs[temp]; num = num >>> 4; } for(int x = pos; x < arr.length; x++) { System.out.print(arr[x]); }}/*十进制转二进制/八进制类似可以通过函数调用的方式，将通用的代码抽出来 *///十进制-->十六进制public static void toHex(int num){ trans(num,15,4);}//十进制-->二进制public static void toBinary(int num){ trans(num,1,1);}//十进制-->八进制public static void toOctal(int num){ trans(num,7,3);}public static void trans(int num, int base, int offset){ if(num == 0) { System.out.print("0"); return; } char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; char[] arr = new char[32]; int pos = arr.length; while(num != 0) { int temp = num & base; arr[--pos] = chs[temp]; num = num >>> offset; } for(int x = pos; x < arr.length; x++) { System.out.print(arr[x]); }}

注意：可以通过Integer类的方法直接将十进制数转换为对应的进制数

System.out.println(Integer.toBinaryString(-6));System.out.println(Integer.toHexString(5));System.out.println(Integer.toOctalString(32));

二维数组

格式：

格式1：int[][] arr = new int[3][2];

定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称为arr[0]，arr[1]，arr[2]
给第一个一维数组1角标位赋值为78写法：arr[0][1] = 78;

格式2：int[][] arr = new int[3][];

二维数组中有3个一维数组
每个一维数组都是默认初始化值null
可以对这三个一维数组分别进行初始化
arr[0] = new int[3];arr[1] = new int[1];arr[2] = new int[2];

格式3：

int[][] arr = {{3,1,7},{5,8,2,9},{4,6}};

还可以写成如下方式：

int[][] arr = new int[3][2];int[] arr[] = new int[3][2];int arr[][] = new int[3][2];

内存图示：

Example1：直接打印二维数组

int[][] arr1 = new int[3][2];System.out.println(arr); //[[I@c17164System.out.println(arr[0]); //[I@1fb8ee3System.out.println(arr[0][0]); //0int[][] arr2 = new int[3][];System.out.println(arr); //[[I@c17164System.out.println(arr[0]); //nullSystem.out.println(arr[0][0]); //NullPointerException

Example2：数组长度

System.out.println(arr.length); //打印二维数组的长度-->就是一维数组的个数。System.out.println(arr[1].length); //打印二维数组中角标为1的一维数组的长度。