├── 2.txt └── README.md /README.md: -------------------------------------------------------------------------------- 1 | # Youtube 视频: 2 | 3 | + [循序渐进学java从入门到精通 - 韩顺平](https://www.youtube.com/playlist?list=PL3rfV4zNE8CDPMYudVYZvNQU3LUQ72Mx0) 4 | 5 | + 第00讲 开山篇 6 | 7 | # java平台 8 | 9 | 1. J2SE java开发平台标准版 10 | 2. J2EE java开发平台企业版 11 | 12 | 13 | java程序需要在虚拟机上才可以运行，换言之只要有虚拟机的系统都可以运行java程序。不同系统上要安装对应的虚拟机才可以运行java程序 14 | 15 | ## 开发步骤 16 | 17 | 1. 编写源文件 (.java) 18 | 2. 编译源文件为类文件(.class)可用J2SE或J2EE编译 19 | 3. 在虚拟机上运行 20 | 21 | ## 注释 22 | 23 | + //单行注释 24 | + /* */多行注释 25 | 26 | ## java内容介绍 27 | 28 | java编程可以分成三个方向： 29 | 1. java se (j2se)桌面开发 java中的基础中的基础 30 | 2. java ee (j2ee)web开发 31 | 3. java me (j2me)手机开发 32 | 33 | 34 | # java se课程介绍 35 | # 第01讲 内容介绍 项目演示 原理剖析 36 | + java面向对象编程(基础) 37 | + java图开界面开发 38 | + java数据库编程 39 | + java文件io流编程 40 | + java网络编程 41 | + java多线程编程 42 | 43 | ## java ee基础1 44 | + java面向对象编程--数据库编程-->java se 45 | + java 基础2 46 | + html--css--javascript-->div+css 47 | 48 | ## java ee中级部分 49 | + Servlet--Jsp-->mvc模式 50 | 51 | ## java ee高级部分 52 | + Struts--Ejb--Hibernate--Spring--Ajax(ext,dw2)-->ssh框架 53 | 54 | ## java 之父 gosling 55 | 56 | [logo]: http://www.computinghistory.org.uk/userdata/images/medium/41/46/product-74146.jpg "James Gosling, the father of the Java programming language" 57 | 58 | + 1990 sun启动 绿色计划 59 | + 1992 创建oak语言-->java 60 | + 1994 gosling参加硅谷大会演示java功能，震惊世界 61 | + 1995 sun正式发布java第一个版本，目前最新是jdk7.0 62 | 63 | ## java开发工具 64 | + 记事本. (jcreator. jbuilder退出舞台了). netbean. eclipse 65 | + 如何选择开发工具 66 | + 先选择记事本，对java有一定了解后再使用eclipse高级开发工具 67 | + 为什么呢？ 68 | 69 | 1. 更深刻的理解java技术，培养代码感 70 | 2. 有利于公司面试 71 | 72 | ## java语言的特点 73 | 1. java语言是简单的 74 | 2. java语言是面向对象的 75 | 3. java语言是跨平台(操作系统)的[即一次编译，到处运行] 76 | 4. java是高性能的 77 | 78 | ## java第一个程序hello.java 79 | + 运行java程序要安装和配置jdk 80 | + jdk是什么？ 81 | 1. jdk全称java dvevlopment kit中文java开发工具包 82 | 2. jdk是sun公司开发的 83 | 3. jdk包括jre(java runtime envirnment)java运行环境. 一堆java工具和java基础的类库(类共3600左右，常用类在150个左右) 84 | 4. 可以在[www.sun.com](http://www.oracle.com/technetwork/java/javase/downloads/index.html)下载 85 | + 开发安装jdk,用户执行需要安装jre 86 | 87 | ### 配置JDK 88 | + 添加环境变量即可 89 | + windows下配置jdk 90 | + 在计算机属性--高级设置--环境变量--添加PATH将JDK所在路径指定即可。多个环境变量设置时需要用;号进行隔开 91 | 92 | 1. 编写第一个hello.java 93 | ```java 94 | //注释 (解释) 作者： 95 | //功能：在控制台显示"hello" 96 | //日期：2013.11.28 97 | //public：表示这个类是公共的，一个java文件中只能有一个public类 98 | //class：表示这是一个类 99 | //hello：类名(公共类的类名必须和文件名一致) 100 | public class hello{ 101 | //一个主函数，相当于是程序的入口 102 | public static void main(String args[]){ 103 | //执行语句 104 | //System：是一个包 105 | //out.println是输入函数 106 | System.out.println("hello!"); 107 | } 108 | } 109 | ``` 110 | 2. 编译hello.java 使用`javac hello.java` 111 | 3. 执行hello.java 使用`java hello` 112 | 113 | ### java程序运行关系 114 | 1. java源文件(.java文件) 115 | 2. java编译器即javac.exe 116 | 3. java字节码文件(.class文件) 117 | 4. 由解释执行器即(java.exe)将字节码文件加载到java虚拟器(jvm) 118 | 5. 字节码文件(.class)就会在java虚拟机中执行 119 | 120 | 121 | # 第02讲 变量 数据类型 122 | 123 | 124 | ## 对hello.java程序进行改过使之变为一个简单的加法运算程序 125 | ```java 126 | //注释 (解释) 作者： 127 | //功能：在控制台显示"hello" 128 | //日期：2013.11.28 129 | //public：表示这个类是公共的，一个java文件中只能有一个public类 130 | //class：表示这是一个类 131 | //jiafa：类名(公共类的类名必须和文件名一致) 132 | public class jiafa{ 133 | //一个主函数，相当于是程序的入口 134 | public static void main(String args[]){ 135 | //执行语句 136 | //System：是一个包 137 | //out.println是输入函数 138 | // System.out.println("hello!"); 139 | int a=10;//定义一个变量，变量名a，它的值10 140 | int b=20;//定义一个变量，变量名b，它的值20 141 | int result=a+b;//定义一个叫result变量将变量ab相加的值赋值给result 142 | //输出结果 143 | System.out.println("结果是"+result); 144 | } 145 | } 146 | ``` 147 | ---------------------------------------------------------------- 148 | ## 为什么有变量 149 | 150 | 不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位。java中的基本数据类型的定义与c/c++中大体一致。 151 | ```java 152 | public class Test{ 153 | public static void main(String []args){ 154 | int a=1;//定义一个整形变量，取名a，并赋初值1 155 | int b=3;//定义一个整形变量，取名b，并赋初值3 156 | b=89;//给变量b赋89 157 | System.out.println(a);//输出语句，把变量a的值输出 158 | System.out.println(b);//把变量b的值输出 159 | } 160 | } 161 | ``` 162 | ---------------------------------------------------------------- 163 | # java基本语法---基本数据类型 164 | java基本数据类型 四大类型 165 | **整数类型. 小数(浮点)类型. 布尔类型. 字符类型** 166 | 167 | ## 整数类型 168 | 可以表示一个整数，常用的整数类型有：byte,short,int,long 169 | 170 | 主要区别是 数据大小范围，请大家看一个小案例。 171 | + byte 占用内存 一个字节 范围：-128至127 172 | + short 占用内存 两个字节 范围：-32768至32767 173 | + int 占用内存 四个字节 范围：-2147483648至2147483647 174 | + long 占用内存 八个字节 范围：-?至? 175 | 176 | ## 小数(浮点)类型 177 | 可以表示一个小数，常用的小数(浮点)类型有： 178 | >+ float(单精度),double(双精度) 179 | >+ float 占用内存 四个字节 范围：3.4E-38至3.4E+38 只能提供7位有效数字 180 | >+ double占用内存 八个字节 范围：1.7E-308至1.7E+308 可提供16位有效数字 181 | 182 | ## 布尔类型 183 | 可以表示"真"或者"假"，类型是boolean 184 | >比如： 185 | >boolean spBool=true; //给变量spBool定义为boolean型并赋值为真 186 | 187 | ## 字符类型 188 | 可以表示 单个字符，字符类型是char。char是两个字节(可以存放汉字) 189 | 多个字符我们称为字符串，在java中String这种数据类型表示，但是String不是基本数据类型，而是类，类是复合数据类型。 190 | >+ 结论：在java中，对char进行运算的时候，直接当做ascii码对应的整数对待。 191 | >+ 思考： 192 | ```java 193 | int test1='a'+'b'; 输出值195 194 | char test2='a'+'b'; 输出值? 195 | char test3='中'; 输出值195 196 | ``` 197 | 198 | 199 | ## java基本语法--定义变量，初始化，赋值 200 | ### 定义变量 201 | 1. 什么是定义变量？ 202 | + int a; 这就是定义了一个变量，变量名是a 203 | + float haha;这也定义了一个变量，表示一个float类型的小数，变量名是haha 204 | 205 | ### 初始化变量 206 | + 在定义变量的时候，就给值 207 | + int a=45;这就是初始化变量a 208 | ### 给变量赋值 209 | + 比如你先定义了变量：int tt; 210 | + 然后再给值tt=780; ->这就是给变量赋值 211 | 212 | ---------------------------------------------------------------- 213 | # java基本语法--基本数据类型转换 214 | ## 自动转换 215 | + int a=1.2; double b=3; 216 | >结论：数据类型可以自动的从低精度-->高精度。高精度不能转为低精度。 217 | + byte小于练习 228 | ```java 229 | int a=1; int a=1; 230 | double b=4.5; double b=4.5; 231 | a=b; b=a; 232 | 报错 成功 233 | 234 | ## 计算过程中的转换 235 | int a=3; 236 | int b=a+3.4; 237 | ``` 238 | >结论：当一个整数和一个double运算的时候，运算结果会向高精度转换 239 | 240 | 241 | # java 基本语法--运算符 242 | 243 | # 视频： 第03讲 运算符 流程控制 244 | 245 | + java中常用的算术运算符是：`+加. -减. *乘. /除. %取模` 246 | + 其实`%`运算可以得到两个数的余数。 247 | 248 | ## 算术运算符：++自加. --自减。 249 | 这两个运算符比较特殊，请大家思考一下： 250 | ```java 251 | int a=90; 252 | a++; 等同于(a=a+1) 253 | 这时a等于？ 91 254 | 255 | int b=89; 256 | b--; 等同于(b=b-1) 257 | 这时b等于？ 88 258 | 259 | int a=56; 260 | int b=a++; 261 | System.out.println(b); 56 262 | System.out.println(a); 57 263 | ***int b=++a;相当于a=a+1再将b=a； 264 | int b=a++;相当于b=a再将a=a+1。 265 | ``` 266 | ---------------------------------------------------------------- 267 | ## 算术运算符：+=左加. -=左减. /=左除. %=左取模 268 | 请大家看看几个案例，就明白了： 269 | ```java 270 | int a=90; 271 | a+=90; (相当于a=a+90) 272 | 请问，a现在等于多少？ 180 273 | 274 | float b=89.7f; 275 | b+=a; (相当于b=b+a) 276 | 请问，b现在等于多少？ 269.7 277 | 278 | int a=56;int b=90; 279 | a-=34;b%=a; (相当于a=a-34,b=b%a) 280 | System.out.println(b); 2 281 | System.out.println(a); 22 282 | ---------------------------------------------------------------- 283 | ``` 284 | # 运算符 285 | ## 关系运算符 286 | 1. ==等于； 287 | 2. ` >大于；` 288 | 3. <小于； 289 | 4. `>=大于等于；` 290 | 5. <=小于等于； 291 | 6. !=不等于 292 | ```java 293 | int a=90;int b=90; 294 | if(a==b){System.out.println("ok1");} 295 | b--; 296 | if(a>b){System.out.println("ok2");} 297 | if(a>=b){System.out.println("ok3");} 298 | ``` 299 | 请编写一个程序，该程序可以接收两个数(可以是整数，也可是小数)并判断两个数是大于？小于？还是等于？ 300 | 301 | 程序代码： 302 | ```java 303 | import java.io.*;//载入IO流包 304 | public class Demo5{ 305 | public static void main(String []args){ 306 | try{ 307 | //输入流，从键盘接收数 308 | InputStreamReader isr=new InputStreamReader(System.in); 309 | BufferedReader br=new BufferedReader(isr); 310 | //给出提示 311 | System.out.println("请输入第一个数"); 312 | //从控制台读取一行数据 313 | String a1=br.readLine(); 314 | System.out.println("请输入第二个数"); 315 | String a2=br.readLine(); 316 | //把String转为float 317 | float num1=Float.parseFloat(a1); 318 | float num2=Float.parseFloat(a2); 319 | if(num1>num2){System.out.println("第一个大");} 320 | if(num1==num2){System.out.println("相等");} 321 | if(num18){System.out.println("ok1");} 342 | b--; 343 | if(a>b && a>45){System.out.println("ok2");} 344 | if(!(a<=b)){System.out.println("ok3");} 345 | ``` 346 | # java基本语法----三大流程控制 347 | ## 顺序控制 348 | 听其名而知其意，让程序可以顺序的执行。 349 | 请大家看个案例[demo11.java]: 350 | ```java 351 | int a=7; 352 | System.out.println("a="+a); 353 | System.out.println("hello!"); 354 | a++; 355 | System.out.println("a="+a); 356 | System.out.println("0(∩_∩)0"); 357 | a++; 358 | System.out.println("a="+a); 359 | ``` 360 | ## 分支控制 361 | 让程序有选择的执行，分支控制有三种： 362 | 1. 单分支；2. 双分支；3. 多分支a 363 | 1. 单分支语法： 364 | ```java 365 | if(条件表达式){ 366 | 语句; 367 | } 368 | ``` 369 | 2. 双分支语法： 370 | ```java 371 | if(条件表达式){ 372 | 语句; 373 | }else{ 374 | 语句; 375 | } 376 | ``` 377 | 3.1. 多分支语法： 378 | ```java 379 | if(条件表达式){ 380 | 语句; 381 | }else if(条件表达式){ 382 | 语句; 383 | }else if(条件表达式){ 384 | 语句; 385 | }else{ 386 | 语句; 387 | } 388 | ``` 389 | 3.2. 多分支语法： 390 | ```java 391 | switch(条件表达式){ //***条件表达式数据类型，就和case常量表达式一致，否则就会报错。 392 | case 常量1: 393 | 语句1; 394 | //语句1至break中相当于{}可以加入相应程序代码 395 | break; //break，表示跳出switch语句 396 | case 常量2: 397 | 语句1; 398 | break; 399 | ... 400 | case 常量n: 401 | 语句n; 402 | break; 403 | default: 404 | 语句; 405 | break; 406 | } 407 | ``` 408 | *****:switch中的可用数据类型主要是：允许byte,short,int,char,enum等 409 | 410 | 1. 单分支控制作业：请大家看个案例[demo22.java]: 411 | 编写一个程序，可以输入人的年龄，如果该同学的年龄大于18岁，则输出“你年龄大于18，要为自己的行为负责!” 412 | 413 | 2. 双分支控制作业：请大家看个案例[demo33.java]: 414 | 编写一个程序，可以输入人的年龄，如果该同志的年龄大于18岁，则输出“你年龄大于18岁，要对自己的行为负责!”否则，输出“你的年龄不大这次放过你了” 415 | 416 | 3. 多分支控制作业：请大家看个案例[demo44.java] 417 | 编写一个程序，可以输入人的年龄，如果该同志的年龄大于18岁，则输出“你年龄大于18，要对自己的行业负责，送入监狱”。如果该同志的年龄大于10岁并且小于等于18，则输出“你的年龄也不小了，把你送少管所”。其它情况，则输出“小孩子，下次注意”。 418 | 419 | 4. 多分支控制作业：请大家看个案例[demo55.java] 420 | 请编写一个程序，该程序可以接收一个字符，比如：a,b,c,d,e,f,g 421 | a表示星期一，b表示星期二...根据用户的输入显示相应的信息，要求使用switch语句完成。 422 | 423 | 5. 多分支控制作业：请大家看个案例[demo66.java] 424 | 对比switch与if语句在执行分支语句的区别。 425 | ***switch分支语句不支持判断类型即boolean类型，switch只支持byte,short,int,char,enum等数据类型 426 | ------------------------------------------------------------------------------- 427 |   428 | ## 循环控制 429 | 听其名而知其意，就是让你的代码可以循环的执行。 430 | 循环控制有三种 431 | 1. for循环 语法： 432 | for(循环初值;循环条件;步长){ 433 | 语句; //循环体 434 | } 435 | 436 | 2. while循环 语法： 437 | while(循环条件){ 438 | 语句; //循环体 439 | } 440 | 特别说明：while循环是先判断在执行语句。 441 | 442 | 3. do while循环 语法： 443 | do{ 444 | 语句; //循环体 445 | }while(循环条件); 446 | 特别说明：do while循环是先执行，再判断。 447 | 448 | 请大家看个案例[demo77-88-99.java]: 449 | 编写一个程序，可以打印10句“你好，我是刘德华同志!”。请大家想想怎么做？ 450 | 1. for循环 451 | ```java 452 | for (int a=0;a<10;a++){System.out.println("你好，我是刘德华同志!");} 453 | ``` 454 | 2. while循环 455 | ```java 456 | int i=0;while(i<10){System.out.println("你好，我是刘德华同志!");i++;} 457 | ``` 458 | 3. do while循环 459 | ```java 460 | int i=0;do{System.out.println("你好，我是刘德华同志!");i++;}while(i<10) 461 | ``` 462 | 463 | 请编写一个程序，可以接收一个整数，表示层数，打印出金字塔一半。[demo100.java] 464 | ```java 465 | // 把一个复杂的问是先拆解成简单问题 466 | //三角形[Demo100.java] 467 | public class Demo100{ 468 | public static void main(String []args){ 469 | //死去活来法-->打四次 470 | int lay=4; 471 | //表示有多少层 472 | for(int i=1;i<=lay;i++){ 473 | //打印* 474 | for(int j=1;j<=i;j++){ 475 | System.out.print("*"); 476 | } 477 | System.out.println();//换行 478 | } 479 | } 480 | } 481 | ``` 482 | ------------------------------------------------------------------------------- 483 | ```java 484 | //金字塔[Demo101.java] 485 | public class Demo101{ 486 | public static void main(String []args){ 487 | int lay=10;//表示有多少层 488 | for(int i=1;i<=lay;i++){ 489 | //找出规律 490 | //1->3 2->2 3->1 4->0找出空格 491 | for(int k=1;k<=lay-i;k++){ 492 | System.out.print(" "); 493 | } 494 | //打印* 495 | //1->1 2->3 3->5 4->7找出星的规律 496 | for(int j=1;j<=(i-1)*2+1;j++){ 497 | System.out.print("*"); 498 | } 499 | System.out.println();//换行 500 | } 501 | } 502 | } 503 | ``` 504 | ------------------------------------------------------------------------------- 505 | ```java 506 | //镂空金字塔[Demo102.java] 507 | public class Demo102{ 508 | public static void main(String []args){ 509 | int lay=10;//表示有多少层 510 | for(int i=1;i<=lay;i++){ 511 | //找出规律 512 | //1->3 2->2 3->1 4->0找出空格 513 | for(int k=1;k<=lay-i;k++){ 514 | System.out.print(" "); 515 | } 516 | //打印* 517 | //1->1 2->3 3->5 4->7找出星的规律 518 | for(int j=1;j<=(i-1)*2+1;j++){ 519 | //判断该层是否是顶层或者是底层 520 | if(i==1||i==lay){ 521 | System.out.print("*"); 522 | }else{ 523 | //如果是第一个* 524 | if(j==1||j==(i-1)*2+1){ 525 | System.out.print("*"); 526 | }else{ 527 | System.out.print(" "); 528 | } 529 | } 530 | } 531 | System.out.println();//换行 532 | } 533 | } 534 | } 535 | ``` 536 | ------------------------------------------------------------------------------- 537 | ```java 538 | //空心菱形[Demo103.java] 539 | public class Demo103{ 540 | public static void main(String []args){ 541 | int lay=4;//菱形上半部行数 542 | for(int i=1;i<=lay-1;i++){ //判断循环上半部分 543 | for(int k=1;k<=lay-i;k++){ //找行内*号前输出空格 544 | System.out.print(" "); 545 | } 546 | for(int j=1;j<=(i-1)*2+1;j++){ //找行内输出星的位置 547 | if(j==1||j==(i-1)*2+1){ //判断行最小长度和最大长度，并在最小长度和最大长度上输出*号，行内输入出空格。 548 | System.out.print("*"); 549 | }else{ 550 | System.out.print(" "); 551 | } 552 | } 553 | System.out.println(); //换行 554 | } 555 | for(int i=1;i<=lay;i++){ //判断循环菱形下半部分 556 | for(int k=1;k<=i-1;k++){ //判断循环找*号前要输出空格处 557 | System.out.print(" "); 558 | } 559 | for(int j=1;j<=(lay-i)*2+1;j++){ //判断循环行长度 560 | if(j==1||j==(lay-i)*2+1){ //判断行最小长度和最大长度，并在最小长度和最大长度上输出*号，行内输入出空格。 561 | System.out.print("*"); 562 | }else{ 563 | System.out.print(" "); 564 | } 565 | } 566 | System.out.println();//输出换行 567 | } 568 | } 569 | } 570 | ``` 571 | ------------------------------------------------------------------------------- 572 | ```java 573 | //实心菱形[Demo104.java] 574 | public class Demo104{ 575 | public static void main(String []args){ 576 | int lay=4;//菱形上半部行数 577 | for(int i=1;i<=lay-1;i++){ //判断循环上半部分 578 | for(int k=1;k<=lay-i;k++){ //找行内*号前输出空格 579 | System.out.print(" "); 580 | } 581 | for(int j=1;j<=(i-1)*2+1;j++){ //找行内输出星的位置 582 | System.out.print("*"); 583 | } 584 | System.out.println(); //换行 585 | } 586 | for(int i=1;i<=lay;i++){ //判断循环菱形下半部分 587 | for(int k=1;k<=i-1;k++){ //判断循环找*号前要输出空格处 588 | System.out.print(" "); 589 | } 590 | for(int j=1;j<=(lay-i)*2+1;j++){ //判断循环行长度 591 | System.out.print("*"); 592 | } 593 | System.out.println();//输出换行 594 | } 595 | } 596 | } 597 | ``` 598 | ------------------------------------------------------------------------------- 599 | 600 | # 1. java面向对象编程(1)-类与对象 601 | 一个问题？[Demo107.java] 602 | 张老太养了两只猫猫：一只名字叫小白，今年3岁，白色。还有一只叫小花，今年100岁，花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示张老太没有这只猫猫。 603 | ```java 604 | //用前面学习过的知识写出代码 605 | public class Demo107{ 606 | public static void main(String []args){ 607 | int a=49;//输入的名字49，50 608 | int cat1age=3; //第一只猫 609 | String cat1name="小白"; 610 | String cat1color="白色"; 611 | int cat2age=100; //第二只猫 612 | String cat2name="小花"; 613 | String cat2color="花色"; 614 | switch(a){ 615 | case '1': 616 | System.out.println(cat1age+cat1color); 617 | break; 618 | case '2': 619 | System.out.println(cat2age+cat2color); 620 | break; 621 | default: 622 | System.out.println("张老太没有这只猫!"); 623 | } 624 | } 625 | } 626 | ``` 627 | ## java语言是面向对象的 628 | 计算机语言的发展向接近人的思维方式演变 629 | + 汇编语言 [面向机器] 630 | + c语言 [面向过程] 631 | + java语言 [面向对象] 632 | 633 | # 类和对象的关系 634 | 把猫的特性提取出来-->猫类-->对象(实例) 635 | -->对象(实例) 636 | -->... 637 | 注意：从猫类到对象，目前有几种说法：1. 创建一个对象；2. 实例化一个对象；3. 对类实例化...以后大家听到这些说法，不要模糊。(对象就是实例，实例就是对象)java最大的特点就是面向对象。 638 | ```java 639 | //定义猫类 640 | public class Demo105{ 641 | public static void main(String []args){ 642 | //创建一个猫对象 643 | Cat cat1=new Cat();//Cat是定义的一个数据类型 644 | //Cat cat1; 645 | //cat1=new Cat();// 等同于 Cat cat1=new Cat(); 646 | //访问属性的 对象名.属性名字 647 | cat1.age=3; 648 | cat1.name="小白"; 649 | cat1.color="白色"; 650 | 651 | //创建第二只猫 652 | Cat cat2=new Cat(); 653 | cat2.age=100; 654 | cat2.name="小花"; 655 | cat2.color="花色"; 656 | } 657 | } 658 | 659 | //java中如何定义一个类？[类名的首写字母大写]可根据程序的需要定义类 660 | class Cat{ 661 | //下面的就是类的成员变量/属性 662 | int agr; 663 | String name; 664 | String color; 665 | Master myMaster; 666 | } 667 | 668 | //引用类型，比如建个主人类 669 | class Master{ 670 | int age; 671 | String name; 672 | String address; 673 | } 674 | ``` 675 | 类和对象的区别和联系 676 | 1. 类是抽象的，概念的，代表一类事物，比如人类，猫类.. 677 | 2. 对象是具体的，实际的，代表一个具体事物 678 | 3. 类对象的模板，对象是类的一个个体，实例 679 | 680 | ## 类--如何定义类 681 | 一个全面的类定义比较复杂，如： 682 | package 包名; 683 | class 类名 extends 父类 implements 684 | 接口名{ 685 | 成员变量; 686 | 构造方法; 687 | 成员方法; 688 | } 689 | 690 | 要透彻的掌握类，必须要了解类的构成 691 | class 类名{ ----> 待定... 692 | 成员变量; 693 | } 694 | 695 | 类--类的成员变量 696 | 成员变量是类的一个组成部分，一般是基本数据类型，也可是引用类型。比如我们前面定义猫类的int age 就是成员变量。 697 | 698 | 对象--如何创建对象 699 | 创建一个对象有两种方法 700 | 1. 先声明再创建 701 | 1. 对象声明：类名 对象名 702 | 2. 对象创建：对象名=new 类名() 703 | 704 | 2. 一步到位法 705 | 类名 对象名=new 类名() 706 | 707 | 对象--如何访问(使用)对象的成员变量 708 | 对象名.变量名; //简单先这样理解，以后加下控制符此表达就不准确了。 709 | ***对象总是存在内存中的 710 | 711 | 一个小思考题[Demo.105.java] 712 | 为了让大家加深印象，我们定义一个人类(Person)(包括名字. 年龄)。用一步到位法去创建一个对象 713 | ↓ 714 | 我们看看下面一段代码: 715 | ```java 716 | System.out.printlin(b.age); 717 | Person a=new Person(); → 请问：b.age究竟是多少？ 718 | a.age=10; 719 | a.name="小明"; 720 | Person b; 721 | b=a; 722 | ``` 723 | ***对象总是存在内存中的 724 | 一个小思考题[Demo106.java] 725 | 在明白对象是如何在内存中存在后，请大家再看看下面的思考题，请问会输出什么信息？ 726 | ```java 727 | Person1 a=new Person1(); 728 | a.age=10; 729 | a.name="小明"; 730 | Person1 b; 731 | b=a; 732 | System.out.println(b.name);//输出“小明” 733 | b.age=200; 734 | System.out.println(a.age);//输出a.age为200 735 | ``` 736 | *****重点也是难点 737 | 类--成员方法的初步介绍 738 | 在某些情况下，我们要需要定义成员方法。比如人类：除了有一些属性外(成员变量表示的年龄. 姓名...)，我们人类还有一些行为比如：可以说话. 跑步..，通过学习，我们人类还可以做算术题。这时就要用成员方法才能完成。现在要求对Person类完善： 739 | 1. 添加speak成员方法，输入出：我是一个好人 740 | 2. 添加jisuan成员方法，可以计算从1+..+1000的结果 741 | 3. 修改jisuan成员方法，该方法可以接收一个数n，计算从1+..+n的结果 742 | 4. 添加add成员方法，可以计算两个数的和 743 | 744 | 745 | 746 | # 类--类的成员方法(成员函数)定义 747 | 成员方法也叫成员函数，这里希望大家不要被两个名词搞晕了。 748 | public 返回数据类型 方法名(参数列表) 749 | { 750 | 语句;//方法(函数)主体 751 | } 752 | 1. 参数列表：表示成员函数输入 753 | 2. 数据类型(返回类型)：表示成员函数输出 754 | 3. 函数主体：表示为了实现某一功能代码块 755 | ```java 756 | //类的调用及方法调用[Demo108.java] 757 | public class Demo108{ 758 | public static void main(String []args){ 759 | Person p1=new Person(); 760 | p1.speak();//调用speak方法 761 | p1.jiSuan();//调用计算方法 762 | p1.jiSuan(200);//调用可以传入参数的计算方法 763 | p1.add(12,10);//调用两个数的和 764 | 765 | int res=p1.add2(23,34);//调用两个数的和并返回值到res中 766 | System.out.println("res返回值是："+res); 767 | System.out.println("num1+num2+num3="+p1.add3(2,2.3f,4.5f));//返回类型一定要一致否则报错。 768 | } 769 | } 770 | //定义名字的几个方法： 771 | //1. 驼峰法 如myCry；2. 下划线法my_cry 772 | //方法名在有不同参数的情况下可以使用同一个方法名，即有参数和没参数的方法可以同名 773 | class Person{ //请注意类名首写字母应为大写如Person为类名 774 | int age; 775 | String name; 776 | //1. 可以输出我是好人方法 777 | public void speak(){ //请注意方法名的首写字母应为小写如speak为方法名 778 | System.out.println("我是一个好人"); 779 | } 780 | //2. 可以计算1+..+1000的方法 781 | public void jiSuan(){ 782 | int result=0; 783 | for(int i=1;i<=1000;i++){ 784 | result=result+i; 785 | } 786 | System.out.println("1+..+1000结果是"+result); 787 | } 788 | //3. 带参数的成员方法,可以输入n值并计算1+..+n 789 | public void jiSuan(int n){ 790 | int result=0; 791 | for(int i=1;i<=n;i++){ 792 | result+=i; 793 | } 794 | System.out.println("1+..+n结果是"+result); 795 | } 796 | //4. 计算两个数的和 797 | public void add(int num1,int num2){ 798 | int result=0; //与下面一句等同于return num1+num2; 799 | result=num1+num2; 800 | System.out.println("num1+num2="+result); 801 | } 802 | //5. 计算两个数的和，并将结果返回给主调(调用它的)函数 803 | //注意：返回类型和返回结果的类型要一致 804 | //注意：在调用某个成员方法的时候，给出的具体数值的个数 805 | //和类型要相匹配。 806 | public int add2(int num1,int num2){ 807 | return num1+num2; 808 | } 809 | //6. 计算两个float数的和，并将结果返给主调函数 810 | public float add3(int num1,float num2,float num3){ 811 | return num1+num2+num3; 812 | } 813 | } 814 | ``` 815 | ## 类--类的成员方法(函数)--如何理解 816 | 如何理解方法这个概念，给大家举个通俗的示例： 817 | 程序员调用方法：给方法必要的输入，方法返回结果。 818 | 819 | 类的成员方法--声明 820 | public int test(int a);/*方法声明*/ 821 | 这句话的作用是声明该方法，声明的格式为： 822 | 访问修饰符 数据类型 函数名(参数列表); 823 | 在给Person类添加add方法的例题中，我们看到的关键字return，它的功能是把表达式的值返回的值返回给主调函数的方法。 824 | return 表达式; 825 | 826 | 类的成员方法(函数)--特别说明 827 | 1. 方法的参数列表可以是多个 828 | 案例：在Person类中编写一个成员方法，从键盘输入三个数，返回最大的那个数。 829 | 参数列表可以是多个，并且数据类型可以是任意的类型int float double char.. 830 | 访问修饰符 返回数据类型 函数名(参数列表){ 831 | 语句; //函数主体 832 | } 833 | 834 | 2. 方法可以没有返回值 835 | 案例：编写一个函数，从控制台输入一个整数打印出对应的金字塔。 836 | 返回类型可以是任意的数据类型(int,float,double,char..)也可以没有返回值void表示没有返回值 837 | 访问修饰符 返回数据类型 函数名(形参列表){ 838 | 语句; //函数主体 839 | } 840 | 841 | 类的成员方法(函数)--小练习 842 | 案例：编写一个成员函数，从键盘输入一个整数(1-9)，打印出对应的乘法表[Demo110.java] 843 | //实例键盘输入打印乘法表[Demo110.java] 844 | ```java 845 | import java.io.*; 846 | public class Demo110{ 847 | public static void main(String []args){ 848 | Cfb jiu=new Cfb(); 849 | jiu.cf(); 850 | } 851 | } 852 | class Cfb{ 853 | public void cf(){ 854 | try{ 855 | //输入流，从键盘接收数 856 | InputStreamReader isr=new InputStreamReader(System.in); 857 | BufferedReader br=new BufferedReader(isr); 858 | //给出提示 859 | System.out.println("请输入1-9，按0退出:"); 860 | //从控制台读取一行数据 861 | String a1=br.readLine(); 862 | //把String转为int 863 | int num1=Integer.decode(a1); 864 | for(int i=1;i<=num1;i++){ 865 | for(int j=1;j<=i;j++){ 866 | System.out.print(i+"×"+j+"="+(i*j)+"\t"); 867 | } 868 | System.out.println(); 869 | } 870 | }catch(Exception e){ 871 | e.printStackTrace(); 872 | } 873 | } 874 | } 875 | ``` 876 | 案例：编写函数，使给定的一个二维数组(3×3)转置 877 | 878 | # 类定义的完善 879 | 在介绍了成员方法后，我们类的定义就可以完善一步： 880 | class 类名{ class 类名{ 待定 881 | 成员变量; → 成员变量; → 882 | } 成员方法; 883 | } 884 | 885 | 小结：1.先设计类；2.然后根据类创建对象。 886 | 小练习： 887 | 1. 设计计算机类，要求如下：[Demo109.java] 888 | 属性：品牌(Brand). 颜色(Color). cpu型号(CPU). 内存容量(Memory). 硬盘大小(Harddisk). 价格(Price). 工作状态(Work) 889 | 方法：打开(Open). 关闭(Close). 休眠(Sleep) 890 | 创建一个计算机对象，调用打开，关闭方法 891 | ```java 892 | //计算机类与对象的代码 893 | import java.io.*;//加载IO流包 894 | public class Demo109{ 895 | public static void main(String []args){ 896 | Computer Pc=new Computer(); 897 | Pc.Brand="品牌"; 898 | Pc.Color="颜色"; 899 | Pc.Cpu="Cpu型号"; 900 | Pc.Memory="内存容量"; 901 | Pc.Hd="硬盘容量"; 902 | Pc.Price="价格"; 903 | Pc.Work="工作状态"; 904 | try{ 905 | //输入流，从键盘接收数 906 | InputStreamReader isr=new InputStreamReader(System.in); 907 | BufferedReader br=new BufferedReader(isr); 908 | //给出提示 909 | System.out.println("请输入0-9控制机器"); 910 | //从控制台读取一行数据 911 | String a1=br.readLine(); 912 | //把String转为float 913 | float num1=Float.parseFloat(a1); 914 | if(num1==0){Pc.open();} 915 | else if(num1==1){Pc.close();} 916 | else if(num1==2){Pc.sleep();} 917 | else if(num1==3){System.out.println(Pc.Brand);} 918 | else if(num1==4){System.out.println(Pc.Color);} 919 | else if(num1==5){System.out.println(Pc.Cpu);} 920 | else if(num1==6){System.out.println(Pc.Memory);} 921 | else if(num1==7){System.out.println(Pc.Hd);} 922 | else if(num1==8){System.out.println(Pc.Price);} 923 | else if(num1==9){System.out.println(Pc.Work);} 924 | else {System.out.println("输入错误!");} 925 | }catch(Exception e){ 926 | e.printStackTrace(); 927 | } 928 | } 929 | } 930 | 931 | class Computer{ 932 | String Brand; 933 | String Color; 934 | String Cpu; 935 | String Memory; 936 | String Hd; 937 | String Price; 938 | String Work; 939 | public void open(){ 940 | System.out.println("开机"); 941 | } 942 | public void close(){ 943 | System.out.println("关机"); 944 | } 945 | public void sleep(){ 946 | System.out.println("休眠"); 947 | } 948 | } 949 | ``` 950 | 2. 采用面向对象思想设计超级马里奥游戏人物 951 | 952 | 953 | ------------------------------------------------------------------------------- 954 | 955 | # 2. java面向对象编程(1)-构造方法(函数) 956 | 类的构造方法介绍 957 | 什么是构造方法呢？在回答这个问题之前，我们来看一个需求：前面我们在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在我要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做？ 958 | ↓ 959 | 你可以在定义类的时候，定义一个构造方法即可。 960 | 961 | 构造方法是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点： 962 | 1. 方法名和类名相同 963 | 2. 没有返回值 964 | 3. 在创建一个类的新对象时，系统会自动的调用该类的构造方法完成对新对象的初始化。 965 | 特别说明： 966 | 一个类可以定义多个不同的构造方法。 967 | ```java 968 | //例人类构造方法[Demo111.java] 969 | public class Demo111{ 970 | public static void main(String []args){ 971 | Person p1=new Person(12,"顺平");//给予不同的初始值，调用的构造方法不同，构造方法虽同名，但系统会根据初始值来选定构造方法。 972 | } 973 | } 974 | //定义一个人类 975 | class Person{ 976 | int age; 977 | String name; 978 | //默认构造方法 979 | public Person(){ 980 | } 981 | //构造方法的主要用处是：初始化你的成员属性(变量) 982 | //构造方法 983 | public Person(int age,String name){ 984 | System.out.println("我是构造1"); 985 | age=age; 986 | name=name; 987 | } 988 | //构造方法2 989 | public Person(String name){ 990 | System.out.println("我是构造2"); 991 | name=name; 992 | } 993 | } 994 | ``` 995 | 类的默认构造方法 996 | 有些同志可能会问？亲爱的老师，我们在没有学习构造函数前不是也可以创建对象吗？ 997 | 是这样的，如果程序员没有定义构造方法，系统会自动生成一个默认构造方法。比如Person类Person (){}; 998 | 当创建一个Person对象时Person per1=new Person();默认的构造函数就会被自动调用。 999 | 1000 | 类的构造方法小结： 1001 | 1. 构造方法名和类名相同； 1002 | 2. 构造方法没有返回值； 1003 | 3. 主要作用是完成对新对象的初始化； 1004 | 4. 在创建新对象时，系统自动的调用该类的构造方法； 1005 | 5. 一个类可以有多个构造方法； 1006 | 6. 每个类都有一个默认的构造方法。 1007 | 1008 | 类定义的改进 1009 | 在提出构造方法后，我们类的定义就应该更加完善了： 1010 | class 类名{ class 类名{ class 类名{ 1011 | 成员变量; 成员变量; 成员变量; 1012 | } → 成员方法; → 构造方法; → 待定.. 1013 | } 成员方法 1014 | } 1015 | java面向对象编程(2)--this 1016 | 一个问题？ 1017 | 请大家看一段代码：(Demo112.java) 1018 | *重点*：this是属于一个对象，不属于类的。 1019 | java虚拟机会给每个对象分配this,代表当前对象。坦白的讲，要明白this不是件容易的事 1020 | 注意事项：this不能在类定义的外部使用，只能在类定义的方法中使用 1021 | ```java 1022 | /* 1023 | this的必要性 1024 | */ 1025 | public class Demo112{ 1026 | public static void main(String []args){ 1027 | Dog dog1=new Dog(2,"大黄"); 1028 | Person p1=new Person(dog1,23,"郭德纲"); 1029 | Person p2=new Person(dog1,24,"刘谦"); 1030 | p1.showInfo(); 1031 | p1.dog.showInfo(); 1032 | } 1033 | } 1034 | //定义一个人类 1035 | class Person{ 1036 | //成员变量 1037 | int age; 1038 | String name; 1039 | Dog dog;//引用类型 1040 | public Person(Dog dog,int age,String name){ 1041 | //可读性不好 1042 | //age=age; 1043 | //name=name; 1044 | this.age=age; //this.age指this代词指定是成员变量age 1045 | this.name=name; //this.name指this代词指定是成员变量name 1046 | this.dog=dog; 1047 | } 1048 | //显示人名字 1049 | public void showInfo(){ 1050 | System.out.println("人名是："+this.name); 1051 | } 1052 | } 1053 | 1054 | class Dog{ 1055 | int age; 1056 | String name; 1057 | public Dog(int age,String name){ 1058 | this.age=age; 1059 | this.name=name; 1060 | } 1061 | //显示狗名 1062 | public void showInfo(){ 1063 | System.out.println("狗名叫"+this.name); 1064 | } 1065 | } 1066 | ``` 1067 | ------------------------------------------------------------------------------- 1068 | 类变量--提出问题？ 1069 | 提出问题的主要目的就是让大家思考解决之道。 1070 | ```java 1071 | public class Demo113{ 1072 | public static void main(String []args){ 1073 | /* int total=0; 1074 | Child ch1=new Child(3,"妞妞"); 1075 | ch1.joinGame(); 1076 | total++; 1077 | Child ch2=new Child(4,"小小"); 1078 | ch2.joinGame(); 1079 | total++; 1080 | */ 1081 | Child ch1=new Child(3,"妞妞"); 1082 | ch1.joinGame(); 1083 | Child ch2=new Child(4,"小小"); 1084 | ch2.joinGame(); 1085 | Child ch3=new Child(5,"大大"); 1086 | ch3.joinGame(); 1087 | System.out.println("共有="+Child.total); 1088 | } 1089 | } 1090 | //定义小孩类 1091 | class Child{ 1092 | int age; 1093 | String name; 1094 | //static公共函数,total是静态变量，因此它可以被任何一个对象访问 1095 | static int total=0; 1096 | public Child(int age,String name){ 1097 | this.age=age; 1098 | this.name=name; 1099 | } 1100 | public void joinGame(){ 1101 | total++; 1102 | System.out.println("有一个小孩加入了"); 1103 | } 1104 | } 1105 | ``` 1106 | ------------------------------------------------------------------------------- 1107 | # java面向对象编程(2)--类变量. 类方法 1108 | 什么是类变量？ 1109 | 类变量是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。 1110 | 1111 | 如何定义类变量？ 1112 | 定义语法： 1113 | 访问修饰符 static 数据类型 变量名; 1114 | 1115 | 如何访问类变量？ 1116 | 类名.类变量名 或者 对象名.类变量名 1117 | ```java 1118 | //类变量的程序演示[Demo114.java] 1119 | public class Demo114{ 1120 | static int i=1; 1121 | static{ 1122 | //该静态区域块只被执行一次 1123 | i++; 1124 | System.out.println("执行一次"); 1125 | } 1126 | public Demo114(){ //建立Demo114()构造函数 1127 | System.out.println("执行二次"); 1128 | i++; 1129 | } 1130 | public static void main(String []args){ 1131 | Demo114 t1=new Demo114(); //创建t1对象实例并调用Demo114函数 1132 | System.out.println(t1.i); 1133 | 1134 | Demo114 t2=new Demo114(); 1135 | System.out.println(t2.i); 1136 | } 1137 | } 1138 | ``` 1139 | ------------------------------------------------------------------------------- 1140 | 什么是类方法，为什么有类方法？ 1141 | 类方法是属于所有对象实例的，其形式如下： 1142 | 访问修饰符 static 数据返回类型 方法名(){} 1143 | 注意：类方法中不能访问非静态变量(类变量)。 1144 | 使用：类名.类方法名 或者 对象名.类方法名 1145 | *重点*static静态的方法可以访问static静态变量，不能访问非静态变量(类变量) 1146 | 非静态方法可以访问非静态变量(类变量)同时也可以访问static静态变量。 1147 | ```java 1148 | //统计总学费的程序代码，加深static静态的方法由静态变量的访问[Demo115.java] 1149 | public class Demo115{ 1150 | public static void main(String []args){ 1151 | //创建一个学生 1152 | Stu stu1=new Stu(29,"aa",340); 1153 | Stu stu2=new Stu(29,"aa",240); 1154 | System.out.println(Stu.getTotalFee()); 1155 | } 1156 | } 1157 | 1158 | //学生类 1159 | class Stu{ 1160 | int age; 1161 | String name; 1162 | int fee; 1163 | static int totalFee; 1164 | public Stu(int age,String name,int fee){ 1165 | this.age=age; 1166 | this.name=name; 1167 | totalFee+=fee; 1168 | } 1169 | //返回总学费[这是一个类方法(静态方法)] 1170 | //java中规则：类变量原则上用类方法去访问或操作 1171 | public static int getTotalFee(){ 1172 | return totalFee; 1173 | } 1174 | } 1175 | ``` 1176 | 类变量小结 1177 | 1. 什么时候需要用类变量 1178 | 案例[Demo115.java]：定义学生类，统计学生共交多少钱？ 1179 | 用类变量，属于公共的属性 1180 | 2. 类变量与实例变量区别： 1181 | 加上static称为类变量或静态变量，否则称为实例变量 1182 | 类变量是与类相关的，公共的属性 1183 | 实例变量属于每个对象个体的属性 1184 | 类变量可以通过 [类名.类变量名] 直接访问 1185 | 类方法小结 1186 | 1. 什么时候需要用类方法 1187 | 案例[Demo115.java]：定义学生类，统计学生共交多少钱？ 1188 | 类方法属于与类相关的，公共的方法 1189 | 实例方法属于每个对象个体的方法 1190 | 类方法可以通过 [类名.类方法名] 直接访问 1191 | 1192 | ------------------------------------------------------------------------------- 1193 | # java面向对象编程的四大特征 1194 | 抽象/封装/继承/多态 1195 | 1196 | ## 抽象 1197 | 1. 简单理解 1198 | 我们在前面去定义一个类时候，实际上就是把一类事物的共有的属性和行为提取出来，形成一个物理模型(模版)。这种研究问题的方法称为抽象。 1199 | 1200 | ## 封装--什么是封装 1201 | 封装就是把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作(成员方法)，才能对数据进行操作。 1202 | 1203 | 封装--访问控制修饰符 1204 | 电视机的开关，对音量，颜色，频道的控制是公开的，谁都可以操作，但是对机箱后盖，主机板的操作却不是公开的，一般是由专业维修人员来玩。那么java中如何实现这种类似的控制呢？不能随便查看人的年龄，工资等隐私[Demo116.java] 1205 | ```java 1206 | //封装案例[Demo116.java] 1207 | public class Demo116{ 1208 | public static void main(String []args){ 1209 | //创建一个职员 1210 | Clerk clerk1=new Clerk("小花",24,4567.6f); 1211 | System.out.println("名字是"+clerk1.name+"薪水"+clerk1.getSal()); 1212 | } 1213 | } 1214 | //职员 1215 | class Clerk{ 1216 | public String name; 1217 | //private私有的，public公有的 1218 | private int age; 1219 | private float salary; 1220 | 1221 | public Clerk(String name,int age,float sal){ 1222 | this.name=name; 1223 | this.age=age; 1224 | this.salary=sal; 1225 | } 1226 | //通过一个成员方法去控制和访问私有的属性 1227 | public float getSal(){ 1228 | return this.salary; 1229 | } 1230 | } 1231 | ``` 1232 | 封装--访问控制修饰符 1233 | java提供四种访问控制修饰符号控制方法和变量的访问权限： 1234 | 1. 公开级别：用public修饰，对外公开 1235 | 2. 受保护级别：用protected修饰，对子类和同一个包中的类公开 1236 | 3. 默认级别：没有修饰符号，向同一个包的类公开 1237 | 4. 私有级别：用private修饰，只有类本身可以访问，不对外公开 1238 | 1239 | 4种访问级别的访问范围 1240 | | 访问级别 | 访问控制修饰符 | 同类 | 同包 | 子类 | 不同包 | 1241 | | -------- | -------------- | ---- | ---- | ---- | ------ | 1242 | | 公 开 | Public | √ | √ | √ | √ | 1243 | | 受保护 | Protected | √ | √ | √ | ╳ | 1244 | | 默 认 | 没有修饰符 | √ | √ | ╳ | ╳ | 1245 | | 私 有 | private | √ | ╳ | ╳ | ╳ | 1246 | 1247 | 包--必要性 1248 | 问题的提出，请看下面的一个场景[eclipse] 1249 | 现在有两个程序员共同开发一个java项目，程序员xiaoming希望定义一个类取名Dog，程序员xiaoqiang也想定义一个类也叫Dog。两个程序员为此还吵了起来，怎么办？ 1250 | 1251 | 包--三大作用 1252 | 1. 区分相同名字的类 1253 | 2. 当类很多时，可以很好的管理类 1254 | 3. 控制访问范围 1255 | 1256 | 包--换包命令 1257 | package com.自定义名字; 1258 | 注意：打包命令一般放在文件开始处。 1259 | 1260 | 包--命名规范 1261 | 小写字母 比如 com.sina.shunping 1262 | 1263 | 包--常用的包 1264 | 一个包下，包含很多的类，java中常用的包有： 1265 | java.lang.* 包 自动引入 java.util.* 工具包 1266 | java.net.* 包 网络开发包 java.awt.* 包 窗口工具包 1267 | 1268 | 包--如何引入包 1269 | 语法：import 包; 1270 | 比如import java.awt.*; 1271 | 我们引入一个包的主要目的要使用该包下的类 1272 | 1273 | 定义类的改进 1274 | 在提出包后，我们类的定义就更加完善了： 1275 | class 类名{ class 类名{ class类名{ package包名; 待定.. 1276 | 成员变量; → 成员变量; → 成员变量; → class 类名{ → 1277 | } 成员方法; 构造方法; 成员变量; 1278 | } 成员方法; 构造方法; 1279 | } 成员方法; 1280 | } 1281 | ------------------------------------------------------------------------------- 1282 | ## 继承--为什么有？[Demo117.java] 1283 | ```java 1284 | //功能：说明继承的重要性 1285 | 1286 | package com.abc;//包名 1287 | public class Demo117 { 1288 | public static void main(String[] args) { 1289 | Pupil p1=new Pupil(); 1290 | p1.printName(); 1291 | } 1292 | } 1293 | 1294 | //将学生的共有属性提取，做一个父类 1295 | class Stu{ 1296 | //定义成员属性 1297 | protected int age; 1298 | public String name; 1299 | public float fee; 1300 | private String job;//私有将不被继承 1301 | 1302 | //编程中，如果你不希望子类继承某个属性或方法 1303 | //则将其声明为private即可 1304 | public void printName(){ 1305 | System.out.println("名字"+this.name); 1306 | } 1307 | } 1308 | 1309 | //小学生类 1310 | class Pupil extends Stu{ 1311 | //交学费 1312 | public void pay(float fee){ 1313 | this.fee=fee; 1314 | } 1315 | } 1316 | //幼儿 1317 | class Pre extends Pupil{ 1318 | //交学费 1319 | public void pay(float fee){ 1320 | this.fee=fee*1.5f; 1321 | } 1322 | } 1323 | //中学生类 1324 | class MiddleStu extends Stu{ 1325 | //交学费 1326 | public void pay(float fee){ 1327 | this.fee=fee*0.8f; 1328 | } 1329 | } 1330 | //大学生类 1331 | class ColStu extends Stu{ 1332 | //交学费 1333 | public void pay(float fee){ 1334 | this.fee=fee*0.1f; 1335 | } 1336 | } 1337 | ``` 1338 | 继承--解决之道 1339 | 继承可以解决代码复用，让我们的编程更加靠近人类思维。当多个类存在相同的属性(变量)和方法时，可以从这些类中抽象出父类(比如刚才的Student)，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends语句来声明继承父类： 1340 | 语法：class 子类 extends 父类 1341 | 这样，子类就会自动拥有父类定义的某些属性和方法。 1342 | 1343 | 继承--深入讨论 1344 | 1. 父类的哪些属性(变量). 方法被子类继承了？并不是父类的所有属性. 方法都可以被子类继承 1345 | 父类 子类 1346 | public 属性; public 属性; 1347 | protected 属性; 继承 protected 属性; 1348 | private 属性; → 属性; 1349 | 属性; 1350 | public 方法; public 方法; 1351 | protected 方法; protected 方法; 1352 | private 方法; 方法; 1353 | 方法; 1354 | 2. 结论 1355 | 从图可以看出，父类的public修饰符的属性和方法；protected修饰符的属性和方法；默认修饰符属性和方法被子类继承了，父类的private修饰符的属性和方法不能被子类继承。 1356 | 1357 | 继承--注意事项 1358 | 1. 子类最多只能继承一个父类(指直接继承) 1359 | 2. java所有类都是Object类的子类 (所有的子类都可以逐级继承，例:爷->父->子->孙) 1360 | 3. JDK6中有202个包3777个类. 接口. 异常. 枚举. 注释和错误 1361 | 4. 在做开发的时候，强烈建议大家多查jdk帮助文档 1362 | 5. 在使用类时，实在不知道怎么办，多使用搜索引擎 1363 | 1364 | 定义类的改进 1365 | 在提出包后，我们类的定义就更加完善了： 1366 | class 类名{ class 类名{ class类名{ package包名; 1367 | 成员变量; → 成员变量; → 成员变量; → class 类名{ 1368 | } 成员方法; 构造方法; 成员变量; 1369 | } 成员方法; 构造方法; 1370 | } 成员方法; 1371 | } ↓ 1372 | ↓←←←←←←←←←←←←←←←←←←←←←←←←← 1373 | package 包名; 1374 | class 类名 extends 父类{ 待定 1375 | 成员变量; → .... 1376 | 构造方法; 1377 | 成员方法; 1378 | } 1379 | 1380 | ------------------------------------------------------------------------------- 1381 | java面向对象编程(2)--方法重载(overload) 1382 | 方法重载(overload) 1383 | 按顺序，我们应该讲解多态，但是在讲解多态前，我们必须讲解方法重载和方法覆盖(override)。 1384 | 请编写一个类(Abc)，编写方法可以接收两个整数，返回两个数中较大的数[Demo119.java] 1385 | ```java 1386 | //方法重载(overload)getMax 1387 | public class Demo119{ 1388 | public static void main(String []args){ 1389 | Abc2 abc1=new Abc2(); 1390 | System.out.println(abc1.getMax(12,14)); 1391 | System.out.println(abc1.getMax(24f,20f)); 1392 | } 1393 | } 1394 | 1395 | class Abc2{ 1396 | //返回较大的整数 1397 | public int getMax(int i,int j){ 1398 | if(i>j){ 1399 | return i; 1400 | }else{ 1401 | return j; 1402 | } 1403 | } 1404 | public float getMax(float a,float b){ 1405 | if(a>b){ 1406 | return a; 1407 | }else{ 1408 | return b; 1409 | } 1410 | } 1411 | //如果只是返回类型不一样，能否构成重载？不能够构成重载 1412 | /* public double getMax(float d,double c){ 1413 | if(c>d){ 1414 | return c; 1415 | }else{ 1416 | return d; 1417 | } 1418 | } 1419 | //如果只是控制访问修饰符不同，能否构成重载？不能够构成重载 1420 | protected float getMax(float c,float d){ 1421 | if(c>d){ 1422 | return c; 1423 | }else{ 1424 | return d; 1425 | } 1426 | }*/ 1427 | } 1428 | ``` 1429 | 方法重载(overload)概念 1430 | 简单的说：方法重载就是在类的同一种功能的多种实现方式，到底采用哪种方式，取决于调用者给出的参数。 1431 | 注意事项： 1432 | 1. 方法名相同 1433 | 2. 方法的参数类型，个数，顺序至少有一项不同 1434 | 3. 方法返回类型可以不同(只是返回类型不一样，不能构成重载) 1435 | 4. 方法的修饰符可以不同(只是控制访问修饰符不同，不能构成重载) 1436 |   1437 | 1438 | 方法覆盖(override) 1439 | 既然子类可以继承父类的属性和方法，这样可以提高代码的复用性，这个很好，可是问题来了，假设现在我要求大家写三个类猫猫，狗狗，猪猪。我们知道这三个东东都是动物，动物必然存在相同的特点。根据类的抽象特征，我们可以把它们的相同点提取出来，形成一个父类，然后继承。 1440 | ```java 1441 | //子类方法覆盖父类方法[Demo120.java] 1442 | public class Demo120{ 1443 | public static void main(String []args){ 1444 | //创建一只猫 1445 | Cat cat1=new Cat(); 1446 | cat1.cry(); 1447 | Dog dog1=new Dog(); 1448 | dog1.cry(); 1449 | } 1450 | } 1451 | //动物类 1452 | class Animal{ 1453 | int age; 1454 | String name; 1455 | //都会叫 1456 | public void cry(){ 1457 | System.out.println("我是动物，不知道怎么叫"); 1458 | } 1459 | 1460 | } 1461 | //猫猫类 1462 | class Cat extends Animal{ 1463 | //覆盖父类方法 1464 | public void cry(){ 1465 | System.out.println("猫猫叫!"); 1466 | } 1467 | } 1468 | //狗狗类 1469 | class Dog extends Animal{ 1470 | //覆盖父类方法 1471 | public void cry(){ 1472 | System.out.println("汪汪叫!"); 1473 | } 1474 | } 1475 | ``` 1476 | 方法覆盖(override)概念 1477 | 简单的说：方法覆盖就是子类有一个方法，和父类的某个方法的名称. 返回类型. 参数一样，那么我们就说子类的这个方法覆盖了父类的那个方法。比如上个案例的Cat类中的cry方法就覆盖了Animal类的cry方法。 1478 | 注意事项： 1479 | 方法覆盖有很多条件，有些书上说的比较细，总的讲有两点一定注意： 1480 | 1. 子类的方法的返回类型，参数，方法名称，要和父类的返回类型，参数，方法名称完全一样，否则编译出错。 1481 | 2. 子类方法不能缩小父类方法的访问权限。 1482 | 1483 | =============================================================================== 1484 | 作业：上机实习题目 1485 | 1. Josephu问题(丢手帕问题) 1486 | Josephu问题为：设编号为1,2,...n的n个人围坐一圈，约定编号为k(1<=k<=n)的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。 1487 | 提示：用一个不带头结点的循环链表来处理Josephu问题：先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时，对应结点的人从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。 1488 | ```java 1489 | //Josephu问题(丢手帕问题) 1490 | //使用单向链表 1491 | public class Demo121 { 1492 | public static void main(String[] args) { 1493 | CycLink cyclink=new CycLink(); 1494 | cyclink.setLen(5);//链表长度 1495 | cyclink.createLink(); 1496 | cyclink.setK(2);//从第几个人开始数 1497 | cyclink.setM(2);//数几下 1498 | cyclink.show(); 1499 | cyclink.play(); 1500 | } 1501 | } 1502 | 1503 | class Child{ 1504 | int no; 1505 | Child nextChild=null; 1506 | public Child(int no){ 1507 | //给一个编号 1508 | this.no=no; 1509 | } 1510 | } 1511 | 1512 | //单向环形链表 1513 | class CycLink{ 1514 | //先定义一个指向链表第一个小孩的引用 1515 | //指向第一个小孩的引用，不能动 1516 | Child firstChild=null; 1517 | Child temp=null; 1518 | int len=0;//表示共有多少个小孩 1519 | int k=0; 1520 | int m=0; 1521 | //设置m数几下 1522 | public void setM(int m){ 1523 | this.m=m; 1524 | } 1525 | //设置环形链表大小 1526 | public void setLen(int len){ 1527 | this.len=len; 1528 | } 1529 | //设置从第几个人开始数数 1530 | public void setK(int k){ 1531 | this.k=k; 1532 | } 1533 | //开始play 1534 | public void play(){ 1535 | Child temp=this.firstChild; 1536 | //1.先找到开始数数的人 1537 | for(int i=1;i第二个数的关系表达式的值，输出此值； 0 2267 | 5. 用第一个数减去上面关系表达式的值，得到它们的差，输出差； 3 2268 | 6. 存储第二个数的变量累乘上式的结果，输出此变量的当前值； 15 2269 | 7. 存储第一个数的变量累加第二个变量，输出第一个变量的当前值。 18 2270 | ```java 2271 | //输入两个数完成任务集合[Work08.java] 2272 | import java.util.*;//加载包 2273 | public class Work08{ 2274 | public static void main(String []args){ 2275 | Scanner myScanner=new Scanner(System.in);//调用键盘输入 2276 | System.out.print("请输入一个数A："); 2277 | int a=myScanner.nextInt(); 2278 | System.out.print("请输入一个数B："); 2279 | int b=myScanner.nextInt(); 2280 | int e=0;//定义变量 2281 | //求和 2282 | int c=a+b; 2283 | System.out.println("和："+c); 2284 | //求平均数 2285 | int d=(a+b)/2; 2286 | System.out.println("平均数："+d); 2287 | //判断平均数是否大于第二个数 2288 | if(d>b){ 2289 | e=1; 2290 | System.out.println("平均数>第二个数"); 2291 | }else{ 2292 | e=0; 2293 | System.out.println("小于"+b+"输出判断值"+e); 2294 | } 2295 | //第一个数减去上式的值 2296 | int f=a-e; 2297 | System.out.println("第一个数减去上式的值"+f); 2298 | //第二个数乘上式的值 2299 | int g=b*f; 2300 | System.out.println("第二个数累乘上式的值"+g); 2301 | //第一个数累加并赋给第一个数 2302 | a+=g; 2303 | System.out.println("第一个数累加第二个数赋给第一个数的值"+a); 2304 | } 2305 | } 2306 | ``` 2307 | ******************************************************************************* 2308 | 第九题 2309 | 渔夫出海打鱼，收获若干 2310 | 1. 渔夫卖掉一半的鱼，然后送给海伦3条； 2311 | 2. 渔夫又卖掉剩下的鱼的2/3，自己吃掉1条； 2312 | 3. 海伦来看渔夫，问他那天打了多少鱼，渔夫数了数，还剩4条鱼，渔夫对海伦怎么说？ 2313 | ```java 2314 | //打鱼--共有多少鱼[Work09.java] 2315 | public class Work09{ 2316 | public static void main(String []args){ 2317 | int total=0; 2318 | int rest=4;//剩余的鱼 2319 | total=((rest+1)*3+3)*2;//逆推 2320 | System.out.println("鱼一共有："+total); 2321 | } 2322 | } 2323 | ``` 2324 | ******************************************************************************* 2325 | 第十题 2326 | 有一只猴子摘了一堆桃子，当即吃了一半，可是桃子太好吃了，它又多吃了一个，第二天它把第一天剩下的桃子吃了一半，又多吃了一个，就这样到第十天早上它只剩下一个桃子了，问它共摘了多少桃子[Work10.java] 2327 | ```java 2328 | import java.util.*;//加载包 2329 | public class Work10{ 2330 | public static void main(String []args){ 2331 | Monkey mo=new Monkey(); 2332 | mo.scan(); 2333 | } 2334 | } 2335 | class Monkey{ 2336 | //day哪天的桃子数，sday吃了多少天剩下一个 2337 | public static int peach(int day,int sday){//建一个peach方法 2338 | if(day==sday){ 2339 | return 1; 2340 | }else{ 2341 | return (peach(day+1,sday)+1)*2;//算法返回值 2342 | } 2343 | } 2344 | public static void scan(){ //建立输入的方法 2345 | int a=1; 2346 | System.out.println("请输入要吃几天："); 2347 | Scanner sr=new Scanner(System.in); 2348 | int b=sr.nextInt(); 2349 | if(a0;i++,j--){}//错 2686 | c) 2687 | int i,k; 2688 | for(i=0,k=9;(i<10&&k>0);i++,j--){}//错 2689 | d) 2690 | int i,j 2691 | for(i=0;j=10;i<10;i++,j--){}//错 2692 | ``` 2693 | ------------------------------------------------------------------------------- 2694 | 4. 运行以下代码，将得到什么打印结果？ 2695 | ```java 2696 | int i=1; 2697 | switch(i){ 2698 | default: 2699 | System.out.println("default"); 2700 | case 0: 2701 | System.out.println("zero"); 2702 | break; 2703 | case 1; 2704 | System.out.println("one");//执行此语句 2705 | case2; 2706 | System.out.println("two");//执行此语句 2707 | } 2708 | ``` 2709 | ------------------------------------------------------------------------------- 2710 | 5. 以下代码是合法的？ 2711 | ```java 2712 | a) 2713 | float x=1;//数据类型错误 2714 | switch(x){ 2715 | case 1: 2716 | System.out.println("Got a 1");//错 2717 | } 2718 | b) 2719 | long y=1;//数据类型错误 2720 | switch(y){ 2721 | case 1: 2722 | System.out.println("Got a 1");//错 2723 | } 2724 | c) 2725 | byte x=1;//低精转高精 2726 | switch(x){ 2727 | case 1/1: 2728 | System.out.println("Got a 1");//正确 2729 | } 2730 | d) 2731 | int x=1; 2732 | int c=1; 2733 | switch(c){ 2734 | case x;//需常量 2735 | System.out.println("Got a 1");//错 2736 | break; 2737 | e) 2738 | short x=1;//数据类型错误 2739 | switch(x){ 2740 | case 3.2/3: 2741 | System.out.println("Got a 1"); 2742 | break; 2743 | } 2744 | f) 2745 | shout x=1;//数据类型错误 2746 | switch(x){ 2747 | case 1,2,3: 2748 | System.out.println("Got a 1");//错 2749 | break; 2750 | } 2751 | ``` 2752 | ------------------------------------------------------------------------------- 2753 | 6. 以下代码能否编译通过？假如能编译通过，运行时将得到什么打印结果？ 2754 | ```java 2755 | public class Myswitch{ 2756 | public static void main(String args[]){ 2757 | Myswitch ms=new Myswitch(); 2758 | ms.amethod(); 2759 | } 2760 | public void amethod(){ 2761 | for(int a=0,b=0;a<2;b=++a,System.out.println("b="+b)){ 2762 | System.out.println("a="+a); 2763 | } 2764 | } 2765 | } 2766 | 结果：a=0 2767 | b=1 2768 | a=1 2769 | b=2 2770 | ``` 2771 | ------------------------------------------------------------------------------- 2772 | 7. 以下代码能否编译通过？假如能编译通过，运行时将得到什么打印结果？ 2773 | ```java 2774 | void looper(){ 2775 | int x=0; 2776 | one: 2777 | while(x<10){ 2778 | two: 2779 | System.out.println(++x); 2780 | if(x>3) 2781 | break two; 2782 | } 2783 | }//无法编译，break two;无法返回到two标签 2784 | ``` 2785 | ------------------------------------------------------------------------------- 2786 | 8. 以下代码能否编译通过？假如能编译通过，运行时将得到什么打印结果？ 2787 | ```java 2788 | public class Hope{ 2789 | public static void main(String args[]){ 2790 | Hope h=new Hope(); 2791 | } 2792 | protected Hope(){ 2793 | int i=1; 2794 | do{ 2795 | System.out.println(i); 2796 | }while(++i<3); 2797 | } 2798 | } 2799 | 结果：1 2 2800 | ``` 2801 | ******************************************************************************* 2802 | 第十四题 2803 | 请编写一个猜拳的游戏 2804 | 有个人Tom设计他的成员变量，成员方法，可以电脑猜拳。电脑每次都会随机生成0,1,2；0表示石头. 1表示剪刀. 2表示布 2805 | ```java 2806 | //与电脑猜拳[Work14_1.java] 2807 | import java.util.*; 2808 | public class Work14_1 { 2809 | public static void main(String[] args) { 2810 | Kais.jingcyx();//调用开始游戏 2811 | } 2812 | } 2813 | //开始退出游戏类 2814 | class Kais{ 2815 | public static void jingcyx(){ 2816 | System.out.println("是否开始猜拳游戏？按1开始，按0退出"); 2817 | Scanner sr=new Scanner(System.in); 2818 | int x=sr.nextInt(); 2819 | switch (x){ 2820 | case 0: 2821 | System.out.println("已退出游戏!"); 2822 | break; 2823 | case 1: 2824 | System.out.println("游戏说明：0代表石头，1代表剪刀，2代表布"); 2825 | Caiquan.caiquan(); 2826 | break; 2827 | default: 2828 | System.out.println("输入错误，请重新输入!"); 2829 | Kais.jingcyx(); 2830 | break; 2831 | } 2832 | } 2833 | } 2834 | //猜拳游戏 2835 | class Caiquan{ 2836 | public static void caiquan(){ 2837 | int a1=0,b1=0,c1=0; 2838 | System.out.print("请输入想玩的盘数："); 2839 | Scanner p=new Scanner(System.in); 2840 | int ps=p.nextInt(); 2841 | for(int i=1;i<=ps;i++){ 2842 | System.out.println("游戏已开始，请出拳!"); 2843 | Scanner m=new Scanner(System.in); 2844 | int a=m.nextInt();//玩家出拳 2845 | //Random n=new Random(2);//随机函数 2846 | int b=(int)(0+Math.random()*(3-1+1));//随机产生0-2的int数，电脑出拳 2847 | if(a==b){ 2848 | a1++; 2849 | System.out.println("打平!"); 2850 | }else if((a-b)==-1||(a-b)==2){ 2851 | b1++; 2852 | System.out.println("YOU Win!"); 2853 | }else{ 2854 | c1++; 2855 | System.out.println("YOU LOSE"); 2856 | } 2857 | } 2858 | System.out.println("平:"+ a1 +"\n赢:" + b1 +"\n输:"+c1+"\n一共玩了"+(a1+b1+c1)+"局"); 2859 | Kais.jingcyx(); 2860 | } 2861 | } 2862 | ``` 2863 | ******************************************************************************* 2864 | 第十五题 2865 | 请编写一个类koradji(巫师的意思) 2866 | 为类编写如下功能： 2867 | 1. 根据用户的输入某人的生日，可以计算出该人的星座； 2868 | 2. 根据用户的输入年月日可以计算是星期几； 2869 | 3. 可以显示该巫师给多少人算过星相。 2870 | |1月20日- 2月18日|水瓶 |2月19日- 3月20日|双鱼 |3月21日- 4月19日|白羊| 2871 | |-----|-----|-----|-----|-----|-----| 2872 | 4月20日- 5月20日|金牛 |5月21日- 6月20日|双子 |6月21日- 7月22日|巨蟹 2873 | 7月23日- 8月22日狮子 8月23日- 9月22日处女 9月23日-10月22日天秤 2874 | 10月23日-11月21日天蝎 11月22日-12月21日射手 12月22日- 1月19日摩羯 2875 | ```java 2876 | //通过输入生日显示出生在周几。巫师看星座[Wrok15.java] 2877 | import java.util.*; 2878 | public class Work15{ 2879 | public static void main(String []args){ //程序入口 2880 | Start ks=new Start();//调用程序开始类Start，并启用st方法 2881 | ks.st(); 2882 | } 2883 | } 2884 | 2885 | class Start{//程序开始类 2886 | public void st(){ 2887 | System.out.println("年月日格式：19XX XX XX\n请输入出生年月日："); 2888 | Scanner sr=new Scanner(System.in); 2889 | int year=sr.nextInt();//输入年 2890 | int month=sr.nextInt();//输入月 2891 | int date=sr.nextInt();//输入日 2892 | Rq r=new Rq(); //调用周几类 2893 | r.rq(year,month,date);//将年月日数据传给周几类的rq方法中 2894 | Xinz xz=new Xinz();//调用星座类 2895 | xz.xinz(month,date);//将月日的数据传给星座类中的xinz方法中 2896 | System.out.println("\n是否继续让巫师看星座？\n1. 继续\t2. 退出"); 2897 | Scanner sr1=new Scanner(System.in); 2898 | int o=sr1.nextInt(); 2899 | if(o==1){ 2900 | Start qd=new Start();//输入1调用程序开始类 2901 | qd.st(); 2902 | }else if(o!=1){ //不等于1退出 2903 | Xinz tc=new Xinz(); 2904 | System.out.println("巫师为"+tc.getI()+"人看过星座"); 2905 | System.out.println("退出星座查询，Goodbay!"); 2906 | } 2907 | } 2908 | } 2909 | 2910 | class Rq{//周几类 2911 | public void rq(int year,int month,int date){ 2912 | Calendar c = Calendar.getInstance(); //调用日期Calendar抽象类 2913 | c.set(Calendar.YEAR,year); 2914 | c.set(Calendar.MONTH,month-1); 2915 | c.set(Calendar.DATE,date); 2916 | int week = c.get(Calendar.DAY_OF_WEEK); 2917 | switch (week){ //判断输入的日期是周几 2918 | case 1: 2919 | System.out.println("星期日"); 2920 | break; 2921 | case 2: 2922 | System.out.println("星期一"); 2923 | break; 2924 | case 3: 2925 | System.out.println("星期二"); 2926 | break; 2927 | case 4: 2928 | System.out.println("星期三"); 2929 | break; 2930 | case 5: 2931 | System.out.println("星期四"); 2932 | break; 2933 | case 6: 2934 | System.out.println("星期五"); 2935 | break; 2936 | case 7: 2937 | System.out.println("星期六"); 2938 | break; 2939 | } 2940 | } 2941 | } 2942 | 2943 | class Xinz{ //星座类 2944 | public static int i=0;//定义静态变量i，i为统计调用人数计数器 2945 | public void xinz(int month,int date){ //判断星座的方法 2946 | i++;//调用此方法计数累器 2947 | switch(month){ 2948 | case 1:{ 2949 | if(date>=20){ 2950 | System.out.println("水瓶座"); 2951 | }else{ 2952 | System.out.println("摩羯座"); 2953 | } 2954 | break; 2955 | } 2956 | case 2:{ 2957 | if(date>=19){ 2958 | System.out.println("双鱼座"); 2959 | }else{ 2960 | System.out.println("水瓶座"); 2961 | } 2962 | break; 2963 | } 2964 | case 3:{ 2965 | if(date>=21){ 2966 | System.out.println("白羊座"); 2967 | }else{ 2968 | System.out.println("双鱼座"); 2969 | } 2970 | break; 2971 | } 2972 | case 4:{ 2973 | if(date>=20){ 2974 | System.out.println("金牛座"); 2975 | }else{ 2976 | System.out.println("白羊座"); 2977 | } 2978 | break; 2979 | } 2980 | case 5:{ 2981 | if(date>=21){ 2982 | System.out.println("双子座"); 2983 | }else{ 2984 | System.out.println("金牛座"); 2985 | } 2986 | break; 2987 | } 2988 | case 6:{ 2989 | if(date>=21){ 2990 | System.out.println("巨蟹座"); 2991 | }else{ 2992 | System.out.println("金牛座"); 2993 | } 2994 | break; 2995 | } 2996 | case 7:{ 2997 | if(date>=23){ 2998 | System.out.println("狮子座"); 2999 | }else{ 3000 | System.out.println("巨蟹座"); 3001 | } 3002 | break; 3003 | } 3004 | case 8:{ 3005 | if(date>=20){ 3006 | System.out.println("处女座"); 3007 | }else{ 3008 | System.out.println("巨蟹座"); 3009 | } 3010 | break; 3011 | } 3012 | case 9:{ 3013 | if(date>=23){ 3014 | System.out.println("天平座"); 3015 | }else{ 3016 | System.out.println("处女座"); 3017 | } 3018 | break; 3019 | } 3020 | case 10:{ 3021 | if(date>=23){ 3022 | System.out.println("天蝎座"); 3023 | }else{ 3024 | System.out.println("天平座"); 3025 | } 3026 | break; 3027 | } 3028 | case 11:{ 3029 | if(date>=22){ 3030 | System.out.println("射手座"); 3031 | }else{ 3032 | System.out.println("天蝎座"); 3033 | } 3034 | break; 3035 | } 3036 | case 12:{ 3037 | if(date>=22){ 3038 | System.out.println("摩羯座"); 3039 | }else{ 3040 | System.out.println("射手座"); 3041 | } 3042 | break; 3043 | } 3044 | } 3045 | } 3046 | public int getI(){ //返回统计调用次数 3047 | return i; 3048 | } 3049 | } 3050 | ``` 3051 | ******************************************************************************* 3052 |   3053 | 3054 | 第十六题 3055 | 10个人投票选班长，有三个侯选人(张三，李四，王五)，通过编号投票，要求最后显示班长姓名。[Work16.java] 3056 | ```java 3057 | import java.util.*; 3058 | public class Work16 { 3059 | public static void main(String[] args) { 3060 | //设定投票人数 3061 | System.out.print("设定投票人数："); 3062 | Scanner sr=new Scanner(System.in); 3063 | int a=sr.nextInt(); 3064 | System.out.print("请输入第1位侯选人的名字：\n"); 3065 | Scanner sr1=new Scanner(System.in); 3066 | String i1=sr1.nextLine();//键盘接收字符串 3067 | System.out.print("请输入第2位侯选人的名字：\n"); 3068 | Scanner sr2=new Scanner(System.in); 3069 | String i2=sr2.nextLine(); 3070 | System.out.print("请输入第3位侯选人的名字：\n"); 3071 | Scanner sr3=new Scanner(System.in); 3072 | String i3=sr3.nextLine(); 3073 | System.out.println("本次选举将有"+ a +"人参与!"); 3074 | System.out.println("1号:"+i1+"\t2号:"+i2+"\t3号:"+i3); 3075 | Xuanju tp=new Xuanju(); 3076 | tp.tp(a,i1,i2,i3); 3077 | } 3078 | } 3079 | class Xuanju{ 3080 | public void tp(int a,String i1,String i2,String i3){ 3081 | int j1=0,j2=0,j3=0,qq=0;//计票器 3082 | for (int i=1;i<=a;i++){ //统计投票 3083 | System.out.println("请投票，投票请按1,2,3："); 3084 | Scanner tp=new Scanner(System.in); 3085 | int b=tp.nextInt(); 3086 | System.out.println("已有"+ i +"人投票"); 3087 | switch (b){ 3088 | case 1: 3089 | j1++; 3090 | break; 3091 | case 2: 3092 | j2++; 3093 | break; 3094 | case 3: 3095 | j3++; 3096 | break; 3097 | default: 3098 | qq++; 3099 | break; 3100 | } 3101 | } 3102 | 3103 | if(j1>j2&&j1>j3){ 3104 | System.out.println(i1 +"得"+ j1 +"票\n"+ i2 +"得"+ j2 +"票\n"+ i3 +"得"+ j3 +"票\n"+"弃权票数"+qq); 3105 | System.out.println("恭喜" + i1 + "当选班长!"); 3106 | }else if(j1j3){ 3107 | System.out.println(i1 +"得"+ j1 +"票\n"+ i2 +"得"+ j2 +"票\n"+ i3 +"得"+ j3 +"票\n"+"弃权票数"+qq); 3108 | System.out.println("恭喜" + i2 + "当选班长!"); 3109 | }else if(j3>j1&&j2