登录
目录
当前位置： 首页 > 文档资料 > Java 基础入门笔记 >

第2章 Java编程基础 - Java语法基础-2

优质
小牛编辑
139浏览
2023-12-01

1.1 流程控制语句

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

流程控制语句分类：顺序结构、选择结构、循环结构

1.2 顺序结构概述

是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

总的来说：写在前面的先执行，写在后面的后执行

Java语法基础-2 - 图1

1.3 选择结构

选择结构也被称为分支结构。选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。

Java语言提供了两种选择结构语句：（1）if语句（2）switch语句

1.3.1 选择结构(if语句)

if语句有三种格式

if语句第一种格式：

  1. if(关系表达式) {
  2.   语句体
  3. }

执行流程：

  • 首先判断关系表达式看其结果是true还是false
  • 如果是true就执行语句体
  • 如果是false就不执行语句体

Java语法基础-2 - 图2

注意事项：

  • 关系表达式无论简单还是复杂，结果必须是boolean类型
  • if语句控制的语句体如果是一条语句，大括号可以省略；如果是多条语句，就不能省略。建议永远不要省略。
  • 一般来说：有左大括号就没有分号，有分号就没有左大括号

if语句第二种格式：

  1. if(关系表达式) {
  2.     语句体1;
  3. }else {
  4.     语句体2;
  5. }

执行流程：

  • 首先判断关系表达式看其结果是true还是false

  • 如果是true就执行语句体1

  • 如果是false就执行语句体2

Java语法基础-2 - 图3

  1. /*
  2.     if语句格式2的练习：
  3.         A:获取两个数据中较大的值
  4.         B:判断一个数据是奇数还是偶数,并输出是奇数还是偶数
  5. */  
  6. import java.util.Scanner;  
  8. class IfTest {  
  9.     public static void main(String[] args) {  
  10.         //创建键盘录入对象  
  11.         Scanner sc = new Scanner(System.in);  
  13.         //获取两个数据中较大的值  
  14.         System.out.println("请输入第一个数据：");  
  15.         int a = sc.nextInt();  
  17.         System.out.println("请输入第二个数据：");  
  18.         int b = sc.nextInt();  
  20.         //定义一个变量接收最大值  
  21.         int max;  
  23.         if(a > b) {  
  24.             max = a;  
  25.         }else {  
  26.             max = b;  
  27.         }  
  29.         System.out.println("max:"+max);  
  30.         System.out.println("----------------");  
  32.         //判断一个数据是奇数还是偶数  
  33.         System.out.println("请输入你要判断的数据：");  
  34.         int x = sc.nextInt();  
  36.         if(x%2 == 0) {  
  37.             System.out.println(x+"这个数据是偶数");  
  38.         }else {  
  39.             System.out.println(x+"这个数据是奇数");  
  40.         }  
  41.     }  
  42. }

运行结果：

Java语法基础-2 - 图4

if语句第三种格式：

  1. if(关系表达式1) {
  2.    语句体1;
  3. }else  if (关系表达式2) {
  4.    语句体2;
  5. }
  6. …
  7. else {
  8.    语句体n+1;
  9. }

执行流程：

  • 首先判断关系表达式1看其结果是true还是false
  • 如果是true就执行语句体1
  • 如果是false就继续判断关系表达式2看其结果是true还是false
  • 如果是true就执行语句体2
  • 如果是false就继续判断关系表达式…看其结果是true还是false
    …
  • 如果没有任何关系表达式为true，就执行语句体n+1。

Java语法基础-2 - 图5

  1. /*
  2.     三种if语句分别适合做什么事情呢?
  3.         格式1：适合做单个判断
  4.         格式2：适合做两个判断
  5.         格式3：适合做多个判断
  7.     需求：
  8.         键盘录入x的值，计算出y的并输出。
  10.         x>=3 y = 2x + 1;
  11.         -1<=x<3   y = 2x;
  12.         x<=-1    y = 2x – 1;
  14.     分析：
  15.         A:由于数据要键盘录入，所以必须使用Scanner。
  16.         B:由于是三种判断，所以我们选择if语句格式3。
  17. */  
  18. import java.util.Scanner;  
  20. class IfTest2 {  
  21.     public static void main(String[] args) {  
  22.         //创建键盘录入对象  
  23.         Scanner sc = new Scanner(System.in);  
  25.         System.out.println("请输入x的值：");  
  26.         int x = sc.nextInt();  
  28.         //定义一个y  
  29.         int y;  
  31.         //用if语句格式3进行判断  
  32.         if(x >= 3) {  
  33.             y = 2*x + 1;  
  34.         }else if(x>=-1 && x<3) {  
  35.             y = 2*x;  
  36.         }else {  
  37.             y = 2*x - 1;  
  38.         }  
  40.         System.out.println("y:"+y);  
  41.     }  
  42. }

运行结果：

Java语法基础-2 - 图6

