01_选择结构(switch语句)
1 /* 2 switch语句格式： 3 switch(表达式) { 4 case 值1: 5 语句体1; 6 break; 7 case 值2: 8 语句体2; 9 break; 10 ... 11 default: 12 语句体n+1; 13 break; 14 } 15 16 格式的解释： 17 switch:表示这是switch选择结构 18 表达式:这个地方的取值是有限定的 19 byte,short,int,char 20 JDK5以后可以是枚举 21 JDK7以后可以是字符串 22 case:后面跟的是要和表达式进行比较的值 23 语句体:要执行的代码 24 break:表示中断，结束的意思，可以控制switch语句的结束。 25 default:当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实它就相当于if语句的else。 26 27 面试题： 28 byte可以作为switch的表达式吗? 29 long可以作为switch的表达式吗? 30 String可以作为switch的表达式吗? 31 32 案例： 33 键盘录入一个数据，根据这个数据，我们输出对应的星期? 34 键盘录入1,对应输出星期一 35 键盘录入2,对应输出星期二 36 ... 37 键盘录入7,对应输出星期日 38 39 分析： 40 1:键盘录入，用Scanner实现 41 2:判断我们既可以使用if语句，也可以使用我们要讲解的switch语句 42 43 注意： 44 A:遇到左大括号缩进一个tab的位置。 45 B:关联不是很大的语句间空行 46 */ 47 import java.util.Scanner; 48 class SwitchDemo { 49 public static void main(String[] args) { 50 //创建键盘录入对象 51 Scanner sc = new Scanner(System.in); 52 53 //控制键盘录入数据 54 System.out.println("请输入一个数据(1-7):"); 55 int week = sc.nextInt(); //3 56 57 //switch判断语句 58 switch(week) { 59 case 1: 60 System.out.println("星期一"); 61 break; 62 case 2: 63 System.out.println("星期二"); 64 break; 65 case 3: 66 System.out.println("星期三"); 67 break; 68 case 4: 69 System.out.println("星期四"); 70 break; 71 case 5: 72 System.out.println("星期五"); 73 break; 74 case 6: 75 System.out.println("星期六"); 76 break; 77 case 7: 78 System.out.println("星期日"); 79 break; 80 default: 81 System.out.println("你输入的数据有误"); 82 break; 83 } 84 } 85 } 86 /* 87 switch语句的注意事项： 88 A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的 89 B:default可以省略吗? 90 可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。 91 特殊情况： 92 case就可以把值固定。 93 A,B,C,D 94 C:break可以省略吗? 95 可以省略，但是结果可能不是我们想要的。 96 会出现一个现象：case穿透。 97 最终我们建议不要省略 98 D:default一定要在最后吗? 99 不是，可以在任意位置。但是建议在最后。 100 E:switch语句的结束条件 101 a:遇到break就结束了 102 b:执行到末尾就结束了 103 */ 104 import java.util.Scanner; 105 106 class SwitchDemo2 { 107 public static void main(String[] args) { 108 //创建键盘录入对象 109 Scanner sc = new Scanner(System.in); 110 111 //控制键盘录入数据 112 System.out.println("请输入一个数据(1-7):"); 113 int week = sc.nextInt(); //3 114 115 //定义常量 116 //int number = 3; 117 //然后把case后面的值改为number，就会报错 118 119 //switch判断语句 120 switch(week) { 121 case 1: 122 System.out.println("星期一"); 123 break; 124 case 2: 125 System.out.println("星期二"); 126 break; 127 case 3: 128 System.out.println("星期三"); 129 break; 130 case 4: 131 System.out.println("星期四"); 132 break; 133 case 5: 134 System.out.println("星期五"); 135 break; 136 case 6: 137 System.out.println("星期六"); 138 break; 139 case 7: 140 System.out.println("星期日"); 141 break; 142 default: 143 System.out.println("你输入的数据有误"); 144 //break; 145 } 146 } 147 } 148 149 /* 150 看程序写结果 151 */ 152 class SwitchTest { 153 public static void main(String[] args) { 154 int x = 2; 155 int y = 3; 156 switch(x){ 157 default: 158 y++; 159 break; 160 case 3: 161 y++; 162 case 4: 163 y++; 164 } 165 System.out.println("y="+y); 166 System.out.println("---------------"); 167 168 int a = 2; 169 int b = 3; 170 switch(a){ 171 default: 172 b++; 173 case 3: 174 b++; 175 case 4: 176 b++; 177 } 178 System.out.println("b="+b); 179 } 180 } 181 182 /* 183 模拟单项选择题。 184 185 分析： 186 A:出一个选择题，然后供你选择。 187 B:键盘录入选择的数据。 188 C:根据选择来给出你选择的结论。 189 */ 190 import java.util.Scanner; 191 class SwitchTest2 { 192 public static void main(String[] args) { 193 //出一个选择题，然后供你选择。 194 //由于我们现在没有办法键盘录入得到一个'A','B' 195 //这样的东西，我就用65，66这样的值替代 196 //将来我们获取到这样的值以后，强制转换为字符类型 197 System.out.println("下面的几个人你最爱谁?"); 198 System.out.println("65 林青霞"); 199 System.out.println("66 张曼玉"); 200 System.out.println("67 刘德华"); 201 System.out.println("68 王力宏"); 202 //键盘录入选择的数据。 203 Scanner sc = new Scanner(System.in); 204 System.out.println("请输入你的选择："); 205 int choiceNumber = sc.nextInt(); 206 //强制转换为字符类型 207 char choice = (char) choiceNumber; 208 switch(choice) { 209 case 'A': 210 System.out.println("恭喜你,选择正确"); 211 break; 212 case 'B': 213 System.out.println("不好意思，你选择有误"); 214 break; 215 case 'C': 216 System.out.println("不好意思，你选择有误"); 217 break; 218 case 'D': 219 System.out.println("不好意思，你选择有误"); 220 break; 221 default: 222 System.out.println("没有该选项"); 223 break; 224 } 225 } 226 } 227 228 /* 229 根据你键盘录入的字符串，判断是否有满足要求的，如果有就输出。 230 否则，提示有误。 231 232 String s = sc.nextLine(); 233 */ 234 import java.util.Scanner; 235 236 class SwitchTest3 { 237 public static void main(String[] args) { 238 //创建键盘录入对象 239 Scanner sc = new Scanner(System.in); 240 241 //录入数据 242 System.out.println("请输入你要判断的字符串："); 243 String s = sc.nextLine(); 244 245 switch(s) { 246 case "hello": 247 System.out.println("你输入的是hello"); 248 break; 249 case "world": 250 System.out.println("你输入的是world"); 251 break; 252 case "java": 253 System.out.println("你输入的是java"); 254 break; 255 default: 256 System.out.println("没有找到你输入的数据"); 257 //break; 258 } 259 } 260 } 261 262 /* 263 用switch语句实现键盘录入月份，输出对应的季节 264 265 分析： 266 A:键盘录入一个月份，用Scanner实现 267 B:用switch语句实现即可 268 269 if语句和switch语句的区别? 270 if语句： 271 A:针对结果是boolean类型的判断 272 B:针对一个范围的判断 273 C:针对几个常量值的判断 274 275 switch语句： 276 针对几个常量值的判断 277 */ 278 import java.util.Scanner; 279 280 class SwitchTest4 { 281 public static void main(String[] args) { 282 //创建键盘录入对象 283 Scanner sc = new Scanner(System.in); 284 285 //录入数据 286 System.out.println("请输入月份(1-12)："); 287 int month = sc.nextInt(); 288 289 /* 290 switch(month) { 291 case 1: 292 System.out.println("冬季"); 293 break; 294 case 2: 295 System.out.println("冬季"); 296 break; 297 case 3: 298 System.out.println("春季"); 299 break; 300 case 4: 301 System.out.println("春季"); 302 break; 303 case 5: 304 System.out.println("春季"); 305 break; 306 case 6: 307 System.out.println("夏季"); 308 break; 309 case 7: 310 System.out.println("夏季"); 311 break; 312 case 8: 313 System.out.println("夏季"); 314 break; 315 case 9: 316 System.out.println("秋季"); 317 break; 318 case 10: 319 System.out.println("秋季"); 320 break; 321 case 11: 322 System.out.println("秋季"); 323 break; 324 case 12: 325 System.out.println("冬季"); 326 break; 327 default: 328 System.out.println("你输入的月份有误"); 329 } 330 */ 331 332 //这样写太麻烦了，我们使用一个我们不想使用的东西：case穿透 333 switch(month) { 334 case 1: 335 case 2: 336 case 12: 337 System.out.println("冬季"); 338 break; 339 case 3: 340 case 4: 341 case 5: 342 System.out.println("春季"); 343 break; 344 case 6: 345 case 7: 346 case 8: 347 System.out.println("夏季"); 348 break; 349 case 9: 350 case 10: 351 case 11: 352 System.out.println("秋季"); 353 break; 354 default: 355 System.out.println("你输入的月份有误"); 356 } 357 } 358 }
02_循环结构(for语句)
1 /* 2 循环语句：for循环,while循环,do...while循环。 3 4 for循环格式： 5 for(初始化语句;判断条件语句;控制条件语句) { 6 循环体语句; 7 } 8 9 执行流程： 10 A:执行初始化语句 11 B:执行判断条件语句,看其返回值是true还是false 12 如果是true，就继续执行 13 如果是false，就结束循环 14 C:执行循环体语句; 15 D:执行控制条件语句 16 E:回到B继续。 17 18 注意事项： 19 A:判断条件语句无论简单还是复杂结果是boolean类型。 20 B:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。 21 C:一般来说：有左大括号就没有分号，有分号就没有左大括号 22 23 需求：请在控制台输出10次"HelloWorld" 24 */ 25 class ForDemo { 26 public static void main(String[] args) { 27 //最原始的做法 28 System.out.println("HelloWorld"); 29 System.out.println("HelloWorld"); 30 System.out.println("HelloWorld"); 31 System.out.println("HelloWorld"); 32 System.out.println("HelloWorld"); 33 System.out.println("HelloWorld"); 34 System.out.println("HelloWorld"); 35 System.out.println("HelloWorld"); 36 System.out.println("HelloWorld"); 37 System.out.println("HelloWorld"); 38 System.out.println("----------"); 39 40 //这种做法不好,代码的重复度太高。 41 //所以呢，我们用循环改进 42 for(int x=1;x<=10;x++) { 43 System.out.println("HelloWorld"); 44 } 45 } 46 } 47 48 /* 49 需求：请在控制台输出数据1-10 50 */ 51 class ForDemo2 { 52 public static void main(String[] args) { 53 //原始做法 54 System.out.println(1); 55 System.out.println(2); 56 System.out.println(3); 57 System.out.println(4); 58 System.out.println(5); 59 System.out.println(6); 60 System.out.println(7); 61 System.out.println(8); 62 System.out.println(9); 63 System.out.println(10); 64 65 System.out.println("-------------"); 66 67 //如何改进呢?用循环改进 68 for(int x=1; x<=10; x++) { 69 System.out.println(x); 70 } 71 72 System.out.println("-------------"); 73 74 //从0开始 75 for(int x=0; x<10; x++) { 76 System.out.println(x+1); 77 } 78 } 79 } 80 81 82 /* 83 需求：求出1-10之间数据之和 84 85 分析： 86 0+1=1 87 1+2=3 88 3+3=6 89 6+4=10 90 10+5=15 91 ... 92 93 由此可见我们要定义两个变量： 94 一个变量用于存储第一个加数，第一个加数其实保存的是以前的所有数据和。默认初始化值应该是0。 95 一个变量用于存储第二个加数，第二个加数其实就是每次的数据变化的值。 96 97 求和思想。 98 */ 99 class ForDemo3 { 100 public static void main(String[] args) { 101 //原始做法 102 System.out.println(1+2+3+4+5+6+7+8+9+10); 103 104 //定义第一个加数 105 int sum = 0; 106 107 for(int x=1; x<=10; x++) { 108 //这里的x其实是第二个加数 109 sum = sum + x; 110 /* 111 0 + 1 = 1 112 1 + 2 = 3 113 3 + 3 = 6 114 ... 115 */ 116 //sum += x; 117 } 118 119 System.out.println("sum:"+sum); 120 } 121 } 122 123 /* 124 需求： 125 A:求1-100之和。 126 B:求出1-100之间偶数和 127 C:求出1-100之间奇数和(自己做) 128 */ 129 class ForDemo4 { 130 public static void main(String[] args) { 131 //求1-100之和。 132 int sum1 = 0; 133 134 for(int x=1; x<=100; x++) { 135 sum1 +=x; 136 } 137 138 System.out.println("1-100之和是："+sum1); 139 System.out.println("------------------"); 140 141 //求出1-100之间偶数和 142 //方式1 143 int sum2 = 0; 144 145 for(int x=1; x<=100; x++) { 146 if(x%2 == 0) { 147 sum2 += x; 148 } 149 } 150 151 System.out.println("1-100偶数之和是："+sum2); 152 System.out.println("------------------"); 153 154 //方式2 155 int sum3 = 0; 156 157 for(int x=0; x<=100; x+=2) { 158 sum3 += x; 159 } 160 161 System.out.println("1-100偶数之和是："+sum3); 162 System.out.println("------------------"); 163 } 164 } 165 166 /* 167 需求：求5的阶乘。 168 169 什么是阶乘呢? 170 n! = n*(n-1)! 规则 171 n! = n*(n-1)*(n-2)*...*3*2*1 172 173 求和思想。 174 求阶乘思想。 175 */ 176 class ForDemo5 { 177 public static void main(String[] args) { 178 //定义最终结果变量 179 int jc = 1; 180 181 //这里的x其实可以直接从2开始 182 //for(int x=1; x<=5; x++) 183 184 for(int x=2; x<=5; x++) { 185 jc *=x; 186 } 187 188 System.out.println("1-5的阶乘是："+jc); 189 } 190 } 191 192 /* 193 天将降大任于斯人也,必先盗其QQ,封其微博,收其wifi,夺其手机。让其静心学习Java欧耶。 194 195 需求：在控制台输出所有的”水仙花数” 196 197 分析： 198 我们都不知道什么叫"水仙花数"，你让我怎么做呢? 199 200 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。 201 举例：153就是一个水仙花数。 202 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153 203 204 A:三位数其实是告诉了我们范围。 205 B:通过for循环我们就可以实现获取每一个三位数 206 但是麻烦是如何获取这个三位数的个,十,百位上的数据 207 208 我们如何获取一个数据的个,十,百呢? 209 假设有个一个数据:153 210 ge: 153%10 = 3 211 shi: 153/10%10 = 5 212 bai：153/10/10%10 = 1 213 qian：x/10/10/10%10 214 wan: x/10/10/10/10%10 215 ... 216 217 C:让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较 218 如果相同，就把该数据在控制台输出。 219 */ 220 class ForDemo6 { 221 public static void main(String[] args) { 222 //三位数其实是告诉了我们范围。 223 for(int x=100; x<1000; x++) { 224 int ge = x%10; 225 int shi = x/10%10; 226 int bai = x/10/10%10; 227 228 //让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较 229 if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) { 230 //如果相同，就把该数据在控制台输出。 231 System.out.println(x); 232 } 233 } 234 } 235 } 236 237 /* 238 练习： 239 请在控制台输出满足如下条件的五位数 240 个位等于万位 241 十位等于千位 242 个位+十位+千位+万位=百位 243 244 分析： 245 A:五位数就告诉了我们范围。 246 B:分解每一个五位数的个，十，百，千，万位上的数据 247 C:按照要求进行判断即可 248 */ 249 class ForDemo7 { 250 public static void main(String[] args) { 251 //五位数就告诉了我们范围。 252 for(int x=10000; x<100000; x++) { 253 //分解每一个五位数的个，十，百，千，万位上的数据 254 int ge = x%10; 255 int shi = x/10%10; 256 int bai = x/10/10%10; 257 int qian = x/10/10/10%10; 258 int wan = x/10/10/10/10%10; 259 260 //按照要求进行判断即可 261 if((ge==wan) && (shi==qian) && (ge+shi+qian+wan==bai)) { 262 System.out.println(x); 263 } 264 } 265 } 266 } 267 268 /* 269 需求：统计”水仙花数”共有多少个 270 271 分析： 272 A:首先必须知道什么是水仙花数 273 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。 274 举例：153就是一个水仙花数。 275 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153 276 B:定义统计变量，初始化值是0 277 C:三位数告诉了我们范围，用for循环就可以搞定 278 D:获取每一个三位数的个，十，百的数据 279 E:按照要求进行判断 280 F:如果满足要求就计数。 281 */ 282 class ForDemo8 { 283 public static void main(String[] args) { 284 //定义统计变量，初始化值是0 285 int count = 0; 286 287 //三位数告诉了我们范围，用for循环就可以搞定 288 for(int x=100; x<1000; x++) { 289 //获取每一个三位数的个，十，百的数据 290 int ge = x%10; 291 int shi = x/10%10; 292 int bai = x/10/10%10; 293 294 //按照要求进行判断 295 if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) { 296 //如果满足要求就计数。 297 count++; 298 } 299 } 300 301 System.out.println("水仙花数共有"+count+"个"); 302 } 303 } 304 /* 305 需求：请统计1-1000之间同时满足如下条件的数据有多少个： 306 对3整除余2 307 对5整除余3 308 对7整除余2 309 310 分析： 311 A:定义统计变量,初始化值是0 312 B:1-1000之间是一个范围，用for很容易就可以实现。 313 C:每个数据要同时满足如下要求 314 x%3==2 315 x%5==3 316 x%7==2 317 D:如果满足条件，统计数据++即可，最后输出统计变量 318 */ 319 class ForDemo9 { 320 public static void main(String[] args) { 321 //定义统计变量,初始化值是0 322 int count = 0; 323 324 //1-1000之间是一个范围，用for很容易就可以实现。 325 for(int x=1; x<=1000; x++) { 326 /* 327 每个数据要同时满足如下要求 328 x%3==2 329 x%5==3 330 x%7==2 331 */ 332 if(x%3==2 && x%5==3 && x%7==2) { 333 count++; 334 System.out.println(x); 335 } 336 } 337 338 //输出数据 339 System.out.println("满足这样条件的数据共有："+count+"个"); 340 } 341 }
03_循环结构(while语句)
1 /* 2 while循环的基本格式： 3 while(判断条件语句) { 4 循环体语句; 5 } 6 7 扩展格式： 8 9 初始化语句; 10 while(判断条件语句) { 11 循环体语句; 12 控制条件语句; 13 } 14 15 通过这个格式，我们就可以看到其实和for循环是差不多的。 16 17 for(初始化语句;判断条件语句;控制条件语句) { 18 循环体语句; 19 } 20 */ 21 class WhileDemo { 22 public static void main(String[] args) { 23 //输出10次"HelloWorld" 24 //for语句版 25 for(int x=0; x<10; x++) { 26 System.out.println("HelloWorld"); 27 } 28 System.out.println("--------------"); 29 //while语句版 30 int x=0; 31 while(x<10) { 32 System.out.println("HelloWorld"); 33 x++; 34 } 35 } 36 } 37 38 /* 39 练习：用while循环实现 40 左边：求出1-100之和 41 右边：统计水仙花数有多少个 42 43 初始化语句; 44 while(判断条件语句) { 45 循环体语句; 46 控制条件语句; 47 } 48 49 50 51 for(初始化语句;判断条件语句;控制条件语句) { 52 循环体语句; 53 } 54 55 */ 56 class WhileDemo2 { 57 public static void main(String[] args) { 58 //求出1-100之和 59 //for语句版本 60 int sum = 0; 61 62 for(int x=1; x<=100; x++) { 63 sum+=x; 64 } 65 66 System.out.println("sum:"+sum); 67 System.out.println("--------"); 68 //while语句版本 69 int sum2 = 0; 70 71 int y=1; 72 while(y<=100) { 73 sum2+=y; 74 y++; 75 } 76 77 System.out.println("sum2:"+sum2); 78 System.out.println("--------"); 79 } 80 } 81 82 /* 83 需求：统计水仙花数有多少个 84 */ 85 class WhileDemo3 { 86 public static void main(String[] args) { 87 //for循环版本 88 int count = 0; 89 90 for(int x=100; x<1000; x++) { 91 int ge = x%10; 92 int shi = x/10%10; 93 int bai = x/10/10%10; 94 95 if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) { 96 count++; 97 } 98 } 99 100 System.out.println("count:"+count); 101 System.out.println("------------"); 102 103 //while循环版本 104 int count2 = 0; 105 106 int y = 100; 107 while(y<1000) { 108 int ge = y%10; 109 int shi = y/10%10; 110 int bai = y/10/10%10; 111 112 if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == y) { 113 count2++; 114 } 115 116 y++; 117 } 118 119 System.out.println("count2:"+count2); 120 } 121 } 122 123 /* 124 while循环和for循环的区别? 125 使用区别：如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用for循环。 126 因为变量及早的从内存中消失，可以提高内存的使用效率。 127 128 其实还有一种场景的理解: 129 如果是一个范围的，用for循环非常明确。 130 如果是不明确要做多少次，用while循环较为合适。 131 举例：吃葡萄。 132 */ 133 class WhileDemo4 { 134 public static void main(String[] args) { 135 //for循环实现 136 for(int x=0; x<10; x++) { 137 System.out.println("学习Java技术哪家强,中国北京传智播客"); 138 } 139 //这里不能在继续访问了 140 //System.out.println(x); 141 142 //while循环实现 143 int y = 0; 144 while(y<10) { 145 System.out.println("学习Java技术哪家强,中国北京传智播客"); 146 y++; 147 } 148 //这里是可以继续访问的 149 System.out.println(y); 150 } 151 } 152 153 154 155 156 157 158 159 160 161 /* 162 我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。 163 请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度? 164 165 分析： 166 A:定义一个统计变量，默认值是0 167 B:最高山峰是珠穆朗玛峰：8848m这是最终的厚度 168 我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度 169 C:我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度? 170 折叠一次有什么变化呢?就是厚度是以前的2倍。 171 D:只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++ 172 E:输出统计变量。 173 */ 174 class WhileDemo5 { 175 public static void main(String[] args) { 176 //定义一个统计变量，默认值是0 177 int count = 0; 178 179 //最高山峰是珠穆朗玛峰：8848m这是最终的厚度 180 //我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度 181 //为了简单，我把0.01变成1，同理8848就变成了884800 182 int end = 884800; 183 int start = 1; 184 185 while(start<end) { 186 //只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++ 187 count++; 188 189 //折叠一次有什么变化呢?就是厚度是以前的2倍。 190 start *= 2; 191 192 System.out.println("第"+count+"次厚度是"+start); 193 } 194 195 //输出统计变量。 196 System.out.println("要叠"+count+"次"); 197 } 198 }
04_循环结构(dowhile语句)
1 /* 2 do...while循环的基本格式： 3 do { 4 循环体语句; 5 }while(判断条件语句); 6 7 扩展格式； 8 初始化语句; 9 do { 10 循环体语句; 11 控制条件语句; 12 }while(判断条件语句); 13 */ 14 class DoWhileDemo { 15 public static void main(String[] args) { 16 //输出10次HelloWorld。 17 int x = 0; 18 do { 19 System.out.println("HelloWorld"); 20 x++; 21 }while(x<10); 22 23 System.out.println("--------------"); 24 25 //求和1-100 26 int sum = 0; 27 int a = 1; 28 do { 29 sum += a; 30 a++; 31 }while(a<=100); 32 System.out.println(sum); 33 } 34 } 35 36 /* 37 循环语句的区别: 38 do...while循环至少执行一次循环体。 39 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。 40 那么，我们一般使用哪种循环呢? 41 优先考虑for，其次考虑while，最后考虑do...while 42 */ 43 class DoWhileDemo2 { 44 public static void main(String[] args) { 45 int x = 3; 46 while(x < 3) { 47 System.out.println("我爱林青霞"); 48 x++; 49 } 50 System.out.println("--------------"); 51 int y = 3; 52 do { 53 System.out.println("我爱林青霞"); 54 y++; 55 }while(y < 3); 56 } 57 } 58 59 /* 60 注意死循环： 61 A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。 62 B:两种最简单的死循环格式 63 while(true){...} 64 for(;;){...} 65 */ 66 class DoWhileDemo3 { 67 public static void main(String[] args) { 68 int x = 0; 69 while(x < 10) { 70 System.out.println(x); 71 x++; 72 } 73 System.out.println("--------------"); 74 /* 75 while(true) { 76 System.out.println("今天我很高兴，学习了死循环"); 77 } 78 */ 79 for(;;){ 80 System.out.println("今天我很高兴，学习了死循环"); 81 } 82 83 //System.out.println("--------------"); 84 } 85 }
05_循环嵌套
1 /* 2 需求：请输出一个4行5列的星星(*)图案。 3 结果： 4 ***** 5 ***** 6 ***** 7 ***** 8 9 循环嵌套：就是循环语句的循环体本身是一个循环语句。 10 11 通过结果我们知道这样的一个结论： 12 外循环控制行数 13 内循环控制列数 14 */ 15 class ForForDemo { 16 public static void main(String[] args) { 17 //原始做法 18 System.out.println("*****"); 19 System.out.println("*****"); 20 System.out.println("*****"); 21 System.out.println("*****"); 22 System.out.println("-------------"); 23 24 //虽然可以完成需求，但是不是很好 25 //如果是多行多列就会比较麻烦 26 //所以我们准备改进 27 //如何改进呢? 28 //我先考虑如何实现一行*的问题 29 //System.out.println("*****"); 30 //我们要想的是如何实现一次输出一颗*的问题 31 //System.out.println("*"); 32 //System.out.println("*"); 33 //现在虽然可以一次一颗*，但是却换行了，我要求不能换行，怎么办呢? 34 //输出语句的另一种格式：System.out.print(); 这个是不带换行的 35 //System.out.print("*"); 36 //System.out.print("*"); 37 //System.out.print("*"); 38 //System.out.print("*"); 39 //System.out.print("*"); 40 //如果我要在一行上打出多颗*，比较麻烦，而代码是重复的，所以我决定用循环改进 41 for(int x=0; x<5; x++) { 42 System.out.print("*"); 43 } 44 //我们可以通过空的输出语句实现换行：System.out.println(); 45 System.out.println(); 46 47 //既然我可以打出一行，我就可以打出第二行 48 for(int x=0; x<5; x++) { 49 System.out.print("*"); 50 } 51 //我们可以通过空的输出语句实现换行：System.out.println(); 52 System.out.println(); 53 54 //同理打出第三行，第四行 55 for(int x=0; x<5; x++) { 56 System.out.print("*"); 57 } 58 //我们可以通过空的输出语句实现换行：System.out.println(); 59 System.out.println(); 60 61 //既然我可以打出一行，我就可以打出第二行 62 for(int x=0; x<5; x++) { 63 System.out.print("*"); 64 } 65 //我们可以通过空的输出语句实现换行：System.out.println(); 66 System.out.println(); 67 System.out.println("-----------------"); 68 //同样的代码出现了4次，说明我们程序写的不好，用循环改进 69 for(int y=0; y<4; y++) { 70 for(int x=0; x<5; x++) { 71 System.out.print("*"); 72 } 73 //我们可以通过空的输出语句实现换行：System.out.println(); 74 System.out.println(); 75 } 76 } 77 } 78 79 /* 80 需求：请输出下列的形状 81 * 82 ** 83 *** 84 **** 85 ***** 86 */ 87 class ForForDemo2 { 88 public static void main(String[] args) { 89 //通过简单的观察，我们看到这是一个行是5，列数是变化的形状 90 //我们先打印出一个5行5列的形状 91 for(int x=0; x<5; x++) { 92 for(int y=0; y<5; y++) { 93 System.out.print("*"); 94 } 95 System.out.println(); 96 } 97 98 System.out.println("--------------"); 99 100 //我们实现了一个5行5列的形状 101 //但是这不是我们想要的 102 //我们要的是列数变化的 103 //列数是如何变化的呢? 104 //第一行：1列 y=0,y<=0,y++ 105 //第二行：2列 y=0,y<=1,y++ 106 //第三行：3列 y=0,y<=2,y++ 107 //第四行：4列 y=0,y<=3,y++ 108 //第五行：5列 y=0,y<=4,y++ 109 //在看外循环x的变化，恰好就是x=0,1,2,3,4 110 //所以这个最终版的程序就是如下 111 for(int x=0; x<5; x++) { 112 for(int y=0; y<=x; y++) { 113 System.out.print("*"); 114 } 115 System.out.println(); 116 } 117 } 118 } 119 120 121 /* 122 需求：在控制台输出九九乘法表。 123 124 首先我们写出九九乘法表： 125 1*1=1 126 1*2=2 2*2=4 127 1*3=3 2*3=6 3*3=9 128 1*4=4 2*4=8 3*4=12 4*4=16 129 ... 130 1*9=9 2*9=18 3*9=27 ... 131 132 我们先把这个九九乘法表看出是这样的一个形状： 133 * 134 ** 135 *** 136 **** 137 ***** 138 ****** 139 ******* 140 ******** 141 ********* 142 143 注意： 144 '\x' x表示任意，这种做法叫转移字符。 145 146 '\t' tab键的位置 147 '\r' 回车 148 '\n' 换行 149 */ 150 class ForForDemo3 { 151 public static void main(String[] args) { 152 for(int x=0; x<9; x++) { 153 for(int y=0; y<=x; y++) { 154 System.out.print("*"); 155 } 156 System.out.println(); 157 } 158 System.out.println("--------------"); 159 //为了使用数据，我们从1开始 160 for(int x=1; x<=9; x++) { 161 for(int y=1; y<=x; y++) { 162 System.out.print(y+"*"+x+"="+y*x+"\t"); 163 } 164 System.out.println(); 165 } 166 } 167 }
06_跳转语句
1 /* 2 控制跳转语句： 3 break:中断 4 continue:继续 5 return:返回 6 7 break:中断的意思 8 使用场景： 9 A:switch语句中 10 B:循环语句中。 11 (循环语句中加入了if判断的情况) 12 注意：离开上面的两个场景，无意义。 13 14 如何使用呢? 15 A:跳出单层循环 16 B:跳出多层循环 17 要想实现这个效果，就必须知道一个东西。带标签的语句。 18 格式： 19 标签名: 语句 20 */ 21 class BreakDemo { 22 public static void main(String[] args) { 23 //在 switch 或 loop 外部中断 24 //break; 25 //跳出单层循环 26 for(int x=0; x<10; x++) { 27 if(x == 3) { 28 break; 29 } 30 System.out.println("HelloWorld"); 31 } 32 System.out.println("over"); 33 System.out.println("-------------"); 34 wc:for(int x=0; x<3; x++) { 35 nc:for(int y=0; y<4; y++) { 36 if(y == 2) { 37 //break nc; 38 break wc; 39 } 40 System.out.print("*"); 41 } 42 System.out.println(); 43 } 44 } 45 } 46 47 /* 48 continue:继续 49 50 使用场景： 51 循环中。离开此场景无意义。 52 53 测试，找到和break的区别： 54 break:跳出单层循环 55 continue:跳出一次循环，进入下一次的执行 56 57 练习题： 58 for(int x=1; x<=10; x++) { 59 if(x%3==0) { 60 //在此处填写代码 61 } 62 System.out.println(“Java基础班”); 63 } 64 65 我想在控制台输出2次:“Java基础班“ 66 break; 67 我想在控制台输出7次:“Java基础班“ 68 continue; 69 我想在控制台输出13次:“Java基础班“ 70 System.out.println(“Java基础班”); 71 72 73 */ 74 class ContinueDemo { 75 public static void main(String[] args) { 76 for(int x=0; x<10; x++) { 77 if(x == 3) { 78 //break; 79 continue; 80 } 81 82 System.out.println(x); 83 } 84 } 85 } 86 87 /* 88 return:返回 89 90 其实它的作用不是结束循环的，而是结束方法的。 91 */ 92 class ReturnDemo { 93 public static void main(String[] args) { 94 for(int x=0; x<10; x++) { 95 if(x == 2) { 96 System.out.println("退出"); 97 //break; 98 //continue; 99 return; 100 } 101 102 System.out.println(x); 103 } 104 105 System.out.println("over"); 106 } 107 } 108 109 /* 110 需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是， 111 每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱， 112 请问，经过多少天，小芳才可以存到100元钱。 113 114 分析： 115 A:小芳的妈妈每天给她2.5元钱 116 double dayMoney = 2.5; 117 B:她都会存起来 118 double daySum = 0; 119 C:从第一天开始存储 120 int dayCount = 1; 121 D:经过多少天，小芳才可以存到100元钱。 122 double result = 100; 123 E:这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱， 124 说明要判断dayCount的值，如果对5整除就减去6元钱。 125 daySum -= 6; 126 由此还隐含了一个问题，就是如果不是5的倍数天的话，钱要累加 127 daySum += dayMoney; 128 F:因为不知道是多少天，所以我用死循环，一旦超过100元我就退出循环。 129 */ 130 class WhileDemo { 131 public static void main(String[] args) { 132 //每天要存储的钱是2.5元 133 double dayMoney = 2.5; 134 135 //存钱的初始化值是0 136 double daySum = 0; 137 138 //从第一天开始存储 139 int dayCount = 1; 140 141 //最终存储不小于100就不存储了 142 int result = 100; 143 144 //因为不知道是多少天，所以我用死循环， 145 while(true) { 146 //累加钱 147 daySum += dayMoney; 148 149 //一旦超过100元我就退出循环。 150 if(daySum >= result) { 151 System.out.println("共花了"+dayCount+"天存储了100元"); 152 break; 153 } 154 155 if(dayCount%5 == 0) { 156 //花去6元钱 157 daySum -= 6; 158 System.out.println("第"+dayCount+"天花了6元钱"); 159 } 160 161 //天数变化 162 dayCount++; 163 } 164 } 165 }
小结：
1 1:switch语句(掌握) 2 (1)格式： 3 switch(表达式) { 4 case 值1: 5 语句体1; 6 break; 7 case 值2: 8 语句体2; 9 break; 10 ... 11 default: 12 语句体n+1; 13 break; 14 } 15 16 格式解释说明： 17 switch:说明这是switch语句。 18 表达式:可以是byte,short,int,char 19 JDK5以后可以是枚举 20 JDK7以后可以是字符串 21 case:后面的值就是要和表达式进行比较的值 22 break:表示程序到这里中断，跳出switch语句 23 default:如果所有的情况都不匹配,就执行这里,相当于if语句中的else 24 (2)面试题 25 switch语句的表达式可以是byte吗?可以是long吗?可以是String吗? 26 可以,不可以,JDK7以后可以 27 (3)执行流程: 28 A:首先计算表达式的值 29 B:和每一个case进行匹配，如果有就执行对应的语句体，看到break就结束。 30 C:如果没有匹配，就执行default的语句体n+1。 31 (4)注意事项: 32 A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的 33 B:default可以省略吗? 34 可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。 35 特殊情况： 36 case就可以把值固定。 37 A,B,C,D 38 C:break可以省略吗? 39 可以省略，但是结果可能不是我们想要的。 40 会出现一个现象：case穿透。 41 最终我们建议不要省略 42 D:default一定要在最后吗? 43 不是，可以在任意位置。但是建议在最后。 44 E:switch语句的结束条件 45 a:遇到break就结束了 46 b:执行到末尾就结束了 47 (5)案例： 48 A:键盘录入一个数字(1-7),输出对应的星期几。 49 B:单项选择题 50 C:键盘录入一个字符串的问题 51 String s = sc.nextLine(); 52 D:根据给定的月份,输出对应的季节 53 (6)if语句和switch语句各自的场景 54 A:if 55 针对boolean类型的判断 56 针对一个范围的判断 57 针对几个常量的判断 58 B:switch 59 针对几个常量的判断 60 61 2:循环语句(掌握) 62 (1)有三种:for,while,do...while 63 (2)for循环语句 64 A:格式 65 for(初始化语句;判断条件语句;控制条件语句){ 66 循环体语句; 67 } 68 69 执行流程： 70 a:执行初始化语句 71 b:执行判断条件语句 72 如果这里是true，就继续 73 如果这里是false，循环就结束 74 c:执行循环体语句 75 d:执行控制条件语句 76 e:回到b 77 B:注意事项 78 a:判断条件语句无论简单还是复杂，结果是boolean类型 79 b:循环体语句如果是一条，可以省略大括号，但是不建议 80 c:有分号就没有左大括号，有左大括号就没有分号 81 C:案例 82 a:输出10次HelloWorld 83 b:输出1-10的数据 84 c:输出10-1的数据 85 d:求1-10的和 86 e:求1-100的和,求1-100的偶数和,求1-100的奇数和 87 f:求5的阶乘 88 g:在控制台打印水仙花数 89 h:统计水仙花个数 90 i:改进版的回文数 91 一个五位数 92 个位 = 万位 93 十位 = 千位 94 个位 + 十位 + 千位 + 万位 = 百位 95 j:统计1-1000之间同时满足如下条件的数据有多少个 96 x%3==2 97 x%5==3 98 x%7==2 99 (3)while循环 100 A:基本格式 101 while(判断条件语句) { 102 循环体语句; 103 } 104 105 扩展格式： 106 初始化语句; 107 while(判断条件语句){ 108 循环体语句; 109 控制条件语句; 110 } 111 112 通过查看这个格式，我们就知道while循环可以和for循环等价转换。 113 B:while的练习 114 把for语句的练习用while改进 115 C:for和while的区别 116 a:使用上的区别 117 for语句的那个控制条件变量,在循环结束后不能在使用了。 118 而while的可以继续使用。 119 b:理解上的区别 120 for适合于一个范围的判断 121 while适合次数不明确的 122 举例:吃葡萄 123 D:案例： 124 a:珠穆朗玛峰问题 125 b:小芳存钱问题(break以后才能做) 126 (4)do...while循环 127 A:基本格式 128 do { 129 循环体语句; 130 }while(判断条件语句); 131 132 扩展格式： 133 初始化语句; 134 do { 135 循环体语句; 136 控制条件语句; 137 }while(判断条件语句); 138 139 通过查看格式，我们就可以看出其实三种循环的格式可以是统一的。 140 B:三种循环的区别 141 a:do...while循环至少执行一次循环体 142 b:for和while必须先判断条件是否是true，然后后才能决定是否执行循环体 143 (5)循环使用的注意事项(死循环) 144 A:一定要注意修改控制条件,否则容易出现死循环。 145 B:最简单的死循环格式 146 a:while(true){...} 147 148 b:for(;;){} 149 150 3:控制跳转语句(掌握) 151 (1)break:中断的意思 152 A:用在循环和switch语句中，离开此应用场景无意义。 153 B:作用 154 a:跳出单层循环 155 b:跳出多层循环，需要标签语句的配合 156 (2)continue:继续 157 A:用在循环中，离开此应用场景无意义。 158 B:作用 159 a:跳出单层循环的一次，可以继续下一次 160 C:填空题 161 for(int x=1; x<=10; x++) { 162 if(x%3 == 0) { 163 //补齐代码 164 } 165 System.out.println("Java基础班"); 166 } 167 如何让控制台输出2次：Java基础班 168 如何让控制台输出7次：Java基础班 169 如何让控制台输出13次：Java基础班 170 (3)return:返回 171 A:用于结束方法的，后面还会在继续讲解和使用。 172 B:一旦遇到return,程序就不会在继续往后执行。
01_方法
1 /* 2 方法：完成特定功能的代码块。 3 4 注意：在很多语言里面有函数的定义，而在Java中函数被称为方法。 5 6 方法格式： 7 修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) { 8 方法体语句; 9 return 返回值; 10 } 11 详细解释： 12 修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。 13 返回值类型：就是功能结果的数据类型。 14 方法名：符合命名规则即可。方便我们的调用。 15 参数： 16 实际参数：就是实际参与运算的。 17 形式参数；就是方法定义上的，用于接收实际参数的。 18 参数类型：就是参数的数据类型 19 参数名：就是变量名 20 方法体语句：就是完成功能的代码。 21 return：结束方法的。 22 返回值：就是功能的结果，由return带给调用者。 23 24 要想写好一个方法，就必须明确两个东西： 25 A:返回值类型 26 结果的数据类型 27 B:参数列表 28 你要传递几个参数，以及每个参数的数据类型 29 30 需求：求两个数据之和的案例 31 32 方法的执行特点： 33 不调用，不执行。 34 35 如何调用呢?(有明确返回值的调用) 36 A:单独调用,一般来说没有意义，所以不推荐。 37 B:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。 38 C:赋值调用,推荐方案。 39 40 */ 41 class FunctionDemo { 42 public static void main(String[] args) { 43 int x = 10; 44 int y = 20; 45 46 //方式1：单独调用 47 //sum(x,y); 48 49 //方式2：输出调用 50 //System.out.println(sum(x,y)); 51 //System.out.println(30); 52 53 //方式3：赋值调用 54 int result = sum(x,y); 55 //result在这里可以进行操作 56 System.out.println(result); 57 } 58 59 /* 60 需求：求两个数据之和的案例 61 62 两个明确： 63 返回值类型：int 64 参数列表：2个，都是int类型。 65 */ 66 public static int sum(int a,int b) { 67 //如何实现呢? 68 //int c = a + b; 69 //return c; 70 71 //c就是a+b,所以，我可以直接返回a+b 72 return a + b; 73 } 74 75 } 76 77 78 79 80 81 82 83 84 85 86 87 /* 88 方法的注意事项： 89 A:方法不调用不执行 90 B:方法与方法是平级关系，不能嵌套定义 91 C:方法定义的时候参数之间用逗号隔开 92 D:方法调用的时候不用在传递数据类型 93 E:如果方法有明确的返回值，一定要有return带回一个值 94 */ 95 class FunctionDemo2 { 96 public static void main(String[] args) { 97 /* 98 错误的 99 public static int sum(int a,int b){ 100 return a + b; 101 } 102 */ 103 104 //sum(10,20); 105 106 //int x = 10; 107 //int y = 20; 108 //错误 109 //sum(int x,int y); 110 } 111 112 public static int sum(int a,int b){ 113 return a + b; 114 } 115 } 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 /* 132 需求：在控制台输出如下的形状 133 ***** 134 ***** 135 ***** 136 ***** 137 138 void类型返回值的方法调用： 139 单独调用 140 输出调用(错误) 141 赋值调用(错误) 142 */ 143 class FunctionDemo3 { 144 public static void main(String[] args) { 145 //for循环嵌套输出图形 146 for(int x=0; x<4; x++) { 147 for(int y=0; y<5; y++) { 148 System.out.print("*"); 149 } 150 System.out.println(); 151 } 152 System.out.println("--------------"); 153 154 //需求：我要在控制台输出一个6行7列的星形图形 155 for(int x=0; x<6; x++) { 156 for(int y=0; y<7; y++) { 157 System.out.print("*"); 158 } 159 System.out.println(); 160 } 161 System.out.println("--------------"); 162 163 //如果需要继续改变，我们就应该考虑使用方法改进。 164 //单独调用 165 pringXing(3,4); 166 System.out.println("--------------"); 167 pringXing(6,7); 168 System.out.println("--------------"); 169 pringXing(8,9); 170 171 //输出调用 172 //此处不允许使用 '空' 类型 173 //System.out.println(pringXing(3,4)); 174 175 //赋值调用 176 //非法的表达式开始 177 //void v = pringXing(3,4); 178 } 179 180 /* 181 写一个什么样子的方法呢?写一个m行n列的代码 182 183 两个明确： 184 返回值类型：这个时候没有明确的返回值，不写东西还不行，所以，这里记住是void 185 参数列表：int m,int n 186 */ 187 public static void pringXing(int m,int n) { 188 for(int x=0; x<m; x++) { 189 for(int y=0; y<n; y++) { 190 System.out.print("*"); 191 } 192 System.out.println(); 193 } 194 } 195 } 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 /* 219 需求：我要求数的和 220 我们的需求不断的发生改变，我们就对应的提供了多个求和的方法。 221 但是呢，他们的名字是不一样的。 222 而我们又要求方法命名做到：见名知意。 223 但是，很明显，现在没有做到。 224 那么，肿么办呢? 225 针对这种情况：方法的功能相同，参数列表不同的情况，为了见名知意，Java允许它们起一样的名字。 226 227 其实，这种情况有一个专业名词：方法重载。 228 229 方法重载： 230 在同一个类中，方法名相同，参数列表不同。与返回值类型无关。 231 参数列表不同： 232 A:参数个数不同 233 B:参数类型不同 234 */ 235 class FunctionDemo4 { 236 public static void main(String[] args) { 237 //jvm会根据不同的参数去调用不同的功能 238 System.out.println(sum(10,20)); 239 System.out.println(sum(10,20,30)); 240 System.out.println(sum(10,20,30,40)); 241 System.out.println(sum(10.5f,20f)); 242 } 243 //需求1:求两个数的和 244 public static int sum(int a,int b) { 245 System.out.println("int"); 246 return a + b; 247 } 248 //需求2:求三数的和 249 /* 250 public static int sum1(int a,int b,int c) { 251 return a + b + c; 252 } 253 */ 254 public static int sum(int a,int b,int c) { 255 return a + b + c; 256 } 257 //需求3:求四个数的和 258 /* 259 public static int sum2(int a,int b,int c,int d) { 260 return a + b + c + d; 261 } 262 */ 263 public static int sum(int a,int b,int c,int d) { 264 return a + b + c + d; 265 } 266 267 public static float sum(float a,float b) { 268 System.out.println("float"); 269 return a + b; 270 } 271 } 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 /* 303 键盘录入两个数据，返回两个数中的较大值 304 */ 305 import java.util.Scanner; 306 307 class FunctionTest { 308 public static void main(String[] args) { 309 //创建键盘录入对象 310 Scanner sc = new Scanner(System.in); 311 312 System.out.println("请输入第一个数据:"); 313 int a = sc.nextInt(); 314 315 System.out.println("请输入第二个数据:"); 316 int b = sc.nextInt(); 317 318 int result = getMax(a,b); 319 System.out.println("较大值是："+result); 320 } 321 /* 322 需求：两个数中的较大值 323 两个明确： 324 返回值类型：int 325 参数列表：int a,int b 326 */ 327 public static int getMax(int a,int b) { 328 //if语句 329 /* 330 if(a > b) { 331 //System.out.println(a); 332 return a; 333 }else { 334 //System.out.println(b); 335 return b; 336 } 337 */ 338 //用三元改进 339 //int c = ((a > b)? a: b); 340 //return c; 341 342 //由于c就是后面的式子 343 return ((a>b)? a : b); 344 } 345 } 346 347 348 349 /* 350 键盘录入两个数据，比较两个数是否相等 351 352 分析： 353 比较两个数是否相等结果是一个boolean类型。 354 */ 355 import java.util.Scanner; 356 class FunctionTest2 { 357 public static void main(String[] args) { 358 //创建键盘录入对象 359 Scanner sc = new Scanner(System.in); 360 System.out.println("请输入第一个数据:"); 361 int a = sc.nextInt(); 362 System.out.println("请输入第二个数据:"); 363 int b = sc.nextInt(); 364 boolean flag = compare(a,b); 365 System.out.println(flag); 366 } 367 /* 368 需求：比较两个数是否相等 369 两个明确： 370 返回值类型：boolean 371 参数列表：int a,int b 372 */ 373 public static boolean compare(int a,int b) { 374 //if语句的格式2实现 375 /* 376 if(a == b) { 377 return true; 378 }else { 379 return false; 380 } 381 */ 382 //三元改进 383 //boolean flag = ((a==b)? true: false); 384 //return flag; 385 //继续改进 386 //return ((a==b)? true: false); 387 //最终版 388 return a == b; 389 } 390 } 391 392 393 /* 394 键盘录入三个数据，返回三个数中的最大值 395 */ 396 import java.util.Scanner; 397 398 class FunctionTest3 { 399 public static void main(String[] args) { 400 //创建键盘录入对象 401 Scanner sc = new Scanner(System.in); 402 403 System.out.println("请输入第一个数据:"); 404 int a = sc.nextInt(); 405 406 System.out.println("请输入第二个数据:"); 407 int b = sc.nextInt(); 408 409 System.out.println("请输入第三个数据:"); 410 int c = sc.nextInt(); 411 412 int max = getMax(a,b,c); 413 System.out.println("三个数据中的最大值是："+max); 414 } 415 416 /* 417 需求；返回三个数中的最大值 418 419 两个明确： 420 返回值类型：int 421 参数列表：int a,int b,int c 422 */ 423 public static int getMax(int a,int b,int c) { 424 //if嵌套 425 /* 426 if(a > b) { 427 if(a > c) { 428 return a; 429 }else { 430 return c; 431 } 432 }else { 433 if(b > c) { 434 return b; 435 }else { 436 return c; 437 } 438 } 439 */ 440 441 //用三元改 442 /* 443 if(a > b) { 444 return (a>c? a: c); 445 }else { 446 return (b>c? b: c); 447 } 448 */ 449 450 //继续改进 451 //return (a>b)? (a>c? a: c): (b>c? b: c); 452 //不建议，写代码一定要注意阅读性强 453 int temp = ((a>b)? a: b); 454 int max = ((temp>c)? temp: c); 455 return max; 456 } 457 } 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 /* 482 键盘录入行数和列数，输出对应的星形 483 */ 484 import java.util.Scanner; 485 486 class FunctionTest4 { 487 public static void main(String[] args) { 488 //创建键盘录入对象 489 Scanner sc = new Scanner(System.in); 490 491 System.out.println("请输入行数："); 492 int m = sc.nextInt(); 493 494 System.out.println("请输入列数："); 495 int n = sc.nextInt(); 496 497 //void类型的方法调用 498 pringXing(m,n); 499 } 500 501 /* 502 输出星形 503 504 两个明确： 505 返回值类型：void 506 参数列表：int m,int n 507 */ 508 public static void pringXing(int m,int n) { 509 for(int x=0; x<m; x++) { 510 for(int y=0; y<n; y++) { 511 System.out.print("*"); 512 } 513 System.out.println(); 514 } 515 } 516 } 517 518 519 520 521 522 523 524 525 /* 526 键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表 527 */ 528 import java.util.Scanner; 529 530 class FunctionTest5 { 531 public static void main(String[] args) { 532 //创建对象 533 Scanner sc = new Scanner(System.in); 534 535 System.out.println("请输入n的值：(1~9)"); 536 int n = sc.nextInt(); 537 538 //调用 539 printNN(n); 540 } 541 542 /* 543 需求：输出对应的nn乘法表 544 两个明确： 545 返回值类型：void 546 参数列表：int n 547 */ 548 public static void printNN(int n) { 549 for(int x=1; x<=n; x++) { 550 for(int y=1; y<=x; y++) { 551 System.out.print(y+"*"+x+"="+y*x+"\t"); 552 } 553 System.out.println(); 554 } 555 } 556 } 557 558 559 560 561 562 563 564 565 566 567 568 569 /* 570 比较两个数据是否相等。参数类型分别为 571 两个byte类型，两个short类型，两个int类型，两个long类型， 572 并在main方法中进行测试 573 */ 574 class FunctionTest6 { 575 public static void main(String[] args) { 576 //测试 577 byte b1 = 3; 578 byte b2 = 4; 579 System.out.println("byte:"+compare(b1,b2)); 580 //测试 581 short s1 = 5; 582 short s2 = 5; 583 System.out.println("short:"+compare(s1,s2)); 584 //后面的两个自己测试 585 } 586 //byte类型 587 public static boolean compare(byte a,byte b) { 588 System.out.println("byte"); 589 return a == b; 590 } 591 //short类型 592 public static boolean compare(short a,short b) { 593 System.out.println("short"); 594 return a == b; 595 } 596 //int类型 597 public static boolean compare(int a,int b) { 598 System.out.println("int"); 599 return a == b; 600 } 601 //long类型 602 public static boolean compare(long a,long b) { 603 System.out.println("long"); 604 return a == b; 605 } 606 }
02_数组(一维数组)
1 /* 2 数组:存储同一种数据类型的多个元素的容器。 3 4 定义格式： 5 A:数据类型[] 数组名; 6 B:数据类型 数组名[]; 7 8 举例： 9 A:int[] a; 定义一个int类型的数组a变量 10 B:int a[]; 定义一个int类型的a数组变量 11 12 注意：效果可以认为是一样的，都是定义一个int数组，但是念法上有些小区别。推荐使用第一种。 13 14 如何对数组进行初始化呢? 15 A:何谓初始化呢? 就是为数组开辟内存空间，并为每个数组元素赋予值 16 B:有几种方式呢? 17 a:动态初始化 只指定长度，由系统给出初始化值 18 b:静态初始化 给出初始化值，由系统决定长度 19 20 动态初始化的格式： 21 数据类型[] 数组名 = new 数据类型[数组长度]; 22 23 举例： 24 int[] arr = new int[3]; 25 26 如何获取数组中的元素呢? 27 通过: 28 数组名[索引] 29 索引其实就是每个元素的编号，从0开始，最大索引是数组的长度-1。 30 */ 31 class ArrayDemo { 32 public static void main(String[] args) { 33 //定义一个数组 34 //int[] a; 35 //可能尚未初始化变量a 36 //System.out.println(a); 37 38 int[] arr = new int[3]; 39 /* 40 左边： 41 int:说明数组中的元素的数据类型是int类型 42 []:说明这是一个数组 43 arr:是数组的名称 44 45 右边： 46 new:为数组分配内存空间。 47 int:说明数组中的元素的数据类型是int类型 48 []:说明这是一个数组 49 3:数组长度，其实也就是数组中元素的个数 50 */ 51 52 System.out.println(arr); //[I@175078b 地址值。 53 //我要地址值没有意义啊，我就要数据值，怎么办呢? 54 //不用担心，java为你考虑到了。 55 //其实数组中的每个元素都是有编号的，并且是从0开始。最大编号是数组的长度-1。 56 //用数组名和编号的配合就可以获取数组中的指定编号的元素。这个编号的专业叫法：索引 57 //通过数组名访问数据的格式是：数组名[索引]; 58 System.out.println(arr[0]); 59 System.out.println(arr[1]); 60 System.out.println(arr[2]); 61 } 62 } 63 64 65 66 67 68 69 /* 70 定义一个数组，输出该数组的名称和数组元素值。 71 给数组元素赋值，再次输出该数组的名称和数组元素值。 72 */ 73 class ArrayDemo2 { 74 public static void main(String[] args) { 75 //定义一个数组 76 int[] arr = new int[3]; 77 78 //输出数组名称 79 System.out.println(arr); 80 //输出数组元素值 81 System.out.println(arr[0]); 82 System.out.println(arr[1]); 83 System.out.println(arr[2]); 84 System.out.println("----"); 85 86 //给数组元素赋值 87 arr[0] = 100; 88 arr[2] = 200; 89 90 //输出数组名称 91 System.out.println(arr); 92 //输出数组元素值 93 System.out.println(arr[0]); 94 System.out.println(arr[1]); 95 System.out.println(arr[2]); 96 } 97 } 98 99 100 101 /* 102 定义两个数组，分别输出两个数组各自的数组名及元素值。 103 然后给每个数组的元素重新赋值，再次分别输出两个数组各自的数组名及元素值。 104 */ 105 class ArrayDemo3 { 106 public static void main(String[] args) { 107 //定义第一个数组 108 int[] arr = new int[2]; 109 //定义第二个数组 110 int[] arr2 = new int[3]; 111 112 //输出数组名和元素值 113 System.out.println(arr); 114 System.out.println(arr[0]); 115 System.out.println(arr[1]); 116 System.out.println("----"); 117 118 System.out.println(arr2); 119 System.out.println(arr2[0]); 120 System.out.println(arr2[1]); 121 System.out.println(arr2[2]); 122 System.out.println("----"); 123 124 //给元素重新赋值 125 arr[1] = 20; 126 127 arr2[1] = 30; 128 arr2[0] = 40; 129 130 //输出数组名和元素值 131 System.out.println(arr); 132 System.out.println(arr[0]); 133 System.out.println(arr[1]); 134 System.out.println("----"); 135 136 System.out.println(arr2); 137 System.out.println(arr2[0]); 138 System.out.println(arr2[1]); 139 System.out.println(arr2[2]); 140 } 141 } 142 143 144 145 146 147 /* 148 定义第一个数组,定义完毕后，给数组元素赋值。赋值完毕后，在输出数组名称和元素。 149 定义第二个数组,定义完毕后，给数组元素赋值。赋值完毕后，在输出数组名称和元素。 150 定义第三个数组,把第一个数组的地址值赋值给它。(注意类型一致)，通过第三个数组的名称去把元素重复赋值。 151 最后，再次输出第一个数组数组名称和元素。 152 */ 153 class ArrayDemo4 { 154 public static void main(String[] args) { 155 //定义第一个数组 156 int[] arr = new int[3]; 157 arr[0] = 88; 158 arr[1] = 33; 159 arr[2] = 66; 160 System.out.println(arr); 161 System.out.println(arr[0]); 162 System.out.println(arr[1]); 163 System.out.println(arr[2]); 164 System.out.println("----"); 165 166 //定义第二个数组 167 int[] arr2 = new int[3]; 168 arr2[0] = 22; 169 arr2[1] = 44; 170 arr2[2] = 55; 171 System.out.println(arr2); 172 System.out.println(arr2[0]); 173 System.out.println(arr2[1]); 174 System.out.println(arr2[2]); 175 System.out.println("----"); 176 177 //定义第三个数组 178 int[] arr3 = arr; 179 arr3[0] = 100; 180 arr3[1] = 200; 181 System.out.println(arr); 182 System.out.println(arr[0]); 183 System.out.println(arr[1]); 184 System.out.println(arr[2]); 185 } 186 } 187 188 189 190 191 192 193 194 195 196 197 /* 198 数组的静态初始化： 199 格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…}; 200 简化格式： 201 数据类型[] 数组名 = {元素1,元素2,…}; 202 203 举例： 204 int[] arr = new int[]{1,2,3}; 205 206 简化后： 207 208 int[] arr = {1,2,3}; 209 210 注意事项： 211 不要同时动态和静态进行。 212 如下格式： 213 int[] arr = new int[3]{1,2,3}; //错误 214 */ 215 class ArrayDemo5 { 216 public static void main(String[] args) { 217 //定义数组 218 int[] arr = {1,2,3}; 219 220 System.out.println(arr); 221 System.out.println(arr[0]); 222 System.out.println(arr[1]); 223 System.out.println(arr[2]); 224 } 225 } 226 227 228 229 230 231 232 233 /* 234 数组操作的两个常见小问题： 235 ArrayIndexOutOfBoundsException:数组索引越界异常 236 原因：你访问了不存在的索引。 237 238 NullPointerException:空指针异常 239 原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。 240 241 作用：请自己把所有的场景Exception结尾的问题总结一下。以后遇到就记录下来。 242 现象，原因，解决方案。 243 */ 244 class ArrayDemo6 { 245 public static void main(String[] args) { 246 //定义数组 247 int[] arr = {1,2,3}; 248 249 //System.out.println(arr[3]); 250 251 //引用类型的常量：空常量 null 252 arr = null; 253 System.out.println(arr[0]); 254 } 255 } 256 257 258 259 /* 260 数组遍历：就是依次输出数组中的每一个元素。 261 262 注意：数组提供了一个属性length，用于获取数组的长度。 263 格式：数组名.length 264 */ 265 class ArrayTest { 266 public static void main(String[] args) { 267 //定义数组 268 int[] arr = {11,22,33,44,55}; 269 270 //获取每一个元素 271 //如何获取呢?我们知道数组名结合编号(索引)就可以找到数据 272 System.out.println(arr[0]); 273 System.out.println(arr[1]); 274 System.out.println(arr[2]); 275 System.out.println(arr[3]); 276 System.out.println(arr[4]); 277 System.out.println("--------------------"); 278 279 //虽然这种做法可以，但是不是我想要的 280 //我们发现，代码的重复度很高 281 //输出语句，数组名都是相同的，仅仅是索引是变化的 282 //我们就可以使用循环搞定索引值 283 for(int x=0; x<5; x++) { 284 //x=0,1,2,3,4 285 System.out.println(arr[x]); 286 } 287 System.out.println("--------------------"); 288 289 //从0开始我们是明确的，但是为什么到5呢，我们是数了一下数组的个数 290 //继续看下个数组如何遍历 291 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,11,2,2,3,4,5,7,8,5,3,5,6,8,7,}; 292 //而我们在很多时候，数组的元素不能靠数 293 //这个时候，数组就给我们提供了一个属性：length专门用于获取数组的长度 294 //格式：数组名.length 返回数组的长度 295 System.out.println(arr.length); 296 System.out.println(arr2.length); 297 System.out.println("--------------------"); 298 299 //改进第一个程序 300 for(int x=0; x<arr.length; x++) { 301 System.out.println(arr[x]); 302 } 303 System.out.println("--------------------"); 304 305 //我们如果想要对多个数组进行遍历，每个数组的遍历我们都把代码写一遍，麻烦不 306 //麻烦，所以，我们准备用方法改进。 307 //用方法改进后，请调用 308 printArray(arr); 309 System.out.println("--------------------"); 310 printArray(arr2); 311 System.out.println("--------------------"); 312 printArray2(arr); 313 } 314 315 /* 316 遍历数组的方法 317 318 两个明确： 319 返回值类型：void 320 参数列表：int[] arr 321 */ 322 public static void printArray(int[] arr) { 323 for(int x=0; x<arr.length; x++) { 324 System.out.println(arr[x]); 325 } 326 } 327 328 //请看改进版本 329 public static void printArray2(int[] arr) { 330 System.out.print("["); 331 for(int x=0; x<arr.length; x++) { 332 if(x == arr.length-1) { //这是最后一个元素 333 System.out.println(arr[x]+"]"); 334 }else { 335 System.out.print(arr[x]+", "); 336 } 337 } 338 } 339 } 340 341 342 343 344 345 /* 346 数组获取最值(获取数组中的最大值最小值) 347 348 分析： 349 A:定义一个数组，并对数组的元素进行静态初始化。 350 B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。 351 C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。 352 D:最后参照物里面保存的就是最大值。 353 */ 354 class ArrayTest2 { 355 public static void main(String[] args) { 356 //定义一个数组 357 int[] arr = {34,98,10,25,67}; 358 359 //请获取数组中的最大值 360 /* 361 //从数组中任意的找一个元素作为参照物 362 int max = arr[0]; 363 //然后遍历其他的元素 364 for(int x=1; x<arr.length; x++) { 365 //依次获取和参照物进行比较，如果大就留下来，如果小，就离开。 366 if(arr[x] > max) { 367 max = arr[x]; 368 } 369 } 370 //最后参照物里面保存的就是最大值。 371 System.out.println("max:"+max); 372 */ 373 374 //把这个代码用方法改进 375 //调用方法 376 int max = getMax(arr); 377 System.out.println("max:"+max); 378 379 //请获取数组中的最小值 380 int min = getMin(arr); 381 System.out.println("min:"+min); 382 } 383 384 /* 385 需求：获取数组中的最大值 386 两个明确： 387 返回值类型：int 388 参数列表：int[] arr 389 */ 390 public static int getMax(int[] arr) { 391 //从数组中任意的找一个元素作为参照物 392 int max = arr[0]; 393 //然后遍历其他的元素 394 for(int x=1; x<arr.length; x++) { 395 //依次获取和参照物进行比较，如果大就留下来，如果小，就离开。 396 if(arr[x] > max) { 397 max = arr[x]; 398 } 399 } 400 //最后参照物里面保存的就是最大值。 401 return max; 402 } 403 404 public static int getMin(int[] arr) { 405 //从数组中任意的找一个元素作为参照物 406 int min = arr[0]; 407 //然后遍历其他的元素 408 for(int x=1; x<arr.length; x++) { 409 //依次获取和参照物进行比较，如果小就留下来，如果大，就离开。 410 if(arr[x] < min) { 411 min = arr[x]; 412 } 413 } 414 //最后参照物里面保存的就是最小值。 415 return min; 416 } 417 } 418 419 420 421 422 423 424 425 426 427 /* 428 数组元素逆序 (就是把元素对调) 429 430 分析： 431 A:定义一个数组，并进行静态初始化。 432 B:思路 433 把0索引和arr.length-1的数据交换 434 把1索引和arr.length-2的数据交换 435 ... 436 只要做到arr.length/2的时候即可。 437 */ 438 class ArrayTest3 { 439 public static void main(String[] args) { 440 //定义一个数组，并进行静态初始化。 441 int[] arr = {12,98,50,34,76}; 442 443 //逆序前 444 System.out.println("逆序前："); 445 printArray(arr); 446 447 //逆序后 448 System.out.println("逆序后："); 449 //reverse(arr); 450 reverse2(arr); 451 printArray(arr); 452 } 453 454 /* 455 需求：数组逆序 456 两个明确： 457 返回值类型：void (有人会想到应该返回的是逆序后的数组，但是没必要，因为这两个数组其实是同一个数组) 458 参数列表：int[] arr 459 */ 460 public static void reverse(int[] arr) { 461 /* 462 //第一次交换 463 int temp = arr[0]; 464 arr[0] = arr[arr.length-1-0]; 465 arr[arr.length-1-0] = temp; 466 467 //第二次交换 468 int temp = arr[1]; 469 arr[1] = arr[arr.length-1-1]; 470 arr[arr.length-1-1] = temp; 471 472 //第三次交换 473 int temp = arr[2]; 474 arr[2] = arr[arr.length-1-2]; 475 arr[arr.length-1-2] = temp; 476 */ 477 //用循环改进 478 for(int x=0; x<arr.length/2; x++) { 479 int temp = arr[x]; 480 arr[x] = arr[arr.length-1-x]; 481 arr[arr.length-1-x] = temp; 482 } 483 } 484 485 public static void reverse2(int[] arr) { 486 for(int start=0,end=arr.length-1; start<=end; start++,end--) { 487 int temp = arr[start]; 488 arr[start] = arr[end]; 489 arr[end] = temp; 490 } 491 } 492 493 //遍历数组 494 public static void printArray(int[] arr) { 495 System.out.print("["); 496 for(int x=0; x<arr.length; x++) { 497 if(x == arr.length-1) { //这是最后一个元素 498 System.out.println(arr[x]+"]"); 499 }else { 500 System.out.print(arr[x]+", "); 501 } 502 } 503 } 504 } 505 506 507 508 509 510 511 512 513 514 515 /* 516 数组查表法(根据键盘录入索引,查找对应星期) 517 意思是：String[] strArray = {"星期一","星期二",...}; 518 */ 519 import java.util.Scanner; 520 521 class ArrayTest4 { 522 public static void main(String[] args) { 523 //定义一个字符串数组 524 String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"}; 525 526 //创建键盘录入对象 527 Scanner sc = new Scanner(System.in); 528 529 System.out.println("请输入一个数据(0-6)："); 530 int index = sc.nextInt(); 531 532 System.out.println("你要查找的日期是："+strArray[index]); 533 } 534 } 535 536 537 538 539 540 541 542 /* 543 需求：数组元素查找(查找指定元素第一次在数组中出现的索引) 544 分析： 545 A:定义一个数组，并静态初始化。 546 B:写一个功能实现 547 遍历数组，依次获取数组中的每一个元素，和已知的数据进行比较 548 如果相等，就返回当前的索引值。 549 */ 550 class ArrayTest5 { 551 public static void main(String[] args) { 552 //定义一个数组，并静态初始化 553 int[] arr = {200,250,38,888,444}; 554 //需求：我要查找250在这个数组中第一次出现的索引 555 int index = getIndex(arr,250); 556 System.out.println("250在数组中第一次出现的索引是："+index); 557 558 int index2 = getIndex2(arr,250); 559 System.out.println("250在数组中第一次出现的索引是："+index2); 560 561 int index3 = getIndex2(arr,2500); 562 System.out.println("2500在数组中第一次出现的索引是："+index3); 563 } 564 565 /* 566 需求：查找指定数据在数组中第一次出现的索引 567 两个明确： 568 返回值类型：int 569 参数列表：int[] arr,int value 570 */ 571 public static int getIndex(int[] arr,int value) { 572 //遍历数组，依次获取数组中的每一个元素，和已知的数据进行比较 573 for(int x=0; x<arr.length; x++) { 574 if(arr[x] == value) { 575 //如果相等，就返回当前的索引值。 576 return x; 577 } 578 } 579 //目前的代码有一个小问题 580 //就是假如我要查找的数据在数组中不存在，那就找不到，找不到，你就对应的返回吗? 581 //所以报错。 582 //只要是判断，就可能是false，所以大家要细心。 583 //如果找不到数据，我们一般返回一个负数即可，而且是返回-1 584 return -1; 585 } 586 public static int getIndex2(int[] arr,int value) { 587 //定义一个索引 588 int index = -1; 589 //有就修改索引值 590 for(int x=0; x<arr.length; x++) { 591 if(arr[x] == value) { 592 index = x; 593 break; 594 } 595 } 596 //返回index 597 return index; 598 } 599 }
小结：
1 1:方法(掌握) 2 (1)方法：就是完成特定功能的代码块。 3 注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。 4 (2)格式： 5 修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) { 6 方法体语句; 7 return 返回值; 8 } 9 10 修饰符：目前就用 public static。后面再详细讲解其他修饰符 11 返回值类型：就是功能结果的数据类型 12 方法名：就是起了一个名字，方便我们调用该方法。 13 参数类型：就是参数的数据类型 14 参数名：就是变量 15 参数分类： 16 实参：实际参与运算的数据 17 形参：方法上定义的，用于接收实际参数的变量 18 方法体语句：就是完成功能的代码块 19 return：结束方法 20 返回值：就是功能的结果，由return带给调用者。 21 (3)两个明确： 22 返回值类型：结果的数据类型 23 参数列表：参数的个数及对应的数据类型 24 (4)方法调用 25 A:有明确返回值的方法 26 a:单独调用，没有意义 27 b:输出调用，不是很好，因为我可能需要不结果进行进一步的操作。但是讲课一般我就用了。 28 c:赋值调用，推荐方案 29 B:void类型修饰的方法 30 a:单独调用 31 (5)案例： 32 A:求和方案 33 B:获取两个数中的较大值 34 C:比较两个数据是否相同 35 D:获取三个数中的最大值 36 E:输出m行n列的星形 37 F:输出nn乘法表 38 (6)方法的注意事项 39 A:方法不调用不执行 40 B:方法之间是平级关系，不能嵌套定义 41 C:方法定义的时候，参数是用，隔开的 42 D:方法在调用的时候，不用在传递数据类型 43 E:如果方法有明确的返回值类型，就必须有return语句返回。 44 (7)方法重载 45 在同一个类中，方法名相同，参数列表不同。与返回值无关。 46 47 参数列表不同： 48 参数的个数不同。 49 参数的对应的数据类型不同。 50 (8)方法重载案例 51 不同的类型的多个同名方法的比较。 52 53 2:数组(掌握) 54 (1)数组：存储同一种数据类型的多个元素的容器。 55 (2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。 56 编号的专业叫法：索引 57 (3)定义格式 58 A:数据类型[] 数组名; 59 B:数据类型 数组名[]; 60 61 推荐是用A方式，B方法就忘了吧。 62 但是要能看懂 63 (4)数组的初始化 64 A:动态初始化 65 只给长度，系统给出默认值 66 67 举例：int[] arr = new int[3]; 68 B:静态初始化 69 给出值，系统决定长度 70 71 举例：int[] arr = new int[]{1,2,3}; 72 简化版：int[] arr = {1,2,3}; 73 (5)Java的内存分配 74 A:栈 存储局部变量 75 B:堆 存储所有new出来的 76 C:方法区(面向对象部分详细讲解) 77 D:本地方法区(系统相关) 78 E:寄存器(CPU使用) 79 80 注意： 81 a:局部变量 在方法定义中或者方法声明上定义的变量。 82 b:栈内存和堆内存的区别 83 栈：数据使用完毕，就消失。 84 堆：每一个new出来的东西都有地址 85 每一个变量都有默认值 86 byte,short,int,long 0 87 float,double 0.0 88 char '\u0000' 89 boolean false 90 引用类型 null 91 数据使用完毕后，在垃圾回收器空闲的时候回收。 92 (6)数组内存图 93 A:一个数组 94 B:二个数组 95 C:三个数组(两个栈变量指向同一个堆内存) 96 (7)数组的常见操作 97 A:遍历 98 方式1： 99 public static void printArray(int[] arr) { 100 for(int x=0; x<arr.length; x++) { 101 System.out.println(arr[x]); 102 } 103 } 104 105 方式2： 106 public static void printArray(int[] arr) { 107 System.out.print("["); 108 for(int x=0; x<arr.length; x++) { 109 if(x == arr.length-1) { 110 System.out.println(arr[x]+"]"); 111 }else { 112 System.out.println(arr[x]+", "); 113 } 114 } 115 } 116 B:最值 117 最大值： 118 public static int getMax(int[] arr) { 119 int max = arr[0]; 120 121 for(int x=1; x<arr.length; x++) { 122 if(arr[x] > max) { 123 max = arr[x]; 124 } 125 } 126 127 return max; 128 } 129 130 最小值： 131 public static int getMin(int[] arr) { 132 int min = arr[0]; 133 134 for(int x=1; x<arr.length; x++) { 135 if(arr[x] < min) { 136 min = arr[x]; 137 } 138 } 139 140 return min; 141 } 142 C:逆序 143 方式1： 144 public static void reverse(int[] arr) { 145 for(int x=0; x<arr.length/2; x++) { 146 int temp = arr[x]; 147 arr[x] = arr[arr.length-1-x]; 148 arr[arr.length-1-x] = temp; 149 } 150 } 151 152 方式2： 153 public static void reverse(int[] arr) { 154 for(int start=0,end=arr.length-1; start<=end; start++,end--) { 155 int temp = arr[start]; 156 arr[start] = arr[end]; 157 arr[end] = temp; 158 } 159 } 160 D:查表 161 public static String getString(String[] strArray,int index) { 162 return strArray[index]; 163 } 164 E:基本查找 165 方式1： 166 public static int getIndex(int[] arr,int value) { 167 for(int x=0; x<arr.length; x++) { 168 if(arr[x] == value) { 169 return x; 170 } 171 } 172 173 return -1; 174 } 175 176 方式2： 177 public static int getIndex(int[] arr,int value) { 178 int index = -1; 179 180 for(int x=0; x<arr.length; x++) { 181 if(arr[x] == value) { 182 index = x; 183 break; 184 } 185 } 186 187 return index; 188 }