Java语言基础（二）---程序流程控制语句、函数
来源：互联网 发布：阿里伯克 052d数据对比 编辑：程序博客网 时间：2024/05/16 05:52
Java语言基础组成：关键字、标识符、注释、常量和变量、运算符、语句、函数、数组
一. 程序流程控制语句
1. 顺序结构：
简单的语句都是顺序结构的。
2. 判断结构：
【if 语句定义】 （1） if（条件表达式）{
执行语句;
} （2） if（条件表达式）
{
执行语句;
}
else
{
执行语句;
} （3） if（条件表达式）
{
执行语句;
}
else if（条件表达式）
{
执行语句;
}
else
{
执行语句;
} 【if-else 语句 与 三元表达式区别】
- 三元运算符：
好处：可以简化if-else代码
弊端：因为是一个运算符，所以运算完后必须要有结果
【实例】: int a = 3, b;
b = a > 2 ? System.out.println(“haha”) : a; // 是错误的！
- if-else 语句： 运算完后不一定有结果
【实例 1】：根据用户定义的数值不同，打印对应的星期英文
int num = 2;if(num == 1){ System.out.println("Monday");}else if(num == 2){ System.out.println("Tuesday")}else if(num == 3){ System.out.println("Wednesday")}else if(num == 4){ System.out.println("Thursday")}else if(num == 5){ System.out.println("Friday")}else if(num == 6){ System.out.println("Saturday")}else if(num == 7){ System.out.println("Sunday")}else{ System.out.println("nono");}【实例 2】：根据用户指定月份，打印该月份所属的季节（3,4,5春季；6,7,8夏季；9,10,11秋季；12,1,2冬季）
（【注】见switch进行改写）
int x = 4;if(x > 12 || x < 1){ //一定要先对数据进行判断，只有正确的数值才能进行相应的处理，非正确的数值应该人性化地提示用户。 System.out.println("月份不存在"); }else if(x >= 3 && x <= 5){ System.out.println("春季");}else if(x >= 6 && x <= 8){ System.out.println("夏季");}else if(x >= 9 && x <= 11){ System.out.println("秋季");}else{ System.out.println("冬季");}3. 选择结构：
【switch 语句定义】 switch（表达式）{
case 取值1 :
执行语句;
break;
……
default :
执行语句;
break;
}
- 表达式类型：
byte，short，int，char，Enum（枚举），
JDK1.7增加了对字符串的判断。但是不支持long。
- case 取值1 :
case： 定义备选答案，没有顺序的，可以随便排列，
定义位置可 随性。
取值1： 答案的具体内容。
- default： 默认，default最后的break可以不用写。
若default放在case前，在读取时，也先读取case，
再最后读取default。
- if-else： 能判断具体数值，区间，boolean型
- switch：判断区间很费劲，要全部写出来，并且不能判断boolean型。
- 如果进行具体数值判断，数值不多用switch（因为switch效率稍高）
- 对区间判断，对结果为boolean型判断，使用if（if的使用范围广）
【实例 1】：分析代码执行结果
int x = 3; switch(x) { default : System.out.println(“d”); case 4 : System.out.println(“a”); case 6: System.out.println(“b”); break; case 2: System.out.println(“c”); break; } //结果为：d(回车)a(回车)b(回车) //分析为：第一次读取时，case都没有符合，读到default，执行后既没有break也没有大括号（}）， // 那么继续向下执行，而不再进行判断case，把下面能执行的都执行完，直到碰到break或大括号（}）。【实例 2】：根据用户指定月份，打印该月份所属的季节（3,4,5春季；6,7,8夏季；9,10,11秋季；12,1,2冬季）
（【注】对上面的if-case进行改写）
int x = 4;switch(x){ case 3: case 4: case 5: //多个答案对应同个内容，同个执行语句 System.out.println("春季");break; case 6: case 7: case 8: System.out.println("夏季");break; case 9: case 10: case 11: System.out.println("秋季");break; default: System.out.println("月份不存在"); }4. 循环结构：
当要对某些语句执行很多次，就使用循环结构。
while while（条件表达式）{
循环体;
}
【while 与 do-while 区别】
- while： 先判断条件，只有条件满足才执行循环体
- do-while：先执行循环体，再判断条件，
条件满足，再执行循环体。
do-while：无论条件是否满足，循环体至少执行一次。 do-while do
{
循环体;
}while（条件表达式）；
for for（初始化表达式; 循环条件; 循环后的操作表达式）
{
执行语句;
}
【for 语句特点】
- 初始化表达式只参与1次
- 只要条件不满足，跳出循环
【for 语句中变量的作用域】
[e.g.] for( int x = 0; x
变量x只在for语句中有效，离开{ } ，x在内存中消失了，
即for语句结束后，x在内存中消失了
【for与 while 区别】
- 如果需要定义循环增量，用for更适合
【无限循环的最简单表现形式】
- for( ; ; ){ } //循环条件默认为true
- while(true){ }
【实例 1】：分析下面的代码
int x = 1;for(System.out.println("a"); x < 3; System.out.println("b")){ System.out.println("c"); x++;}//结果为：a(回车)c(回车)b(回车)c(回车)b(回车)/*分析为：(1)【初始化表达式】：不一定要写成int x = 1; 只要是合法表达式就可以 (2)【循环条件】：循环条件表达式必须要有真假 (3)【循环后的操作表达式】：当表达式多时，用"，"隔开，可以写多条语句*//*【扩展】: for(int y = 0; y < 3; y++){ } => 可以改成： int y = 0; for(; y < 3;) //表达式可以为空 { y++; }*/【实例 2】：获取1~10的和，并打印
/*【累加思想】：sum += num; => 每次加的内容有可能不一样原理： 通过变量记录住循环操作后的结果， 一个数不断地变大或变小，以记录住每次变化的结果， 通过循环的形式进行累加动作，通常为累加一个变量或一个循环增量。 [e.g.] 字符串的不断延长*/int sum = 0;for(int num = 1; num <= 10; num++){ sum += num;}System.out.println("sum=" + sum);【实例 3】：1~100之间 7的倍数的个数，并打印。
/*【计数器思想】：count++; => 符合条件有多少个，立刻想到计数器原理： 通过一个变量记录住数据的状态变化，也需要通过循环完成。*///方法一：int count1 = 0;for(int i = 1; i <= 100; i++){ if(i % 7 == 0) { System.out.print("i=" + i + ' '); count1++; }}System.out.println("个数为：" + count1);//方法二：int multiplication = 7; //7的倍数值int count2 = 0;for(int i = 2; multiplication <= 100; i++){ count2++; System.out.print("mul=" + multiplication + ' '); multiplication = 7 * i; //更新7的倍数值}System.out.println("个数为：" + count2);【实例 4】：打印矩形
/*利用for循环嵌套打印图形*************************/ /** * 打印矩形 * @param x 行 * @param y 列 */ public static void printJuxing(int x,int y) { for(int n = 0; n < x; n++) //对于打印长方形，外循环控制行数 { for (int m = 0; m < y ; m++ ) //内循环控制的是每一行的列数，也就是一行中元素的个数 { System.out.print("*"); } System.out.println(); //用于换行 } }【实例 5】：打印倒直角三角形
/* 利用for循环嵌套，打印图形。 **** *** ** * 方法一： 思路： 1.因为for循环嵌套的，外循环是控制行数的，内循环是控制每一行的列数的。 2.行数为4，n由0开始，进行4次循环，n最大为3。 3.列数m不断地变小，第0行4个，第1次3个，由此可见，第n行为4-n。 补充： 第0行，m变化的区间为，0-4，共4个。 第1行，m变化的区间为，0-3，共3个。 第2行，m变化的区间为，0-2，共2个。 第n行，m变化的区间为，0-n，共n个。 所以m的初始值为0，m的条件为，m<4-n。 */ for(int n = 0; n < 4; n++) { for(int m = 0;m < 4 - n;m++) { System.out.print("*"); } System.out.println(); } System.out.println("------------------------"); /* 方法二： 思路：第0行，m变化的区间为，0-4，共4个。 第1行，m变化的区间为，1-4，共3个。 第2行，m变化的区间为，2-4，共2个。 第n行，m变化的区间为，n-4，共4-n个。 所以m的初始值在变化，m<4是不变的。 */ for(int n = 0; n < 4; n++ ) { for(int m = n; m < 4; m++) { System.out.print("*"); } System.out.println(); } System.out.println("------------------------");【实例 6】：打印顺直角三角形
/* 利用for循环嵌套，打印图形。 * ** *** **** 思路：1.因为for循环嵌套的，外循环是控制行数的，内循环是控制每一行的列数的。 2.行数为4，n由0开始，进行四次循环，n最大为3。 3.列数m不断增加，第0行1个，第1行2个，由此可见，第n行为n+1。 */ for(int n = 0; n < 4; n++) { for(int m = 0; m < n + 1; m++) { System.out.print("*"); } System.out.println(); }【打印三角形的规则】：
- 1. 尖朝上，可以改变条件，让条件随外循环变化
- 2. 尖朝下，可以改变初始值，让初始值随外循环变化
【实例 7】：按规则打印数字
/* 打印： 1 12 123 1234 12345 思路:尖朝上，改变条件。 */ for(int n = 1; n <= 5; n++) { for(int m = 1; m <= n; m++) { System.out.print(m); } System.out.println(); }【实例 8】：打印九九乘法表
/** 打印九九乘法表： 1*1=1 1*2=1 2*2=4 1*3=3 2*3=6 3*3=9 */ for (int n = 1; n <= 9 ; n++) { for(int m = 1; m <= n; m++) { System.out.print(m + "*" + n + "=" + ( m * n) + "\t"); } System.out.println(); }【实例 9】：打印等腰三角形
/* 打印。 ----* ---* * --* * * -* * * * * * * * * */ //方法一 for (int n = 1; n <= 5; n++ ) { for (int m = 5; m >= 1; m-- ) { if(m <= n) { System.out.print("* "); } else { System.out.print(" "); } } System.out.println(); } System.out.println("------------------------"); //方法二 for (int n = 0; n < 5 ; n++ ) { for (int m = n + 1; m < 5 ; m++ ) { System.out.print(" "); } for (int z = 0; z <= n ;z++ ) { System.out.print("* "); } System.out.println(); }5. 其他程序流程控制语句：
break（跳出） 【作用语句】：- switch
- 循环结构：用于跳出所在循环
【作用语句】： 只能用于循环结构：继续循环
【break，continue语句 注意事项】：
- 1. 都有自己的作用范围，离开了作用范围，是没有意义的。
- 2. 单独存在时，下面不可以有任何语句，因为执行不到。
【错误】：
for(int x = 0; x< 3; x++)
{
continue;
System.out.println(x); //continue下面不可以有任何语句
}
【正确】：
for(int x = 0; x< 3; x++)
{
if(x % 2 == 1);
continue;
System.out.println(x);
}
- 3. 使用标号：标号只能用于循环上，给循环起名字的一种方式。
【e.g. break】：
w: for(int x = 0; x< 3; x++)
{
q: for(int y = 0; y< 4; y++)
{
System.out.println(x);
break w; //直接跳出外围for循环，不写w，默认跳出内循环。
}
}
//结果为：0
【e.g. continue】：
w: for(int x = 0; x< 3; x++)
{
q: for(int y = 0; y< 4; y++)
{
System.out.println(x);
continue w; //直接跳出外围for循环，不写w，默认跳出内循环。
}
}
//结果为：0(回车)1(回车)2(回车)
二. 函数
1. 函数的定义：
函数就是定义在类中的具有特定功能的一段独立小程序，函数也成为方法。
【函数的格式】：修饰符 返回值类型 函数名（参数类型 形式参数1）
{
执行语句；
return 返回值；
}
- 【修饰符】：对函数进行外加功能的定义，
让函数具备更多含义 - 【函数名】：
1. 用于标识函数，方便调用
2. 用于通过这个名称，体现这个函数的功能
- 【返回值类型】：数据类型，即函数运行的结果
- 【参数类型 形式参数1】：1. 定义变量，
2. 多个参数用”,”隔开
- 【形式参数与实际参数的区别】：
1. 形式参数：是一个变量，用于存储调用函数时，
传递给函数的实际参数。
2. 实际参数：传递给形式参数的具体数值。
- 【return 返回值】：
1. return：用于结束函数
2. 谁调用返回给谁
为了提高代码的复用性，对代码进行抽取，将这个部分定义成一个独立的功能，方便日后使用，
Java中对功能的定义是通过函数的形式体现的。
【函数的注意点】：
1. 函数只有被调用才执行。
2. 函数放的位置：放在主函数上下都可以。
3. 函数中只能调用函数，不可以在函数内部定义函数，
定义函数时，函数的结果应该返回给调用者，由调用者处理。
【实例】：如何定义函数，调用函数的实例
public static void main(String[] args) { int x = getResult(4); //可以重用 System.out.println("x=" + 4); } public static int getResult(int num) //定义函数 { return num * 3 + 5; }2. 函数的特点：
【函数的特点】：
- 定义函数可以将功能代码进行封装。
- 便于对功能进行复用。
- 函数只有被调用才会执行。
- 函数的出现提高了代码的复用性。
- 当函数运算后，没有具体返回值时，这时返回值类型用一个特殊的关键字标识，该关键字就是void。
void 代表的是函数没有具体返回值的情况。
当函数的返回值类型是void时，函数中的return 可以省略不写，系统会自己加的。
3. 函数的应用：
我们编写程序，其实就是在不断地实现功能，Java中最小的功能单元就是函数，所以以后在写代码的时候，只要在处理或定义功能，都把它定义到独立的函数功能中去，而不要把代码换七八糟塞到主函数中，主函数的功能就只有一个，就是调用函数。
【如何定义函数？】：
- 明确返回值类型：既然函数是一个独立的功能，那么该功能的运算结果是什么就要先明确。
- 明确参数列表：再明确在定义该功能的过程中，是否需要未知的内容参与运算，即是否需要参数。
参数列表包括参数的类型和参数的个数。
【实例 1】：定义一个功能，完成 3 + 4 的运算，并将结果返回给调用者
public static void main(String[] args) { int sum = getSum(); System.out.println("sum=" + sum); } /** * 功能：计算 3 + 4 * @return 返回总数 */ public static int getSum() { return 3 + 4; }【实例 2】：为了方便用户需求，由用户来指定加数和被加数，这样功能才有意义
public static void main(String[] args) { int sum = getSum(3, 4); System.out.println("sum=" + sum); } /** * 功能：计算两数相加 * @return 返回总数 */ public static int getSum(int x, int y) { return x + y; }【实例 3】：判断两个数是否相同
public static void main(String[] args) { boolean num = compare(6,6); //比较两个值是否相等 if(num) System.out.println("相同"); else System.out.println("不相同"); } /** * 功能：判断两个数是否相同 * @return boolean值 */ public static boolean compare(int x, int y) { /* 方法一： if(x == y) return true; else return false; */ /* 方法二：三元运算符 return x == y ? true : false; */ //方法三：最简单的 return x == y; }【实例 4】：比较两个数，获取最大的数
public static void main(String[] args) { int max= getMax(4,6); //求最大值 System.out.println("最大值为：" + max); } /** * 功能：比较两个数，获取最大的数 * @return max */ public static int getMax(int x,int y) { return x > y ? x : y; }【实例 5】：查找出下面代码中，错误的定义思想
public static void main(String[] args) { System.out.println(getMax(4,6)); //[错误1] } /** * 功能：比较两个数，获取最大的数 */ public static void getMax(int x,int y) { System.out.println("最大值为：" + x > y ? x : y); //[错误2] } /*【错误分析】： [错误1]：getMax方法返回值类型为void时，输出语句不知道要输出什么，不能打印，直接调用就行了。 [错误2]：定义函数只要完成相对应的功能就好了，不要做过多的功能， 至于打印是由调用者来完成，不要在getMax功能中完成。 */【实例 6】：定义功能，用于打印矩形。
/* 定义功能，用于打印矩形。 思路：1.需要知道行数和列数。 2.不需要返回值。 */ public static void main(String[] args) { printJuxing(4, 6); } /** * 功能：用于打印矩形 * @param row 行 * @param col 列 */ public static void printJuxing(int row,int col) { for(int n = 0; n < row; n++) { for (int m = 0; m < col ; m++ ) { System.out.print("*"); } System.out.println(); } }【实例 7】：定义一个打印99乘法表功能的函数。
/* 定义一个打印99乘法表功能的函数。 思路：1.需要值。 2.不需要返回值，直接打印。 */ public static void main(String[] args) { mul(9); } /** * 功能：打印99乘法表功能的函数 * @param x 最大到几（例如9） */ public static void mul(int x) { for(int n = 1; n <= x; n++) { for (int m = 1; m <= n ; m++ ) { System.out.print( m + "*" + n + "=" + m * n + "\t"); } System.out.println(); } }4. 函数的重载：
在同一个类中，允许存在一个以上的同名函数，参数个数或者参数类型不同的同名函数就叫做重载。重载的特点：与返回值无关，只看参数列表。
当定义的功能相同，但参与运算的未知内容不同，那么，就定义一个相同的函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数。
【实例 1】：add方法出现了重载的形式，名称保证一致
public static void main(String[] args){ //功能一致，所以功能用的名字也一致 add(4, 5); add(4, 5, 6); //通过参数列表来区分调用哪个函数}public static int add(int a, int b){ return a + b;}public static int add(int a, int b, int c){ return a + b + c; //简化为：return add(a, b) + c; 提高代码的复用性。}【什么时候用重载？】
当定义的功能相同，但参与运算的未知内容不同，那么，这时就定义一个函数名称以表示其功能，方便阅读。而通过参数列表的不同来区分多个同名函数。
【实例 2】：定义一个打印99乘法表功能的函数。用重载，一个是自定义num，一个是标准的9；
public static void main(String[] args) { mul(8); //八八乘法表 mul(); //九九乘法表 } /** * 功能：自定义数值99乘法表 * @param x 最大到几（例如9） */ public static void mul(int x) { for(int n = 1; n <= x; n++) { for (int m = 1; m <= n ; m++ ) { System.out.print( m + "*" + n + "=" + m * n + "\t"); } System.out.println(); } } /** * 功能：标准版99乘法表 */ public static void mul() { mul(9); }【实例 3】：给定一个函数，比较下面有没有和它重载
void show(int a, char b, double c){}//原函数//[a]void show(int x, char y, double z){} //没有，因为和原函数一模一样//[b]int show(int a, double c, char b){}//重载了，因为参数类型不同，注意：重载和返回值类型无关，参数也是有顺序的//[c]void show(int a, double c, char b){} //重载了，参数是有顺序的//[d]boolean show(int c, char b){} //重载了，因为参数个数不同//[e]void show(double c){} //重载了，因为参数个数不同//[f]double show(int x, char y, double z){} //没有，参数一样，返回值虽然不同，但是不是重载，并且这个函数不允许和给定的函数 1 0
- Java语言基础（二）---程序流程控制语句、函数
- java基础（二）----流程控制语句跳转控制语句
- Java语言基础组成之：程序流程控制、函数、数组
- Java语言基础（二）——数据类型、运算符和流程控制语句
- Java语言基础-6.流程控制语句
- 第一篇：JAVA语言基础（第二章 语言基本语法、第三章 数组、第四章、程序流程控制语句）
- Java语言基础——贰（程序流程控制）
- 黑马程序员-----java基础（二）-----程序流程控制
- JAVA基础再回首（二）——流程控制语句、跳转控制语句
- Java学习日记（二）程序流程控制、函数、数组
- swift语言基础（二）流程控制
- JAVA基础（四）------流程控制语句
- Java基础（五）流程控制语句
- java流程控制语句(二)
- Java基础：流程控制语句
- Java基础----控制流程语句
- 黑马程序员——Java语言基础：程序流程控制、函数、数组
- Java基础知识点之函数和流程控制语句小结
- 工作周记
- 关于COIDE的各种小技巧
- 使用storyboard，设置tab bar Item的选中图片（selected Image）
- 记一次线程堵塞
- hdu 4353 Finding Mine 计算几何
- Java语言基础（二）---程序流程控制语句、函数
- JavaScript中的闭包
- 世纪末的星期
- OpenVPN不能在Android5.0（Lollipop）使用的问题分析
- 最大公约数
- 振兴中华
- 51Nod-点头网-1035 最长的循环节
- Apache Spark MLlib学习笔记（七）MLlib决策树类算法源码解析 3
- 欢迎使用CSDN-markdown编辑器