switch语句格式：

  1. switch(表达式) {
  2.   case 值1：
  3.     语句体1;
  4.     break;
  5.   case 值2：
  6.     语句体2;
  7.     break;
  8.   …
  9.   default：
  10.     语句体n+1;
  11.     break;
  12. }

格式解释

  • switch表示这是switch语句
    • 表达式的取值：byte，short，int，char
    • JDK5以后可以是枚举
    • JDK7以后可以是String
  • case后面跟的是要和表达式进行比较的值
  • 语句体部分可以是一条或多条语句
  • break表示中断，结束的意思，可以结束switch语句
  • default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

执行流程

  • 首先计算出表达式的值
  • 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
  • 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

Java语法基础-2 - 图7

  1. /*
  2.     用switch语句实现键盘录入月份，输出对应的季节
  4.     分析：
  5.         A:键盘录入一个月份，用Scanner实现
  6.         B:用switch语句实现即可
  7. */  
  8. import java.util.Scanner;  
  10. class SwitchTest4 {  
  11.     public static void main(String[] args) {  
  12.         //创建键盘录入对象  
  13.         Scanner sc = new Scanner(System.in);  
  15.         //录入数据  
  16.         System.out.println("请输入月份(1-12)：");  
  17.         int month = sc.nextInt();  
  19.         //case穿透  
  20.         switch(month) {  
  21.             case 1:  
  22.             case 2:  
  23.             case 12:  
  24.                 System.out.println("冬季");  
  25.                 break;  
  26.             case 3:  
  27.             case 4:  
  28.             case 5:  
  29.                 System.out.println("春季");  
  30.                 break;  
  31.             case 6:  
  32.             case 7:  
  33.             case 8:  
  34.                 System.out.println("夏季");  
  35.                 break;  
  36.             case 9:  
  37.             case 10:  
  38.             case 11:  
  39.                 System.out.println("秋季");  
  40.                 break;  
  41.             default:  
  42.                 System.out.println("你输入的月份有误");  
  43.         }  
  44.     }  
  45. }

运行结果：

Java语法基础-2 - 图8

（3）if语句和switch语句的区别?
if语句：

  • A:针对结果是boolean类型的判断
  • B:针对一个范围的判断
  • C:针对几个常量值的判断

switch语句：针对几个常量值的判断

注意事项：

  • case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
  • default可以省略吗?可以省略。一般不建议。除非判断的值是固定的。
  • break可以省略吗?可以省略，一般不建议。否则结果可能不是你想要的
  • default的位置一定要在最后吗?可以出现在switch语句任意位置。
  • switch语句的结束条件，遇到break执行到程序的末尾

2. 循环结构

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

2.1 循环语句的组成

  • 初始化语句：一条或者多条语句，这些语句完成一些初始化操作
  • 判断条件语句：这是一个boolean 表达式，这个表达式能决定是否执行循环体
  • 循环体语句：这个部分是循环体语句，也就是我们要多次做的事情
  • 控制条件语句：这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束

2.2 for循环语句格式

  1. for(初始化语句;判断条件语句;控制条件语句) {
  2.        循环体语句;
  3. }

执行流程

  • 执行初始化语句
  • 执行判断条件语句，看其结果是true还是false
    • 如果是false，循环结束
    • 如果是true，继续执行
  • 执行循环体语句
  • 执行控制条件语句
  • 回到B继续

Java语法基础-2 - 图9

注意事项

  • 判断条件语句的结果是一个boolean类型

  • 循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。

  • 一般来说：有左大括号就没有分号，有分号就没有左大括号

2.3 for语句的练习

代码示例：在控制台输出所有的”水仙花数”

  1. /*
  2.     需求：在控制台输出所有的”水仙花数”
  4.     分析：
  5.         我们都不知道什么叫"水仙花数"，你让我怎么做呢?
  7.         所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
  8.         举例：153就是一个水仙花数。
  9.         153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
  11.         A:三位数其实是告诉了我们范围。
  12.         B:通过for循环我们就可以实现获取每一个三位数
  13.           但是麻烦是如何获取这个三位数的个,十,百位上的数据
  15.           我们如何获取一个数据的个,十,百呢?
  16.             假设有个一个数据:153
  17.             ge: 153%10 = 3
  18.             shi: 153/10%10 = 5
  19.             bai：153/10/10%10 = 1
  20.             qian：x/10/10/10%10
  21.             wan:  x/10/10/10/10%10
  22.             ...
  24.         C:让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较
  25.           如果相同，就把该数据在控制台输出。
  26. */  
  27. class ForDemo6 {  
  28.     public static void main(String[] args) {  
  29.         //三位数其实是告诉了我们范围。  
  30.         for(int x=100; x<1000; x++) {  
  31.             int ge = x%10;  
  32.             int shi = x/10%10;  
  33.             int bai = x/10/10%10;  
  35.             //让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较  
  36.             if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {  
  37.                 //如果相同，就把该数据在控制台输出。  
  38.                 System.out.println(x);  
  39.             }  
  40.         }  
  41.     }  
  42. }

运行结果：

Java语法基础-2 - 图10

