黑马程序员——Java语言基础(二)---程序流程控制语句、函数
2015-04-10 20:57
761 查看
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-
Java语言基础组成:关键字、标识符、注释、常量和变量、运算符、语句、函数、数组
【实例 1】:根据用户定义的数值不同,打印对应的星期英文
【实例 2】:根据用户指定月份,打印该月份所属的季节(3,4,5春季;6,7,8夏季;9,10,11秋季;12,1,2冬季)
(【注】见switch进行改写)
【实例 1】:分析代码执行结果
【实例 2】:根据用户指定月份,打印该月份所属的季节(3,4,5春季;6,7,8夏季;9,10,11秋季;12,1,2冬季)
(【注】对上面的if-case进行改写)
【实例 1】:分析下面的代码
【实例 2】:获取1~10的和,并打印
【实例 3】:1~100之间 7的倍数的个数,并打印。
【实例 4】:打印矩形
【实例 5】:打印倒直角三角形
【实例 6】:打印顺直角三角形
【打印三角形的规则】:
1. 尖朝上,可以改变条件,让条件随外循环变化
2. 尖朝下,可以改变初始值,让初始值随外循环变化
【实例 7】:按规则打印数字
【实例 8】:打印九九乘法表
【实例 9】:打印等腰三角形
【实例】:如何定义函数,调用函数的实例
定义函数可以将功能代码进行封装。
便于对功能进行复用。
函数只有被调用才会执行。
函数的出现提高了代码的复用性。
当函数运算后,没有具体返回值时,这时返回值类型用一个特殊的关键字标识,该关键字就是void。
void 代表的是函数没有具体返回值的情况。
当函数的返回值类型是void时,函数中的return 可以省略不写,系统会自己加的。
【如何定义函数?】:
明确返回值类型:既然函数是一个独立的功能,那么该功能的运算结果是什么就要先明确。
明确参数列表:再明确在定义该功能的过程中,是否需要未知的内容参与运算,即是否需要参数。
参数列表包括参数的类型和参数的个数。
【实例 1】:定义一个功能,完成 3 + 4 的运算,并将结果返回给调用者
【实例 2】:为了方便用户需求,由用户来指定加数和被加数,这样功能才有意义
【实例 3】:判断两个数是否相同
【实例 4】:比较两个数,获取最大的数
【实例 5】:查找出下面代码中,错误的定义思想
【实例 6】:定义功能,用于打印矩形。
【实例 7】:定义一个打印99乘法表功能的函数。
当定义的功能相同,但参与运算的未知内容不同,那么,就定义一个相同的函数名称以表示其功能,方便阅读,而通过参数列表的不同来区分多个同名函数。
【实例 1】:add方法出现了重载的形式,名称保证一致
【什么时候用重载?】
当定义的功能相同,但参与运算的未知内容不同,那么,这时就定义一个函数名称以表示其功能,方便阅读。而通过参数列表的不同来区分多个同名函数。
【实例 2】:定义一个打印99乘法表功能的函数。用重载,一个是自定义num,一个是标准的9;
【实例 3】:给定一个函数,比较下面有没有和它重载
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-
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 语句: 运算完后不一定有结果 |
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。 |
【switch 与 if-else 区别】 if-else: 能判断具体数值,区间,boolean型 switch:判断区间很费劲,要全部写出来,并且不能判断boolean型。 | ||
【switch 与 if-else 如何选择】 如果进行具体数值判断,数值不多用switch(因为switch效率稍高) 对区间判断,对结果为boolean型判断,使用if(if的使用范围广) |
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 << 3; x++ ){ } 变量x只在for语句中有效,离开{ } ,x在内存中消失了, 即for语句结束后,x在内存中消失了 【for与 while 区别】 如果需要定义循环增量,用for更适合 【无限循环的最简单表现形式】 for( ; ; ){ } //循环条件默认为true while(true){ } |
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 循环结构:用于跳出所在循环 |
continue(跳出) | 【continue 的意思】: 结束本次循环,继续下一循环 【作用语句】: 只能用于循环结构:继续循环 |
【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){} //没有,参数一样,返回值虽然不同,但是不是重载,并且这个函数不允许和给定的函数
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-
相关文章推荐
- 黑马程序员——Java语言基础:程序流程控制、函数、数组
- 黑马程序员—Java语言基础(程序流程控制-if、switch、for、while、do while、break、continue)
- 黑马程序员 JAVA初级-编程基础2 流程控制语句 函数 数组
- 黑马程序员--java语言基础之--流程控制和函数
- 黑马程序员_java的语言基础组成进阶(对第三课程序流程控制的总结)
- 黑马程序员_java基础(2) 流程控制语句&函数与数组
- 黑马程序员——Java基础——程序流程控制、函数操作
- 黑马程序员--Java语言基础2-流程控制和函数
- 黑马程序员_01_Java语言基础部分(数据类型与表达式、流程控制语句、数组与方法)
- Java语言基础组成之:程序流程控制、函数、数组
- 黑马程序员 Java函数和程序流程控制
- Java基础知识点之函数和流程控制语句小结
- 黑马程序员_Java基础_进制转换、基本数据类型、运算符、流程控制语句等
- Java基础-->Java中的程序流程控制与函数
- 01_Java语言基础部分(数据类型与表达式、流程控制语句、数组与方法)
- Java基础——程序流程控制、函数与数组
- 黑马程序员——Java基础语法(二)---流程控制与函数
- 黑马程序员-iOS基础-C语言基础(三)流程控制及函数
- 黑马程序员_Java基础(流程控制、函数、数组)
- 学习笔记 Java_毕向东_语言基础_程序流程控制 2014.7.29