代码示例：回文数

  1. /*
  2.     练习：
  3.         请在控制台输出满足如下条件的五位数
  4.         个位等于万位
  5.         十位等于千位
  6.         个位+十位+千位+万位=百位
  8.     分析：
  9.         A:五位数就告诉了我们范围。
  10.         B:分解每一个五位数的个，十，百，千，万位上的数据
  11.         C:按照要求进行判断即可
  12. */  
  13. class ForDemo7 {  
  14.     public static void main(String[] args) {  
  15.         //五位数就告诉了我们范围。  
  16.         for(int x=10000; x<100000; x++) {  
  17.             //分解每一个五位数的个，十，百，千，万位上的数据  
  18.             int ge = x%10;  
  19.             int shi = x/10%10;  
  20.             int bai  = x/10/10%10;  
  21.             int qian = x/10/10/10%10;  
  22.             int wan = x/10/10/10/10%10;  
  24.             //按照要求进行判断即可  
  25.             if((ge==wan) && (shi==qian) && (ge+shi+qian+wan==bai)) {  
  26.                 System.out.println(x);  
  27.             }  
  28.         }  
  29.     }  
  30. }

运行结果：

Java语法基础-2 - 图11

2.4 while循环语句格式

基本格式

  1. while(判断条件语句) {
  2.       循环体语句;
  3. }

扩展格式

  1. 初始化语句;
  2. while(判断条件语句) {
  3.       循环体语句;
  4.       控制条件语句;
  5. }

Java语法基础-2 - 图12

循环结构(for循环和while循环的区别)：

for循环语句和while循环语句可以等价转换，但还是有些小区别的

  • 使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
  • 场景区别：for循环适合针对一个范围判断进行操作,while循环适合判断次数不明确操作
  1. /*
  2.     练习：用while循环实现
  3.     左边：求出1-100之和
  4.     右边：统计水仙花数有多少个
  6.     初始化语句;
  7.     while(判断条件语句) {
  8.          循环体语句;
  9.          控制条件语句;
  10.     }
  14.     for(初始化语句;判断条件语句;控制条件语句) {
  15.         循环体语句;
  16.     }
  18. */  
  19. class WhileDemo2 {  
  20.     public static void main(String[] args) {  
  21.         //求出1-100之和  
  22.         //for语句版本  
  23.         int sum = 0;  
  25.         for(int x=1; x<=100; x++) {  
  26.             sum+=x;  
  27.         }  
  29.         System.out.println("sum:"+sum);  
  30.         System.out.println("--------");  
  31.         //while语句版本  
  32.         int sum2 = 0;  
  34.         int y=1;  
  35.         while(y<=100) {  
  36.             sum2+=y;  
  37.             y++;  
  38.         }  
  40.         System.out.println("sum2:"+sum2);  
  41.         System.out.println("--------");  
  42.     }  
  43. }

运行结果：

Java语法基础-2 - 图13

  1. /*
  2.     需求：统计水仙花数有多少个
  3. */  
  4. class WhileDemo3 {  
  5.     public static void main(String[] args) {  
  6.         //for循环版本  
  7.         int count = 0;  
  9.         for(int x=100; x<1000; x++) {  
  10.             int ge = x%10;  
  11.             int shi = x/10%10;  
  12.             int bai = x/10/10%10;  
  14.             if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {  
  15.                 count++;  
  16.             }  
  17.         }  
  19.         System.out.println("count:"+count);  
  20.         System.out.println("------------");  
  22.         //while循环版本  
  23.         int count2 = 0;  
  25.         int y = 100;  
  26.         while(y<1000) {  
  27.             int ge = y%10;  
  28.             int shi = y/10%10;  
  29.             int bai = y/10/10%10;  
  31.             if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == y) {  
  32.                 count2++;  
  33.             }  
  35.             y++;  
  36.         }  
  38.         System.out.println("count2:"+count2);  
  39.     }  
  40. }

运行结果：

Java语法基础-2 - 图14

2.4 while循环和for循环的区别?

使用区别：如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用for循环。因为变量及早的从内存中消失，可以提高内存的使用效率。

其实还有一种场景的理解:
如果是一个范围的，用for循环非常明确。
如果是不明确要做多少次，用while循环较为合适。举例：吃葡萄。

  1. class WhileDemo4 {  
  2.     public static void main(String[] args) {  
  3.         //for循环实现  
  4.         for(int x=0; x<10; x++) {  
  5.             System.out.println("学习Java技术哪家强,中国北京传智播客");  
  6.         }  
  7.         //这里不能在继续访问了  
  8.         //System.out.println(x);  
  10.         //while循环实现  
  11.         int y = 0;  
  12.         while(y<10) {  
  13.             System.out.println("学习Java技术哪家强,中国北京传智播客");  
  14.             y++;  
  15.         }  
  16.         //这里是可以继续访问的  
  17.         System.out.println(y);  
  18.     }  
  19. }

2.5 do…while循环语句格式

基本格式

  1. do {
  2.       循环体语句;
  3. }while((判断条件语句);

扩展格式

  1. 初始化语句;
  2. do {
  3.      循环体语句;
  4.      控制条件语句;
  5. } while((判断条件语句);

Java语法基础-2 - 图15

注意死循环：

A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
B:两种最简单的死循环格式

  1. while(true){...}
  2. for(;;){...}

2.6 循环嵌套

代码示例：九九表

  1. /*
  2.     需求：在控制台输出九九乘法表。
  4.     首先我们写出九九乘法表：
  5.         1*1=1
  6.         1*2=2   2*2=4
  7.         1*3=3   2*3=6   3*3=9
  8.         1*4=4   2*4=8   3*4=12  4*4=16
  9.         ...
  10.         1*9=9   2*9=18  3*9=27  ...
  12.     我们先把这个九九乘法表看出是这样的一个形状：
  13.         *
  14.         **
  15.         ***
  16.         ****
  17.         *****
  18.         ******
  19.         *******
  20.         ********
  21.         *********
  23.     注意：
  24.         'x' x表示任意，这种做法叫转移字符。
  26.         't'    tab键的位置
  27.         'r'    回车
  28.         'n'    换行
  29. */  
  30. class ForForDemo3 {  
  31.     public static void main(String[] args) {  
  32.         for(int x=0; x<9; x++) {  
  33.             for(int y=0; y<=x; y++) {  
  34.                 System.out.print("*");  
  35.             }  
  36.             System.out.println();  
  37.         }  
  38.         System.out.println("--------------");  
  39.         //为了使用数据，我们从1开始  
  40.         for(int x=1; x<=9; x++) {  
  41.             for(int y=1; y<=x; y++) {  
  42.                 System.out.print(y+"*"+x+"="+y*x+"t");  
  43.             }  
  44.             System.out.println();  
  45.         }  
  46.     }  
  47. }

运行结果：

Java语法基础-2 - 图16

2.7 跳转控制语句

Java中的goto是保留字，目前不能使用。虽然没有goto语句可以增强程序的安全性，但是也带来很多不便，比如说，我想在某个循环知道到某一步的时候就结束，现在就做不了这件事情。为了弥补这个缺陷，Java就提供了break，continue和return来实现控制语句的跳转和中断。

break 中断、continue 继续、return 返回

2.7.1 break的使用场景

  • 在选择结构switch语句中
  • 在循环语句中
  • 离开使用场景的存在是没有意义的

2.7.2 break的作用

  • 跳出单层循环
  • 跳出多层循环
    带标签的跳出
    格式：标签名: 循环语句
    标签名要符合Java的命名规则
  1. /*
  2.     控制跳转语句：
  3.         break:中断
  4.         continue:继续
  5.         return:返回
  7.     break:中断的意思
  8.     使用场景：
  9.         A:switch语句中
  10.         B:循环语句中。
  11.             (循环语句中加入了if判断的情况)
  12.         注意：离开上面的两个场景，无意义。
  14.     如何使用呢?
  15.         A:跳出单层循环
  16.         B:跳出多层循环
  17.             要想实现这个效果，就必须知道一个东西。带标签的语句。
  18.             格式：
  19.                 标签名: 语句
  20. */  
  21. class BreakDemo {  
  22.     public static void main(String[] args) {  
  23.         //在 switch 或 loop 外部中断  
  24.         //break;  
  26.         //跳出单层循环  
  27.         for(int x=0; x<10; x++) {  
  28.             if(x == 3) {  
  29.                 break;  
  30.             }  
  31.             System.out.println("HelloWorld");  
  32.         }  
  34.         System.out.println("over");  
  35.         System.out.println("-------------");  
  37.         wc:for(int x=0; x<3; x++) {  
  38.             nc:for(int y=0; y<4; y++) {  
  39.                 if(y == 2) {  
  40.                     //break nc;  
  41.                     break wc;  
  42.                 }  
  43.                 System.out.print("*");  
  44.             }  
  45.             System.out.println();  
  46.         }  
  47.     }  
  48. }

2.7.3 continue的使用场景

  • 在循环语句中
  • 离开使用场景的存在是没有意义的

2.7.4 continue的作用

  • 单层循环对比break，然后总结两个的区别
    • break 退出当前循环
    • continue 退出本次循环
  • 也可以带标签的使用
  1. /*
  2.     continue:继续
  4.     使用场景：
  5.         循环中。离开此场景无意义。
  7.     测试，找到和break的区别：
  8.         break:跳出单层循环
  9.         continue:跳出一次循环，进入下一次的执行
  11.     练习题：
  12.         for(int x=1; x<=10; x++) {
  13.             if(x%3==0) {
  14.                 //在此处填写代码
  15.             }
  16.             System.out.println(“Java基础班”);
  17.         }
  19.         我想在控制台输出2次:“Java基础班“
  20.             break;
  21.         我想在控制台输出7次:“Java基础班“
  22.             continue;
  23.         我想在控制台输出13次:“Java基础班“    
  24.             System.out.println(“Java基础班”);
  27. */  
  28. class ContinueDemo {  
  29.     public static void main(String[] args) {  
  30.         for(int x=0; x<10; x++) {  
  31.             if(x == 3) {  
  32.                 //break;  
  33.                 continue;  
  34.             }  
  36.             System.out.println(x);  
  37.         }  
  38.     }  
  39. }

2.7.5 return关键字

不是为了跳转出循环体，更常用的功能是结束一个方法，也就是退出一个方法。跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解

  1. /*
  2.     return:返回
  4.     其实它的作用不是结束循环的，而是结束方法的。
  5. */  
  6. class ReturnDemo {  
  7.     public static void main(String[] args) {  
  8.         for(int x=0; x<10; x++) {  
  9.             if(x == 2) {  
  10.                 System.out.println("退出");  
  11.                 //break;  
  12.                 //continue;  
  13.                 return;  
  14.             }  
  16.             System.out.println(x);  
  17.         }  
  19.         System.out.println("over");  
  20.     }  
  21. }

3. 方法

3.1 方法概述

假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要发射炮弹时调用该方法即可。

3.2 方法定义及格式

1、简单的说：方法就是完成特定功能的代码块
在很多语言里面都有函数的定义，函数在Java中被称为方法
2、格式：

  1. 修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
  2.      函数体;
  3.      return 返回值;
  4.  }

3.3 方法格式解释

  • 修饰符 比较多，后面会详细介绍。目前public static
  • 返回值类型 用于限定返回值的数据类型
  • 方法名 一个名称，为了方便我们调用方法
  • 参数类型 限定调用方法时传入参数的数据类型
  • 参数名 是一个变量，接收调用方法时传入的参数
  • 方法体 完成功能的代码
  • return 结束方法以及返回方法指定类型的值
  • 返回值 程序被return带回的结果，返回给调用者

3.4 有明确返回值的方法调用

  • 单独调用，没有意义
  • 输出调用，有意义，但是不够好，因为我不一定非要把结果输出
  • 赋值调用，推荐方式

注意事项：

  • 方法不调用不执行
  • 方法与方法是平级关系，不能嵌套定义
  • 方法定义的时候参数之间用逗号隔开
  • 方法调用的时候不用在传递数据类型
  • 如果方法有明确的返回值，一定要有return带回一个值

3.5 没有明确返回值的函数调用

  • 其实就是void类型方法的调用
  • 只能单独调用

3.6 方法调用图解

Java语法基础-2 - 图17

3.7 方法重载

  • 方法重载概述

    在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

  • 方法重载特点

    与返回值类型无关，只看方法名和参数列表
    在调用时，虚拟机通过参数列表的不同来区分同名方法

  1. /*
  2.     比较两个数据是否相等。参数类型分别为
  3.         两个byte类型，两个short类型，两个int类型，两个long类型，
  4.     并在main方法中进行测试
  5. */  
  6. class FunctionTest6 {  
  7.     public static void main(String[] args) {  
  8.         //测试  
  9.         byte b1 = 3;  
  10.         byte b2 = 4;  
  11.         System.out.println("byte:"+compare(b1,b2));  
  13.         //测试  
  14.         short s1 = 5;  
  15.         short s2 = 5;  
  16.         System.out.println("short:"+compare(s1,s2));  
  18.         //后面的两个自己测试  
  19.     }  
  21.     //byte类型  
  22.     public static boolean compare(byte a,byte b) {  
  23.         System.out.println("byte");  
  24.         return a == b;  
  25.     }  
  27.     //short类型  
  28.     public static boolean compare(short a,short b) {  
  29.         System.out.println("short");  
  30.         return a == b;  
  31.     }  
  33.     //int类型  
  34.     public static boolean compare(int a,int b) {  
  35.         System.out.println("int");  
  36.         return a == b;  
  37.     }  
  39.     //long类型  
  40.     public static boolean compare(long a,long b) {  
  41.         System.out.println("long");  
  42.         return a == b;  
  43.     }  
  44. }

运行结果：

Java语法基础-2 - 图18

4. 数组

4.1 数组概述

需求：现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。为了解决这种问题，Java就提供了数组供我们使用

那么数组到底是什么呢?有什么特点呢?通过上面的分析：我们可以得到如下两句话：

  • 数组是存储多个变量(元素)的东西(容器)
  • 这多个变量的数据类型要一致

4.2 数组概念

  • 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器
  • 数组既可以存储基本数据类型，也可以存储引用数据类型

4.3 数组的定义格式

格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];
注意：这两种定义做完了，数组中是没有元素值的

4.4 数组初始化概述：

  • Java中的数组必须先初始化,然后才能使用
  • 所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值
  • 数组的初始化方式
    • 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
    • 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度
  • 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值

格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例：int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

4.5 Java中的内存分配

Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

  • 栈 存储局部变量
  • 堆 存储new出来的东西
  • 方法区 (面向对象部分讲)
  • 本地方法区 (和系统相关)
  • 寄存器 (给CPU使用)

Java语法基础-2 - 图19

4.6 Java中数组的内存图解

图解1：定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。

Java语法基础-2 - 图20

图解2：定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。

Java语法基础-2 - 图21

图解3：定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素。

Java语法基础-2 - 图22

4.7 数组的初始化

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例：int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
其实这种写法还有一个简化的写法：int[] arr = {1,2,3};

4.8 数组操作常见的两个小问题

  • ArrayIndexOutOfBoundsException 数组索引越界
    访问到了数组中的不存在的索引时发生
  • NullPointerException 空指针异常
    数组引用没有指向实体，却在操作实体中的元素时。

4.9 二维数组概述

二维数组概述

我们传智播客的Java基础班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个Java基础班。这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用。由此可见：其实二维数组其实就是一个元素为一维数组的数组。

二维数组定义格式
（1）格式1

  1. 数据类型[][] 变量名 = new 数据类型[m][n];
  2. // m表示这个二维数组有多少个一维数组
  3. // n表示每一个一维数组的元素个数

举例：

  1. int[][] arr = new int[3][2];
  2. // 定义了一个二维数组arr
  3. // 这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
  4. // 每个一维数组有2个元素，可以通过arr[m][n]来获取
  5. // 表示获取第m+1个一维数组的第n+1个元素

（2）格式2

  1. 数据类型[][] 变量名 = new 数据类型[m][];
  2. // m表示这个二维数组有多少个一维数组
  3. // 这一次没有直接给出一维数组的元素个数，可以动态的给出。

举例：

  1. int[][] arr = new int[3][];
  2. arr[0] = new int[2];
  3. arr[1] = new int[3]
  4. arr[2] = new int[1];

（3）格式3

  1. 数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
  2. 简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
  3. 举例：int[][] arr =  {{1,2,3},{4,6},{6}};

4.10 数组常见操作

4.10.1 数组遍历

  1. /*
  2.     数组遍历：就是依次输出数组中的每一个元素。
  4.     注意：数组提供了一个属性length，用于获取数组的长度。
  5.           格式：数组名.length
  6. */  
  7. class ArrayTest {  
  8.     public static void main(String[] args) {  
  9.         //定义数组  
  10.         int[] arr = {11,22,33,44,55};  
  12.         //获取每一个元素  
  13.         //如何获取呢?我们知道数组名结合编号(索引)就可以找到数据  
  14.         for(int x=0; x<5; x++) {  
  15.             //x=0,1,2,3,4  
  16.             System.out.println(arr[x]);  
  17.         }  
  18.         System.out.println("--------------------");  
  20.         //从0开始我们是明确的，但是为什么到5呢，我们是数了一下数组的个数  
  21.         //继续看下个数组如何遍历  
  22.         int[] arr2 = {1,2,3,4,5,6,7,8,9,10,11,2,2,3,4,5,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8};  
  23.         //而我们在很多时候，数组的元素不能靠数  
  24.         //这个时候，数组就给我们提供了一个属性：length专门用于获取数组的长度  
  25.         //格式：数组名.length 返回数组的长度  
  26.         System.out.println(arr.length);  
  27.         System.out.println(arr2.length);  
  28.         System.out.println("--------------------");  
  30.         //改进第一个程序  
  31.         for(int x=0; x<arr.length; x++) {  
  32.             System.out.println(arr[x]);  
  33.         }  
  34.         System.out.println("--------------------");  
  36.         //我们如果想要对多个数组进行遍历，每个数组的遍历我们都把代码写一遍，麻烦不  
  37.         //麻烦，所以，我们准备用方法改进。  
  38.         //用方法改进后，请调用  
  39.         printArray(arr);  
  40.         System.out.println("--------------------");  
  41.         printArray(arr2);  
  42.         System.out.println("--------------------");  
  43.         printArray2(arr);  
  44.     }  
  46.     /*
  47.         遍历数组的方法
  49.         两个明确：
  50.             返回值类型：void
  51.             参数列表：int[] arr
  52.     */  
  53.     public static void printArray(int[] arr) {  
  54.         for(int x=0; x<arr.length; x++) {  
  55.             System.out.println(arr[x]);  
  56.         }  
  57.     }  
  59.     //请看改进版本  
  60.     public static void printArray2(int[] arr) {  
  61.         System.out.print("[");  
  62.         for(int x=0; x<arr.length; x++) {  
  63.             if(x == arr.length-1) { //这是最后一个元素  
  64.                 System.out.println(arr[x]+"]");  
  65.             }else {  
  66.                 System.out.print(arr[x]+", ");  
  67.             }  
  68.         }  
  69.     }  
  70. }

4.10.2 获取数组最值

  1. /*
  2.     数组获取最值(获取数组中的最大值最小值)
  4.     分析：
  5.         A:定义一个数组，并对数组的元素进行静态初始化。
  6.         B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。
  7.         C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
  8.         D:最后参照物里面保存的就是最大值。
  9. */  
  10. class ArrayTest2 {  
  11.     public static void main(String[] args) {  
  12.         //定义一个数组  
  13.         int[] arr = {34,98,10,25,67};  
  15.         //请获取数组中的最大值  
  16.         /*
  17.         //从数组中任意的找一个元素作为参照物
  18.         int max = arr[0];
  19.         //然后遍历其他的元素
  20.         for(int x=1; x<arr.length; x++) {
  21.             //依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
  22.             if(arr[x] > max) {
  23.                 max = arr[x];
  24.             }
  25.         }
  26.         //最后参照物里面保存的就是最大值。
  27.         System.out.println("max:"+max);
  28.         */  
  30.         //把这个代码用方法改进  
  31.         //调用方法  
  32.         int max = getMax(arr);  
  33.         System.out.println("max:"+max);  
  35.         //请获取数组中的最小值  
  36.         int min = getMin(arr);  
  37.         System.out.println("min:"+min);  
  38.     }  
  40.     /*
  41.         需求：获取数组中的最大值
  42.         两个明确：
  43.             返回值类型：int
  44.             参数列表：int[] arr
  45.     */  
  46.     public static int getMax(int[] arr) {  
  47.         //从数组中任意的找一个元素作为参照物  
  48.         int max = arr[0];  
  49.         //然后遍历其他的元素  
  50.         for(int x=1; x<arr.length; x++) {  
  51.             //依次获取和参照物进行比较，如果大就留下来，如果小，就离开。  
  52.             if(arr[x] > max) {  
  53.                 max = arr[x];  
  54.             }  
  55.         }  
  56.         //最后参照物里面保存的就是最大值。  
  57.         return max;  
  58.     }  
  60.     public static int getMin(int[] arr) {  
  61.         //从数组中任意的找一个元素作为参照物  
  62.         int min = arr[0];  
  63.         //然后遍历其他的元素  
  64.         for(int x=1; x<arr.length; x++) {  
  65.             //依次获取和参照物进行比较，如果小就留下来，如果大，就离开。  
  66.             if(arr[x] < min) {  
  67.                 min = arr[x];  
  68.             }  
  69.         }  
  70.         //最后参照物里面保存的就是最小值。  
  71.         return min;  
  72.     }  
  73. }

运行结果：

Java语法基础-2 - 图23

4.10.3 数组元素逆序

  1. /*
  2.     数组元素逆序 (就是把元素对调)
  4.     分析：
  5.         A:定义一个数组，并进行静态初始化。
  6.         B:思路
  7.             把0索引和arr.length-1的数据交换
  8.             把1索引和arr.length-2的数据交换
  9.             ...
  10.             只要做到arr.length/2的时候即可。
  11. */  
  12. class ArrayTest3 {  
  13.     public static void main(String[] args) {  
  14.         //定义一个数组，并进行静态初始化。  
  15.         int[] arr = {12,98,50,34,76};  
  17.         //逆序前  
  18.         System.out.println("逆序前：");  
  19.         printArray(arr);  
  21.         //逆序后  
  22.         System.out.println("逆序后：");  
  23.         //reverse(arr);  
  24.         reverse2(arr);  
  25.         printArray(arr);  
  26.     }  
  28.     /*
  29.         需求：数组逆序
  30.         两个明确：
  31.             返回值类型：void (有人会想到应该返回的是逆序后的数组，但是没必要，因为这两个数组其实是同一个数组)
  32.             参数列表：int[] arr
  33.     */  
  34.     public static void reverse(int[] arr) {  
  35.         /*
  36.         //第一次交换
  37.         int temp = arr[0];
  38.         arr[0] = arr[arr.length-1-0];
  39.         arr[arr.length-1-0] = temp;
  41.         //第二次交换
  42.         int temp = arr[1];
  43.         arr[1] = arr[arr.length-1-1];
  44.         arr[arr.length-1-1] = temp;
  46.         //第三次交换
  47.         int temp = arr[2];
  48.         arr[2] = arr[arr.length-1-2];
  49.         arr[arr.length-1-2] = temp;
  50.         */  
  51.         //用循环改进  
  52.         for(int x=0; x<arr.length/2; x++) {  
  53.             int temp = arr[x];  
  54.             arr[x] = arr[arr.length-1-x];  
  55.             arr[arr.length-1-x] = temp;  
  56.         }  
  57.     }  
  59.     public static void reverse2(int[] arr) {  
  60.         for(int start=0,end=arr.length-1; start<=end; start++,end--) {  
  61.             int temp = arr[start];  
  62.             arr[start] = arr[end];  
  63.             arr[end] = temp;  
  64.         }  
  65.     }  
  67.     //遍历数组  
  68.     public static void printArray(int[] arr) {  
  69.         System.out.print("[");  
  70.         for(int x=0; x<arr.length; x++) {  
  71.             if(x == arr.length-1) { //这是最后一个元素  
  72.                 System.out.println(arr[x]+"]");  
  73.             }else {  
  74.                 System.out.print(arr[x]+", ");  
  75.             }  
  76.         }  
  77.     }  
  78. }

运行结果：

Java语法基础-2 - 图24

4.10.4 数组基本查找

  1. /*
  2.     需求：数组元素查找(查找指定元素第一次在数组中出现的索引)
  4.     分析：
  5.         A:定义一个数组，并静态初始化。
  6.         B:写一个功能实现
  7.             遍历数组，依次获取数组中的每一个元素，和已知的数据进行比较
  8.             如果相等，就返回当前的索引值。
  9. */  
  10. class ArrayTest5 {  
  11.     public static void main(String[] args) {  
  12.         //定义一个数组，并静态初始化  
  13.         int[] arr = {200,250,38,888,444};  
  15.         //需求：我要查找250在这个数组中第一次出现的索引  
  16.         int index = getIndex(arr,250);  
  17.         System.out.println("250在数组中第一次出现的索引是："+index);  
  19.         int index2 = getIndex2(arr,250);  
  20.         System.out.println("250在数组中第一次出现的索引是："+index2);  
  22.         int index3 = getIndex2(arr,2500);  
  23.         System.out.println("2500在数组中第一次出现的索引是："+index3);  
  24.     }  
  26.     /*
  27.         需求：查找指定数据在数组中第一次出现的索引
  28.         两个明确：
  29.             返回值类型：int
  30.             参数列表：int[] arr,int value
  31.     */  
  32.     public static int getIndex(int[] arr,int value) {  
  33.         //遍历数组，依次获取数组中的每一个元素，和已知的数据进行比较  
  34.         for(int x=0; x<arr.length; x++) {  
  35.             if(arr[x] == value) {  
  36.                 //如果相等，就返回当前的索引值。  
  37.                 return x;  
  38.             }  
  39.         }  
  41.         //目前的代码有一个小问题  
  42.         //就是假如我要查找的数据在数组中不存在，那就找不到，找不到，你就对应的返回吗?  
  43.         //所以报错。  
  45.         //只要是判断，就可能是false，所以大家要细心。  
  48.         //如果找不到数据，我们一般返回一个负数即可，而且是返回-1  
  49.         return -1;  
  50.     }  
  52.     public static int getIndex2(int[] arr,int value) {  
  53.         //定义一个索引  
  54.         int index = -1;  
  56.         //有就修改索引值  
  57.         for(int x=0; x<arr.length; x++) {  
  58.             if(arr[x] == value) {  
  59.                 index = x;  
  60.                 break;  
  61.             }  
  62.         }  
  64.         //返回index  
  65.         return index;  
  66.     }  
  67. }

运行结果：

Java语法基础-2 - 图25

4.11 随机点名器

  1. package cn.itcast.chapter02.task03;
  2. import java.util.Random;
  3. import java.util.Scanner;
  4. /**
  5.  * 随机点名器
  6.  */
  7. public class CallName {
  8.     /**
  9.      * 1.存储全班同学姓名 创建一个存储多个同学姓名的容器（数组） 键盘输入每个同学的姓名，存储到容器中（数组）
  10.      */
  11.     public static void addStudentName(String[] students) {
  12.         // 键盘输入多个同学姓名存储到容器中
  13.         Scanner sc = new Scanner(System.in);
  14.         for (int i = 0; i < students.length; i++) {
  15.             System.out.println("存储第" + (i + 1) + "个姓名：");
  16.             // 接收控制台录入的姓名字符串
  17.             students[i] = sc.next();
  18.         }
  19.     }
  21.     /**
  22.      * 2.总览全班同学姓名
  23.      */
  24.     public static void printStudentName(String[] students) {
  25.         // 遍历数组，得到每个同学姓名
  26.         for (int i = 0; i < students.length; i++) {
  27.             String name = students[i];
  28.             // 打印同学姓名
  29.             System.out.println("第" + (i + 1) + "个学生姓名：" + name);
  30.         }
  31.     }
  33.     /**
  34.      * 3.随机点名其中一人
  35.      */
  36.     public static String randomStudentName(String[] students) {
  37.         // 根据数组长度，获取随机索引
  38.         int index = new Random().nextInt(students.length);
  39.         // 通过随机索引从数组中获取姓名
  40.         String name = students[index];
  41.         // 返回随机点到的姓名
  42.         return name;
  43.     }
  45.     public static void main(String[] args) {
  46.         System.out.println("--------随机点名器--------");
  47.         // 创建一个可以存储多个同学姓名的容器（数组）
  48.         String[] students = new String[3];
  49.         /*
  50.          * 1.存储全班同学姓名
  51.          */
  52.         addStudentName(students);
  53.         /*
  54.          * 2.总览全班同学姓名
  55.          */
  56.         printStudentName(students);
  57.         /*
  58.          * 3.随机点名其中一人
  59.          */
  60.         String randomName = randomStudentName(students);
  61.         System.out.println("被点到名的同学是 :" + randomName);
  62.     }
  63. }
免责声明： 以上内容版权归原作者所有，如有侵犯您的原创版权请告知，我们将尽快删除相关内容。感谢每一位辛勤著写的作者，感谢每一位的分享。
@小牛知识库 xnip.cn