赞助商链接
当前位置： >>
java学习笔记(全)
Java 学习笔记_全JAVA 学习笔记_全java 内容介绍 java 编程可以分成三个方向： 1、java se (j2se)桌面开发 java 中的基础中的基础 2、java ee (j2ee)web 开发 3、java me (j2me)手机开发 java se 课程介绍 java 面向对象编程(基础) java 图开界面开发 java 数据库编程 java 文件 io 流编程 java 网络编程 java 多线程编程 java ee 基础 1 java 面向对象编程--数据库编程--&java se java 基础 2 html--css--javascript--&div+css java ee 中级部分 Servlet--Jsp--&mvc 模式 java ee 高级部分 Struts--Ejb--Hibernate--Spring--Ajax(ext,dw2)--&ssh 框架 java 之父 gosling 1990 sun 启动 绿色计划 1992 创建 oak 语言--&java 1994 gosling 参加硅谷大会演示 java 功能，震惊世界 1995 sun 正式发布 java 第一个版本，目前最新是 jdk7.0 java 开发工具 记事本、(jcreator、jbuilder 退出舞台了)、netbean、eclipse 如何选择开发工具 先选择记事本，对 java 有一定了解后再使用 eclipse 高级开发工具 为什么呢？ 1、更深刻的理解 java 技术，培养代码感 2、有利于公司面试java 语言的特点1 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全1、java 语言是简单的 2、java 语言是面向对象的 3、java 语言是跨平台(操作系统)的[即一次编译，到处运行] 4、java 是高性能的 java 第一个程序 hello.java 运行 java 程序要安装和配置 jdk jdk 是什么？ 1、jdk 全称 java dvevlopment kit 中文 java 开发工具包 2、jdk 是 sun 公司开发的 3、jdk 包括 jre(java runtime envirnment)java 运行环境、一堆 java 工具和 java 基础的 类库(类共 3600 左右，常用类在 150 个左右) 4、可以在 www.sun.com 下载 **开发安装 jdk,用户执行需要安装 jre 配置 JDK 添加环境变量即可 windows 下配置 jdk 在计算机属性--高级设置--环境变量--添加 PATH 将 JDK 所在路径指定即可。多个环境变量 设置时需要用;号进行隔开 1、编写第一个 hello.java //注释 (解释) 作者： //功能：在控制台显示&hello& //日期： //public：表示这个类是公共的，一个 java 文件中只能有一个 public 类 //class：表示这是一个类 //hello：类名(公共类的类名必须和文件名一致) public class hello{ //一个主函数，相当于是程序的入口 public static void main(String args[]){ //执行语句 //System：是一个包 //out.println 是输入函数 System.out.println(&hello!&); } } 2、编译 hello.java 使用 javac hello.java 3、执行 hello.java 使用 java hello java 程序运行关系 1、java 源文件(.java 文件) 2、java 编译器即 javac.exe2 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全3、java 字节码文件(.class 文件) 4、由解释执行器即(java.exe)将字节码文件加载到 java 虚拟器(jvm) 5、字节码文件(.class)就会在 java 虚拟机中执行 对 hello.java 程序进行改过使之变为一个简单的加法运算程序 //注释 (解释) 作者： //功能：在控制台显示&hello& //日期： //public：表示这个类是公共的，一个 java 文件中只能有一个 public 类 //class：表示这是一个类 //jiafa：类名(公共类的类名必须和文件名一致) public class jiafa{ //一个主函数，相当于是程序的入口 public static void main(String args[]){ //执行语句 //System：是一个包 //out.println 是输入函数 // System.out.println(&hello!&); int a=10;//定义一个变量，变量名 a，它的值 10 int b=20;//定义一个变量，变量名 b，它的值 20 int result=a+b;//定义一个叫 result 变量将变量 ab 相加的值赋值给 result //输出结果 System.out.println(&结果是&+result); } } ---------------------------------------------------------------为什么有变量 不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位。java 中的基本 数据类型的定义与 c/c++中大体一致。 public class Test{ public static void main(String []args){ int a=1;//定义一个整形变量，取名 a，并赋初值 1 int b=3;//定义一个整形变量，取名 b，并赋初值 3 b=89;//给变量 b 赋 89 System.out.println(a);//输出语句，把变量 a 的值输出 System.out.println(b);//把变量 b 的值输出 } } ----------------------------------------------------------------java 基本语法---基本数据类型java 基本数据类型 四大类型 整数类型、小数(浮点)类型、布尔类型、字符类型3 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全整数类型 可以表示一个整数，常用的整数类型有：byte,short,int,long 主要区别是 数据大小范围，请大家看一个小案例。 byte 占用内存 一个字节 范围：-128 至 127 short 占用内存 两个字节 范围：-32768 至 32767 int 占用内存 四个字节 范围：- 至
long 占用内存 八个字节 范围：-?至? 小数(浮点)类型 可以表示一个小数，常用的小数(浮点)类型有： float(单精度),double(双精度) float 占用内存 四个字节 范围：3.4E-38 至 3.4E+38 只能提供 7 位有效数字 double 占用内存 八个字节 范围：1.7E-308 至 1.7E+308 可提供 16 位有效数字 布尔类型 可以表示&真&或者&假&，类型是 boolean 比如： boolean spBool= //给变量 spBool 定义为 boolean 型并赋值为真 字符类型 可以表示 单个字符，字符类型是 char。char 是两个字节(可以存放汉字) 多个字符我们称为字符串，在 java 中 String 这种数据类型表示，但是 String 不是基本数 据类型，而是类，类是复合数据类型。 结论：在 java 中，对 char 进行运算的时候，直接当做 ascii 码对应的整数对待。 思考：int test1='a'+'b'; 输出值 195 char test2='a'+'b'; 输出值? char test3='中'; 输出值 1954 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全java 基本语法--定义变量，初始化，赋值定义变量 1、什么是定义变量？ 这就是定义了一个变量，变量名是这也定义了一个变量，表示一个 float 类型的小数，变量名是 haha 初始化变量 在定义变量的时候，就给值 int a=45;这就是初始化变量 a 给变量赋值 比如你先定义了变量： 然后再给值 tt=780; -&这就是给变量赋值 ----------------------------------------------------------------java 基本语法--基本数据类型转换自动转换 int a=1.2; double b=3; 结论：数据类型可以自动的从低精度--&高精度。高精度不能转为低精度。 byte 小于&short 小于&int 小于&long 小于&float 小于&double 在 java 中的小数默认是 double 数据类型 float 赋值时要在值后加 f long 赋值时要在值后加 l 强制转换 如何把高精度转成低精度？ int a=(int)1.2; 练习 int a=1; int a=1; double b=4.5; double b=4.5; a=b; b=a; 报错 成功 计算过程中的转换 int a=3; int b=a+3.4; 结论：当一个整数和一个 double 运算的时候，运算结果会向高精度转换5 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全java 基本语法--运算符java 中常用的算术运算符是：+加、-减、*乘、/除、%取模 其实%运算可以得到两个数的余数。 算术运算符：++自加、--自减。 这两个运算符比较特殊，请大家思考一下： int a=90; a++; 等同于(a=a+1) 这时 a 等于？ 91 int b=89; b--; 等同于(b=b-1) 这时 b 等于？ 88 int a=56; int b=a++; System.out.println(b); 56 System.out.println(a); 57 ***int b=++a;相当于 a=a+1 再将 b=a； int b=a++;相当于 b=a 再将 a=a+1。 ---------------------------------------------------------------算术运算符：+=左加、-=左减、/=左除、%=左取模 请大家看看几个案例，就明白了： int a=90; a+=90; (相当于 a=a+90) 请问，a 现在等于多少？ 180 float b=89.7f; b+=a; (相当于 b=b+a) 请问，b 现在等于多少？ 269.7 int a=56;int b=90; a-=34;b%=a; (相当于 a=a-34,b=b%a) System.out.println(b); 2 System.out.println(a); 22 ---------------------------------------------------------------运算符 关系运算符 1、==等于；2、&大于；3、&小于；4、&=大于等于；5、&=小于等于；6、!=不等于6 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全int a=90;int b=90; if(a==b){System.out.println(&ok1&);} b--; if(a&b){System.out.println(&ok2&);} if(a&=b){System.out.println(&ok3&);} 请编写一个程序， 该程序可以接收两个数(可以是整数， 也可是小数)并判断两个数是大于？ 小于？还是等于？ 程序代码： import java.io.*;//载入 IO 流包 public class Demo5{ public static void main(String []args){ try{ //输入流，从键盘接收数 InputStreamReader isr=new InputStreamReader(System.in); BufferedReader br=new BufferedReader(isr); //给出提示 System.out.println(&请输入第一个数&); //从控制台读取一行数据 String a1=br.readLine(); System.out.println(&请输入第二个数&); String a2=br.readLine(); //把 String 转为 float float num1=Float.parseFloat(a1); float num2=Float.parseFloat(a2); if(num1&num2){System.out.println(&第一个大&);} if(num1==num2){System.out.println(&相等&);} if(num1&num2){System.out.println(&第二个大&);} }catch(Exception e){ e.printStackTrace(); } } } ----------------------------------------------------------------运算符--逻辑运算符用于判断逻辑关系的运算符 1、&&与；2、||或；3、!非 &&与的运算关系，真真为真，其它都为假。 ||或的运算关系，假假为假，其它都为真。 !非的运算关系，真取假，假取真 请大家看个案例，请问输出什么： int a=90;int b=90;7 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全if(a==b || a&8){System.out.println(&ok1&);} b--; if(a&b && a&45){System.out.println(&ok2&);} if(!(a&=b)){System.out.println(&ok3&);}java 基本语法----三大流程控制顺序控制 听其名而知其意，让程序可以顺序的执行。 请大家看个案例[demo11.java]: int a=7; System.out.println(&a=&+a); System.out.println(&hello!&); a++; System.out.println(&a=&+a); System.out.println(&0(∩_∩)0&); a++; System.out.println(&a=&+a); 分支控制 让程序有选择的执行，分支控制有三种： 1、 单分支；2、双分支；3、多分支 a 1、单分支语法： if(条件表达式){ 语句; } 2、双分支语法： if(条件表达式){ 语句; }else{ 语句; } 3.1、多分支语法： if(条件表达式){ 语句; }else if(条件表达式){ 语句; }else if(条件表达式){ 语句; }else{ 语句; }8 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全3.2、多分支语法： switch(条件表达式){ //***条件表达式数据类型，就和 case 常量表达式一致，否则就 会报错。 case 常量 1: 语句 1; //语句 1 至 break 中相当于{}可以加入相应程序代码 //break，表示跳出 switch 语句 case 常量 2: 语句 1; ... case 常量 n: 语句 default: 语句; } *****:switch 中的可用数据类型主要是：允许 byte,short,int,char,enum 等 1、单分支控制作业：请大家看个案例[demo22.java]: 编写一个程序，可以输入人的年龄，如果该同学的年龄大于 18 岁，则输出“你年龄大于 18， 要为自己的行为负责!” 2、双分支控制作业：请大家看个案例[demo33.java]: 编写一个程序，可以输入人的年龄，如果该同志的年龄大于 18 岁，则输出“你年龄大于 18 岁，要对自己的行为负责!”否则，输出“你的年龄不大这次放过你了” 3、多分支控制作业：请大家看个案例[demo44.java] 编写一个程序，可以输入人的年龄，如果该同志的年龄大于 18 岁，则输出“你年龄大于 18， 要对自己的行业负责，送入监狱” 。如果该同志的年龄大于 10 岁并且小于等于 18，则输出 “你的年龄也不小了，把你送少管所” 。其它情况，则输出“小孩子，下次注意” 。 4、多分支控制作业：请大家看个案例[demo55.java] 请编写一个程序，该程序可以接收一个字符，比如：a,b,c,d,e,f,g a 表示星期一，b 表示星期二...根据用户的输入显示相应的信息，要求使用 switch 语句完 成。 5、多分支控制作业：请大家看个案例[demo66.java] 对比 switch 与 if 语句在执行分支语句的区别。 ***switch 分 支 语 句 不 支 持 判 断 类 型 即 boolean 类 型 ， switch 只 支 持 byte,short,int,char,enum 等数据类型 -------------------------------------------------------------------------------9 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全循环控制听其名而知其意，就是让你的代码可以循环的执行。 循环控制有三种 1、for 循环 语法： for(循环初值;循环条件;步长){ 语句; //循环体 } 2、while 循环 语法： while(循环条件){ 语句; //循环体 } 特别说明：while 循环是先判断在执行语句。 3、do while 循环 语法： do{ 语句; //循环体 }while(循环条件); 特别说明：do while 循环是先执行，再判断。 请大家看个案例[demo77-88-99.java]: 编写一个程序，可以打印 10 句“你好，我是刘德华同志!” 。请大家想想怎么做？ 1、for 循环 for (int a=0;a&10;a++){System.out.println(&你好，我是刘德华同志!&);} 2、while 循环 int i=0;while(i&10){System.out.println(&你好，我是刘德华同志!&);i++;} 3、do while 循环 int i=0;do{System.out.println(&你好，我是刘德华同志!&);i++;}while(i&10) 请编写一个程序，可以接收一个整数，表示层数，打印出金字塔一半。[demo100.java] ***把一个复杂的问是先拆解成简单问题 //三角形[Demo100.java] public class Demo100{ public static void main(String []args){ //死去活来法--&打四次 int lay=4; //表示有多少层 for(int i=1;i&=i++){ //打印* for(int j=1;j&=i;j++){ System.out.print(&*&); }10 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全System.out.println();//换行 } } } ------------------------------------------------------------------------------//金字塔[Demo101.java] public class Demo101{ public static void main(String []args){ int lay=10;//表示有多少层 for(int i=1;i&=i++){ //找出规律 //1-&3 2-&2 3-&1 4-&0 找出空格 for(int k=1;k&=lay-i;k++){ System.out.print(& &); } //打印* //1-&1 2-&3 3-&5 4-&7 找出星的规律 for(int j=1;j&=(i-1)*2+1;j++){ System.out.print(&*&); } System.out.println();//换行 } } } ------------------------------------------------------------------------------//镂空金字塔[Demo102.java] public class Demo102{ public static void main(String []args){ int lay=10;//表示有多少层 for(int i=1;i&=i++){ //找出规律 //1-&3 2-&2 3-&1 4-&0 找出空格 for(int k=1;k&=lay-i;k++){ System.out.print(& &); } //打印* //1-&1 2-&3 3-&5 4-&7 找出星的规律 for(int j=1;j&=(i-1)*2+1;j++){ //判断该层是否是顶层或者是底层 if(i==1||i==lay){ System.out.print(&*&); }else{ //如果是第一个*11 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全if(j==1||j==(i-1)*2+1){ System.out.print(&*&); }else{ System.out.print(& &); } } } System.out.println();//换行 } } } ------------------------------------------------------------------------------//空心菱形[Demo103.java] public class Demo103{ public static void main(String []args){ int lay=4;//菱形上半部行数 for(int i=1;i&=lay-1;i++){ //判断循环上半部分 for(int k=1;k&=lay-i;k++){ //找行内*号前输出空格 System.out.print(& &); } for(int j=1;j&=(i-1)*2+1;j++){ //找行内输出星的位置 if(j==1||j==(i-1)*2+1){ //判断行最小长度和最大长度，并在最小长 度和最大长度上输出*号，行内输入出空格。 System.out.print(&*&); }else{ System.out.print(& &); } } System.out.println(); //换行 } for(int i=1;i&=i++){ //判断循环菱形下半部分 for(int k=1;k&=i-1;k++){ //判断循环找*号前要输出空格处 System.out.print(& &); } for(int j=1;j&=(lay-i)*2+1;j++){ //判断循环行长度 if(j==1||j==(lay-i)*2+1){ //判断行最小长度和最大长度， 并在最小长 度和最大长度上输出*号，行内输入出空格。 System.out.print(&*&); }else{ System.out.print(& &); } } System.out.println();//输出换行12 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全} } } ------------------------------------------------------------------------------//实心菱形[Demo104.java] public class Demo104{ public static void main(String []args){ int lay=4;//菱形上半部行数 for(int i=1;i&=lay-1;i++){ //判断循环上半部分 for(int k=1;k&=lay-i;k++){ //找行内*号前输出空格 System.out.print(& &); } for(int j=1;j&=(i-1)*2+1;j++){ //找行内输出星的位置 System.out.print(&*&); } System.out.println(); //换行 } for(int i=1;i&=i++){ //判断循环菱形下半部分 for(int k=1;k&=i-1;k++){ //判断循环找*号前要输出空格处 System.out.print(& &); } for(int j=1;j&=(lay-i)*2+1;j++){ //判断循环行长度 System.out.print(&*&); } System.out.println();//输出换行 } } } -------------------------------------------------------------------------------1、java 面向对象编程(1)-类与对象一个问题？[Demo107.java] 张老太养了两只猫猫：一只名字叫小白，今年 3 岁，白色。还有一只叫小花，今年 100 岁， 花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果 用户输入的小猫名错误，则显示张老太没有这只猫猫。 //用前面学习过的知识写出代码 public class Demo107{ public static void main(String []args){ int a=49;//输入的名字 49，50 int cat1age=3; //第一只猫 String cat1name=&小白&; String cat1color=&白色&;13 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全int cat2age=100; //第二只猫 String cat2name=&小花&; String cat2color=&花色&; switch(a){ case '1': System.out.println(cat1age+cat1color); case '2': System.out.println(cat2age+cat2color); default: System.out.println(&张老太没有这只猫!&); } } } java 语言是面向对象的 计算机语言的发展向接近人的思维方式演变 汇编语言 [面向机器] c 语言 [面向过程] java 语言 [面向对象] 类和对象的关系 把猫的特性提取出来--&猫类--&对象(实例) --&对象(实例) --&... 注意：从猫类到对象，目前有几种说法：1、创建一个对象；2、实例化一个对象；3、对类 实例化...以后大家听到这些说法，不要模糊。(对象就是实例，实例就是对象)java 最大的 特点就是面向对象。 //定义猫类 public class Demo105{ public static void main(String []args){ //创建一个猫对象 Cat cat1=new Cat();//Cat 是定义的一个数据类型 //Cat cat1; //cat1=new Cat();// 等同于 Cat cat1=new Cat(); //访问属性的 对象名.属性名字 cat1.age=3; cat1.name=&小白&; cat1.color=&白色&; //创建第二只猫 Cat cat2=new Cat();14 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全cat2.age=100; cat2.name=&小花&; cat2.color=&花色&; } } //java 中如何定义一个类？[类名的首写字母大写]可根据程序的需要定义类 class Cat{ //下面的就是类的成员变量/属性 S S Master myM } //引用类型，比如建个主人类 class Master{ S S } 类和对象的区别和联系 1、类是抽象的，概念的，代表一类事物，比如人类，猫类.. 2、对象是具体的，实际的，代表一个具体事物 3、类对象的模板，对象是类的一个个体，实例类--如何定义类一个全面的类定义比较复杂，如： package 包名; class 类名 extends 父类 implements 接口名{ 成员变量; 构造方法; 成员方法; } 要透彻的掌握类，必须要了解类的构成 class 类名{ ----& 待定... 成员变量; } 类--类的成员变量15 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全成员变量是类的一个组成部分，一般是基本数据类型，也可是引用类型。比如我们前面定义 猫类的 int age 就是成员变量。 对象--如何创建对象 创建一个对象有两种方法 1、先声明再创建 1、对象声明：类名 对象名 2、对象创建：对象名=new 类名() 2、一步到位法 类名 对象名=new 类名() 对象--如何访问(使用)对象的成员变量 对象名.变量名; //简单先这样理解，以后加下控制符此表达就不准确了。 ***对象总是存在内存中的 一个小思考题[Demo.105.java] 为了让大家加深印象，我们定义一个人类(Person)(包括名字、年龄)。用一步到位法去创建 一个对象 ↓ 我们看看下面一段代码: System.out.printlin(b.age); Person a=new Person(); → 请问：b.age 究竟是多少？ a.age=10; a.name=&小明&; P b=a; ***对象总是存在内存中的 一个小思考题[Demo106.java] 在明白对象是如何在内存中存在后，请大家再看看下面的思考题，请问会输出什么信息？ Person1 a=new Person1(); a.age=10; a.name=&小明&; Person1 b=a; System.out.println(b.name);//输出“小明” b.age=200; System.out.println(a.age);//输出 a.age 为 200 *****重点也是难点 类--成员方法的初步介绍 在某些情况下，我们要需要定义成员方法。比如人类：除了有一些属性外(成员变量表示的 年龄、姓名...)，我们人类还有一些行为比如：可以说话、跑步..，通过学习，我们人类还16 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全可以做算术题。这时就要用成员方法才能完成。现在要求对 Person 类完善： 1、添加 speak 成员方法，输入出：我是一个好人 2、添加 jisuan 成员方法，可以计算从 1+..+1000 的结果 3、修改 jisuan 成员方法，该方法可以接收一个数 n，计算从 1+..+n 的结果 4、添加 add 成员方法，可以计算两个数的和类--类的成员方法(成员函数)定义成员方法也叫成员函数，这里希望大家不要被两个名词搞晕了。 public 返回数据类型 方法名(参数列表) { 语句;//方法(函数)主体 } 1、参数列表：表示成员函数输入 2、数据类型(返回类型)：表示成员函数输出 3、函数主体：表示为了实现某一功能代码块 //类的调用及方法调用[Demo108.java] public class Demo108{ public static void main(String []args){ Person p1=new Person(); p1.speak();//调用 speak 方法 p1.jiSuan();//调用计算方法 p1.jiSuan(200);//调用可以传入参数的计算方法 p1.add(12,10);//调用两个数的和 int res=p1.add2(23,34);//调用两个数的和并返回值到 res 中 System.out.println(&res 返回值是：&+res); System.out.println(&num1+num2+num3=&+p1.add3(2,2.3f,4.5f));//返回类型一定要 一致否则报错。 } } //定义名字的几个方法： //1、驼峰法 如 myCry；2、下划线法 my_cry //方法名在有不同参数的情况下可以使用同一个方法名，即有参数和没参数的方法可以同 名 class Person{ //请注意类名首写字母应为大写如 Person 为类名 S //1、可以输出我是好人方法 public void speak(){ //请注意方法名的首写字母应为小写如 speak 为方法名 System.out.println(&我是一个好人&);17 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全} //2、可以计算 1+..+1000 的方法 public void jiSuan(){ int result=0; for(int i=1;i&=1000;i++){ result=result+i; } System.out.println(&1+..+1000 结果是&+result); } //3、带参数的成员方法,可以输入 n 值并计算 1+..+n public void jiSuan(int n){ int result=0; for(int i=1;i&=n;i++){ result+=i; } System.out.println(&1+..+n 结果是&+result); } //4、计算两个数的和 public void add(int num1,int num2){ int result=0; //与下面一句等同于 return num1+num2; result=num1+num2; System.out.println(&num1+num2=&+result); } //5、计算两个数的和，并将结果返回给主调(调用它的)函数 //注意：返回类型和返回结果的类型要一致 //注意：在调用某个成员方法的时候，给出的具体数值的个数 //和类型要相匹配。 public int add2(int num1,int num2){ return num1+num2; } //6、计算两个 float 数的和，并将结果返给主调函数 public float add3(int num1,float num2,float num3){ return num1+num2+num3; } } 类--类的成员方法(函数)--如何理解 如何理解方法这个概念，给大家举个通俗的示例： 程序员调用方法：给方法必要的输入，方法返回结果。类的成员方法--声明public int test(int a);/*方法声明*/ 这句话的作用是声明该方法，声明的格式为：18 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全访问修饰符 数据类型 函数名(参数列表); 在给 Person 类添加 add 方法的例题中，我们看到的关键字 return，它的功能是把表达式的 值返回的值返回给主调函数的方法。 return 表达式; 类的成员方法(函数)--特别说明 1、方法的参数列表可以是多个 案例：在 Person 类中编写一个成员方法，从键盘输入三个数，返回最大的那个数。 参数列表可以是多个，并且数据类型可以是任意的类型 int float double char.. 访问修饰符 返回数据类型 函数名(参数列表){ 语句; //函数主体 } 2、方法可以没有返回值 案例：编写一个函数，从控制台输入一个整数打印出对应的金字塔。 返回类型可以是任意的数据类型(int,float,double,char..)也可以没有返回值 void 表示 没有返回值 访问修饰符 返回数据类型 函数名(形参列表){ 语句; //函数主体 } 类的成员方法(函数)--小练习 案例： 编写一个成员函数， 从键盘输入一个整数(1-9)， 打印出对应的乘法表[Demo110.java] //实例键盘输入打印乘法表[Demo110.java] import java.io.*; public class Demo110{ public static void main(String []args){ Cfb jiu=new Cfb(); jiu.cf(); } } class Cfb{ public void cf(){ try{ //输入流，从键盘接收数 InputStreamReader isr=new InputStreamReader(System.in); BufferedReader br=new BufferedReader(isr); //给出提示 System.out.println(&请输入 1-9，按 0 退出:&); //从控制台读取一行数据 String a1=br.readLine(); //把 String 转为 int int num1=Integer.decode(a1);19 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全for(int i=1;i&=num1;i++){ for(int j=1;j&=i;j++){ System.out.print(i+&×&+j+&=&+(i*j)+&\t&); } System.out.println(); } }catch(Exception e){ e.printStackTrace(); } } } 案例：编写函数，使给定的一个二维数组(3×3)转置 类定义的完善 在介绍了成员方法后，我们类的定义就可以完善一步： class 类名{ class 类名{ 待定 成员变量; → 成员变量; → } 成员方法; } 小结：1.先设计类；2.然后根据类创建对象。 小练习： 1、设计计算机类，要求如下：[Demo109.java] 属性： 品牌(Brand)、 颜色(Color)、 cpu 型号(CPU)、 内存容量(Memory)、 硬盘大小(Harddisk)、 价格(Price)、工作状态(Work) 方法：打开(Open)、关闭(Close)、休眠(Sleep) 创建一个计算机对象，调用打开，关闭方法 //计算机类与对象的代码 import java.io.*;//加载 IO 流包 public class Demo109{ public static void main(String []args){ Computer Pc=new Computer(); Pc.Brand=&品牌&; Pc.Color=&颜色&; Pc.Cpu=&Cpu 型号&; Pc.Memory=&内存容量&; Pc.Hd=&硬盘容量&; Pc.Price=&价格&; Pc.Work=&工作状态&; try{ //输入流，从键盘接收数 InputStreamReader isr=new InputStreamReader(System.in); BufferedReader br=new BufferedReader(isr);20 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全//给出提示 System.out.println(&请输入 0-9 控制机器&); //从控制台读取一行数据 String a1=br.readLine(); //把 String 转为 float float num1=Float.parseFloat(a1); if(num1==0){Pc.open();} else if(num1==1){Pc.close();} else if(num1==2){Pc.sleep();} else if(num1==3){System.out.println(Pc.Brand);} else if(num1==4){System.out.println(Pc.Color);} else if(num1==5){System.out.println(Pc.Cpu);} else if(num1==6){System.out.println(Pc.Memory);} else if(num1==7){System.out.println(Pc.Hd);} else if(num1==8){System.out.println(Pc.Price);} else if(num1==9){System.out.println(Pc.Work);} else {System.out.println(&输入错误!&);} }catch(Exception e){ e.printStackTrace(); } } } class Computer{ String B String C String C String M String Hd; String P String W public void open(){ System.out.println(&开机&); } public void close(){ System.out.println(&关机&); } public void sleep(){ System.out.println(&休眠&); } } 2、 采用面向对象思想设计超级马里奥游戏人物21 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全-------------------------------------------------------------------------------2、java 面向对象编程(1)-构造方法(函数)类的构造方法介绍 什么是构造方法呢？在回答这个问题之前， 我们来看一个需求： 前面我们在创建人类的对象 时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在我要求，在创建人 类的对象时，就直接指定这个对象的年龄和姓名，该怎么做？ ↓ 你可以在定义类的时候，定义一个构造方法即可。 构造方法是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点： 1、方法名和类名相同 2、没有返回值 3、在创建一个类的新对象时，系统会自动的调用该类的构造方法完成对新对象的初始化。 特别说明： 一个类可以定义多个不同的构造方法。 //例人类构造方法[Demo111.java] public class Demo111{ public static void main(String []args){ Person p1=new Person(12,&顺平&);//给予不同的初始值，调用的构造方法不同， 构造方法虽同名，但系统会根据初始值来选定构造方法。 } } //定义一个人类 class Person{ S //默认构造方法 public Person(){ } //构造方法的主要用处是：初始化你的成员属性(变量) //构造方法 public Person(int age,String name){ System.out.println(&我是构造 1&); age= name= } //构造方法 2 public Person(String name){ System.out.println(&我是构造 2&); name=22 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全} } 类的默认构造方法 有些同志可能会问？亲爱的老师，我们在没有学习构造函数前不是也可以创建对象吗？ 是这样的， 如果程序员没有定义构造方法， 系统会自动生成一个默认构造方法。 比如 Person 类 Person (){}; 当创建一个 Person 对象时 Person per1=new Person();默认的构造函数就会被自动调用。 类的构造方法小结： 1、构造方法名和类名相同； 2、构造方法没有返回值； 3、主要作用是完成对新对象的初始化； 4、在创建新对象时，系统自动的调用该类的构造方法； 5、一个类可以有多个构造方法； 6、每个类都有一个默认的构造方法。 类定义的改进 在提出构造方法后，我们类的定义就应该更加完善了： class 类名{ class 类名{ class 类名{ 成员变量; 成员变量; 成员变量; } → 成员方法; → 构造方法; → 待定.. } 成员方法 }java 面向对象编程(2)--this一个问题？ 请大家看一段代码：(Demo112.java) *重点*：this 是属于一个对象，不属于类的。 java 虚拟机会给每个对象分配 this,代表当前对象。坦白的讲，要明白 this 不是件容易的 事 注意事项：this 不能在类定义的外部使用，只能在类定义的方法中使用 /* this 的必要性 */ public class Demo112{ public static void main(String []args){ Dog dog1=new Dog(2,&大黄&); Person p1=new Person(dog1,23,&郭德纲&); Person p2=new Person(dog1,24,&刘谦&); p1.showInfo(); p1.dog.showInfo(); } }23 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全//定义一个人类 class Person{ //成员变量 S D//引用类型 public Person(Dog dog,int age,String name){ //可读性不好 //age= //name= this.age= //this.age 指 this 代词指定是成员变量 age this.name= //this.name 指 this 代词指定是成员变量 name this.dog= } //显示人名字 public void showInfo(){ System.out.println(&人名是：&+this.name); } } class Dog{ S public Dog(int age,String name){ this.age= this.name= } //显示狗名 public void showInfo(){ System.out.println(&狗名叫&+this.name); } } ------------------------------------------------------------------------------类变量--提出问题？ 提出问题的主要目的就是让大家思考解决之道。 public class Demo113{ public static void main(String []args){ /* int total=0; Child ch1=new Child(3,&妞妞&); ch1.joinGame(); total++; Child ch2=new Child(4,&小小&);24 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全ch2.joinGame(); total++; */ Child ch1=new Child(3,&妞妞&); ch1.joinGame(); Child ch2=new Child(4,&小小&); ch2.joinGame(); Child ch3=new Child(5,&大大&); ch3.joinGame(); System.out.println(&共有=&+Child.total); } } //定义小孩类 class Child{ S //static 公共函数,total 是静态变量，因此它可以被任何一个对象访问 static int total=0; public Child(int age,String name){ this.age= this.name= } public void joinGame(){ total++; System.out.println(&有一个小孩加入了&); } } ------------------------------------------------------------------------------java 面向对象编程(2)--类变量、类方法 什么是类变量？ 类变量是该类的所有对象共享的变量， 任何一个该类的对象去访问它时， 取到的都是相同的 值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。 如何定义类变量？ 定义语法： 访问修饰符 static 数据类型 变量名; 如何访问类变量？ 类名.类变量名 或者 对象名.类变量名 //类变量的程序演示[Demo114.java] public class Demo114{ static int i=1;25 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全static{ //该静态区域块只被执行一次 i++; System.out.println(&执行一次&); } public Demo114(){ //建立 Demo114()构造函数 System.out.println(&执行二次&); i++; } public static void main(String []args){ Demo114 t1=new Demo114(); //创建 t1 对象实例并调用 Demo114 函数 System.out.println(t1.i); Demo114 t2=new Demo114(); System.out.println(t2.i); } } -------------------------------------------------------------------------------什么是类方法，为什么有类方法？类方法是属于所有对象实例的，其形式如下： 访问修饰符 static 数据返回类型 方法名(){} 注意：类方法中不能访问非静态变量(类变量)。 使用：类名.类方法名 或者 对象名.类方法名 *重点*static 静态的方法可以访问 static 静态变量，不能访问非静态变量(类变量) 非静态方法可以访问非静态变量(类变量)同时也可以访问 static 静态变量。 //统计总学费的程序代码，加深 static 静态的方法由静态变量的访问[Demo115.java] public class Demo115{ public static void main(String []args){ //创建一个学生 Stu stu1=new Stu(29,&aa&,340); Stu stu2=new Stu(29,&aa&,240); System.out.println(Stu.getTotalFee()); } } //学生类 class Stu{ S static int totalF public Stu(int age,String name,int fee){26 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全this.age= this.name= totalFee+= } //返回总学费[这是一个类方法(静态方法)] //java 中规则：类变量原则上用类方法去访问或操作 public static int getTotalFee(){ return totalF } } 类变量小结 1、什么时候需要用类变量 案例[Demo115.java]：定义学生类，统计学生共交多少钱？ 用类变量，属于公共的属性 2、类变量与实例变量区别： 加上 static 称为类变量或静态变量，否则称为实例变量 类变量是与类相关的，公共的属性 实例变量属于每个对象个体的属性 类变量可以通过 [类名.类变量名] 直接访问 类方法小结 1、什么时候需要用类方法 案例[Demo115.java]：定义学生类，统计学生共交多少钱？ 类方法属于与类相关的，公共的方法 实例方法属于每个对象个体的方法 类方法可以通过 [类名.类方法名] 直接访问 ------------------------------------------------------------------------------java 面向对象编程的四大特征 抽象/封装/继承/多态抽象1、简单理解 我们在前面去定义一个类时候， 实际上就是把一类事物的共有的属性和行为提取出来， 形成 一个物理模型(模版)。这种研究问题的方法称为抽象。 封装--什么是封装 封装就是把抽象出来的数据和对数据的操作封装在一起， 数据被保护在内部， 程序的其它部 分只有通过被授权的操作(成员方法)，才能对数据进行操作。 封装--访问控制修饰符 电视机的开关，对音量，颜色，频道的控制是公开的，谁都可以操作，但是对机箱后盖，主 机板的操作却不是公开的，一般是由专业维修人员来玩。那么 java 中如何实现这种类似的27 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全控制呢？不能随便查看人的年龄，工资等隐私[Demo116.java] //封装案例[Demo116.java] public class Demo116{ public static void main(String []args){ //创建一个职员 Clerk clerk1=new Clerk(&小花&,24,4567.6f); System.out.println(&名字是&+clerk1.name+&薪水&+clerk1.getSal()); } } //职员 class Clerk{ public S //private 私有的，public 公有的
public Clerk(String name,int age,float sal){ this.name= this.age= this.salary= } //通过一个成员方法去控制和访问私有的属性 public float getSal(){ return this. } }封装--访问控制修饰符java 提供四种访问控制修饰符号控制方法和变量的访问权限： 1、公开级别：用 public 修饰，对外公开 2、受保护级别：用 protected 修饰，对子类和同一个包中的类公开 3、默认级别：没有修饰符号，向同一个包的类公开 4、私有级别：用 private 修饰，只有类本身可以访问，不对外公开 4 种访问级别的访问范围 访问级别 公 默 私 开 认 有 受保护 访问控制修饰符 Public Protected 没有修饰符 private 同类 √ √ √ √ 同包 √ √ √ w 子类 √ √ w w 不同包 √ w w w包--必要性 问题的提出，请看下面的一个场景[eclipse] 现在有两个程序员共同开发一个 java 项目，程序员 xiaoming 希望定义一个类取名 Dog，程28 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全序员 xiaoqiang 也想定义一个类也叫 Dog。两个程序员为此还吵了起来，怎么办？ 包--三大作用 1、区分相同名字的类 2、当类很多时，可以很好的管理类 3、控制访问范围 包--换包命令 package com.自定义名字; 注意：打包命令一般放在文件开始处。 包--命名规范 小写字母 比如 com.sina.shunping 包--常用的包 一个包下，包含很多的类，java 中常用的包有： java.lang.* 包 自动引入 java.util.* 工具包 java.net.* 包 网络开发包 java.awt.* 包 窗口工具包 包--如何引入包 语法：import 包; 比如 import java.awt.*; 我们引入一个包的主要目的要使用该包下的类 定义类的改进 在提出包后，我们类的定义就更加完善了： class 类名{ class 类名{ class 类名{ package 包名; 待定.. 成员变量; → 成员变量; → 成员变量; → class 类名{ → } 成员方法; 构造方法; 成员变量; } 成员方法; 构造方法; } 成员方法; } -------------------------------------------------------------------------------继承--为什么有？[Demo117.java]//功能：说明继承的重要性 package com.//包名 public class Demo117 { public static void main(String[] args) { Pupil p1=new Pupil(); p1.printName(); } }29 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全//将学生的共有属性提取，做一个父类 class Stu{ //定义成员属性 public S private S//私有将不被继承 //编程中，如果你不希望子类继承某个属性或方法 //则将其声明为 private 即可 public void printName(){ System.out.println(&名字&+this.name); } } //小学生类 class Pupil extends Stu{ //交学费 public void pay(float fee){ this.fee= } } //幼儿 class Pre extends Pupil{ //交学费 public void pay(float fee){ this.fee=fee*1.5f; } } //中学生类 class MiddleStu extends Stu{ //交学费 public void pay(float fee){ this.fee=fee*0.8f; } } //大学生类 class ColStu extends Stu{ //交学费 public void pay(float fee){ this.fee=fee*0.1f; } }30 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全继承--解决之道继承可以解决代码复用， 让我们的编程更加靠近人类思维。 当多个类存在相同的属性(变量) 和方法时，可以从这些类中抽象出父类(比如刚才的 Student)，在父类中定义这些相同的属 性和方法， 所有的子类不需要重新定义这些属性和方法， 只需要通过 extends 语句来声明继 承父类： 语法：class 子类 extends 父类 这样，子类就会自动拥有父类定义的某些属性和方法。 继承--深入讨论 1、父类的哪些属性(变量)、方法被子类继承了？并不是父类的所有属性、方法都可以被子 类继承 父类 子类 public 属性; public 属性; protected 属性; 继承 protected 属性; private 属性; → 属性; 属性; public 方法; public 方法; protected 方法; protected 方法; private 方法; 方法; 方法; 2、结论 从图可以看出，父类的 public 修饰符的属性和方法；protected 修饰符的属性和方法；默 认修饰符属性和方法被子类继承了，父类的 private 修饰符的属性和方法不能被子类继承。 继承--注意事项 1、子类最多只能继承一个父类(指直接继承) 2、java 所有类都是 Object 类的子类 (所有的子类都可以逐级继承，例:爷-&父-&子-&孙) 3、JDK6 中有 202 个包 3777 个类、接口、异常、枚举、注释和错误 4、在做开发的时候，强烈建议大家多查 jdk 帮助文档 5、在使用类时，实在不知道怎么办，多使用搜索引擎定义类的改进在提出包后，我们类的定义就更加完善了： class 类名{ class 类名{ class 类名{ package 包名; 成员变量; → 成员变量; → 成员变量; → class 类名{ } 成员方法; 构造方法; 成员变量; } 成员方法; 构造方法; } 成员方法; } ↓ ↓←←←←←←←←←←←←←←←←←←←←←←←←← package 包名; class 类名 extends 父类{ 待定31 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全成员变量; 构造方法; 成员方法; }→....-------------------------------------------------------------------------------java 面向对象编程(2)--方法重载(overload)方法重载(overload) 按顺序，我们应该讲解多态，但是在讲解多态前，我们必须讲解方法重载和方法覆盖 (override)。 请编写一个类(Abc)，编写方法可以接收两个整数，返回两个数中较大的数[Demo119.java] //方法重载(overload)getMax public class Demo119{ public static void main(String []args){ Abc2 abc1=new Abc2(); System.out.println(abc1.getMax(12,14)); System.out.println(abc1.getMax(24f,20f)); } } class Abc2{ //返回较大的整数 public int getMax(int i,int j){ if(i&j){ }else{ } } public float getMax(float a,float b){ if(a&b){ }else{ } } //如果只是返回类型不一样，能否构成重载？不能够构成重载 /* public double getMax(float d,double c){ if(c&d){ }else{ }32 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全} //如果只是控制访问修饰符不同，能否构成重载？不能够构成重载 protected float getMax(float c,float d){ if(c&d){ }else{ } }*/ } 方法重载(overload)概念 简单的说：方法重载就是在类的同一种功能的多种实现方式，到底采用哪种方式，取决于调 用者给出的参数。 注意事项： 1、方法名相同 2、方法的参数类型，个数，顺序至少有一项不同 3、方法返回类型可以不同(只是返回类型不一样，不能构成重载) 4、方法的修饰符可以不同(只是控制访问修饰符不同，不能构成重载)33 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全方法覆盖(override) 既然子类可以继承父类的属性和方法，这样可以提高代码的复用性，这个很好，可是问题来 了，假设现在我要求大家写三个类猫猫，狗狗，猪猪。我们知道这三个东东都是动物，动物 必然存在相同的特点。根据类的抽象特征，我们可以把它们的相同点提取出来，形成一个父 类，然后继承。 //子类方法覆盖父类方法[Demo120.java] public class Demo120{ public static void main(String []args){ //创建一只猫 Cat cat1=new Cat(); cat1.cry(); Dog dog1=new Dog(); dog1.cry(); } } //动物类 class Animal{ S //都会叫 public void cry(){ System.out.println(&我是动物，不知道怎么叫&); } } //猫猫类 class Cat extends Animal{ //覆盖父类方法 public void cry(){ System.out.println(&猫猫叫!&); } } //狗狗类 class Dog extends Animal{ //覆盖父类方法 public void cry(){ System.out.println(&汪汪叫!&); } } 方法覆盖(override)概念34 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全简单的说： 方法覆盖就是子类有一个方法， 和父类的某个方法的名称、 返回类型、 参数一样， 那么我们就说子类的这个方法覆盖了父类的那个方法。 比如上个案例的 Cat 类中的 cry 方法 就覆盖了 Animal 类的 cry 方法。 注意事项： 方法覆盖有很多条件，有些书上说的比较细，总的讲有两点一定注意： 1、子类的方法的返回类型，参数，方法名称，要和父类的返回类型，参数，方法名称完全 一样，否则编译出错。 2、子类方法不能缩小父类方法的访问权限。 =============================================================================== 作业：上机实习题目 1、Josephu 问题(丢手帕问题) Josephu 问题为：设编号为 1,2,...n 的 n 个人围坐一圈，约定编号为 k(1&=k&=n)的人 从 1 开始报数， 数到 m 的那个人出列， 它的下一位又从 1 开始报数， 数到 m 的那个人又出列， 依次类推，直到所有人出列为止，由此产生一个出队编号的序列。 提示： 用一个不带头结点的循环链表来处理 Josephu 问题： 先构成一个有 n 个结点的单 循环链表，然后由 k 结点起从 1 开始计数，计到 m 时，对应结点的人从链表中删除，然后再 从被删除结点的下一个结点又从 1 开始计数，直到最后一个结点从链表中删除算法结束。 //Josephu 问题(丢手帕问题) //使用单向链表 public class Demo121 { public static void main(String[] args) { CycLink cyclink=new CycLink(); cyclink.setLen(5);//链表长度 cyclink.createLink(); cyclink.setK(2);//从第几个人开始数 cyclink.setM(2);//数几下 cyclink.show(); cyclink.play(); } } class Child{ Child nextChild= public Child(int no){ //给一个编号 this.no= } } //单向环形链表 class CycLink{35 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全//先定义一个指向链表第一个小孩的引用 //指向第一个小孩的引用，不能动 Child firstChild= Child temp= int len=0;//表示共有多少个小孩 int k=0; int m=0; //设置 m 数几下 public void setM(int m){ this.m=m; } //设置环形链表大小 public void setLen(int len){ this.len= } //设置从第几个人开始数数 public void setK(int k){ this.k=k; } //开始 play public void play(){ Child temp=this.firstC //1.先找到开始数数的人 for(int i=1;i&k;i++){ temp=temp.nextC } while(this.len!=1){ //2.数 m 下 for(int j=1;j&m;j++){ temp=temp.nextC } //找到要出圈的前一个小孩 Child temp2= while(temp2.nextChild!=temp){ temp2=temp2.nextC } //3.将数到 m 的小孩，退出圈 temp2.nextChild=temp.nextC //让 temp 指向下一个数数的小孩 temp=temp.nextC this.len--; } //最后一个小孩36 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全System.out.println(&最后出圈的小孩:&+temp.no); } //初始化单向环形链表 public void createLink(){ for(int i=1;i&=i++){ if(i==1){ //创建第一个小孩 Child ch=new Child(i); this.firstChild= this.temp= }else{ //创建最后一个小孩 if(i==len){ Child ch=new Child(i); temp.nextChild= temp= temp.nextChild=this.firstC }else{ //继续创建小孩 Child ch=new Child(i); temp.nextChild= temp= } } } } //打印该环形链表 public void show(){ //定义一个跑龙套 Child temp=this.firstC do{ System.out.print(temp.no+& &); temp=temp.nextC }while(temp!=this.firstChild); } }37 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全java 面向对象编程(2)--四大特征多态--概念 所谓多态，就是指一个引用(类型)在不同情况下的多种状态。也可以理解成：多态是指通过 指向父类的指针，来调用在不同子类中实现的方法。 实现多态有两种方式：1、继承；2、接口 多态演示[Dome122.java] //演示继承、方法覆盖、多态 public class Demo122 { public static void main(String[] args) { //非多态演示 Cat cat=new Cat(); cat.cry(); Dog dog=new Dog(); dog.cry(); //多态演示 Animal an=new Cat(); an.cry(); an=new Dog(); an.cry(); } } //动物类 class Animal{ S public String getName() { } public void setName(String name) { this.name = } public int getAge() { } public void setAge(int age) { this.age = } //动物会叫 public void cry(){ System.out.println(&不知道怎么叫&); } }38 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全//创建 Dog 子类并继承 Animal 父类及覆盖 cry 方法 class Dog extends Animal{ //狗叫 public void cry(){ System.out.println(&汪汪叫&); } } class Cat extends Animal{ //猫自己叫 public void cry(){ System.out.println(&猫猫叫&); } } ------------------------------------------------------------------------------多重多态演示[Dome123.java] //演示子类继承父类、方法覆盖、多态方法 public class Demo123 { public static void main(String[] args) { //非多态演示 System.out.println(&非多态演示:&); Cat cat=new Cat(); cat.cry(); Dog dog=new Dog(); dog.cry(); System.out.println(); //多态演示 System.out.println(&多态演示:&); Animal an=new Cat(); an.cry(); an=new Dog(); an.cry(); System.out.println(); //多重多态演示 System.out.println(&多重多态演示:&); Master master=new Master(); master.feed(new Dog(),new Bone()); master.feed(new Cat(),new Fish()); } } //主人类 class Master{ //给动物喂食物，使用多态，只要写一个方法 public void feed(Animal an,Food f){39 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全an.eat(); f.showName(); } } //食物父类 class Food{ S public void showName(){ System.out.println(&食物&); } } //食物鱼子类 class Fish extends Food{ public void showName(){ System.out.println(&鱼&); } } //食物骨头子类 class Bone extends Food{ public void showName(){ System.out.println(&骨头&); } } //动物类 Animal 父类 class Animal{ S public String getName() { } public void setName(String name) { this.name = } public int getAge() { } public void setAge(int age) { this.age = } //动物会叫 public void cry(){ System.out.println(&不知道怎么叫&);40 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全} //动物吃东西 public void eat(){ System.out.println(&不知道吃什么&); } } //创建 Dog 子类并 extends 继承 Animal 父类及覆盖 cry 方法 class Dog extends Animal{ //狗叫 public void cry(){ System.out.println(&汪汪叫&); } //狗吃东西 public void eat(){ System.out.println(&狗爱吃骨头&); } } class Cat extends Animal{ //猫自己叫 public void cry(){ System.out.println(&猫猫叫&); } //猫吃东西 public void eat(){ System.out.println(&猫爱吃鱼&); } } 多态--注意事项： 1、java 允许父类的引用变量引用它的子类的实例(对象) Animal an=new Cat();//这种转换时自动完成的 2、关于类型转换还有一些具体的细节要求，我们在后面还要提，比如子类能不能转换成父 类，有什么要求等等... -------------------------------------------------------------------------------java 面向对象编程(3)--抽象类抽象类--解决之道 当父类的一些方法不能确定时，可以用 abstract 关键字来修饰该方法 [ 抽象方法 ] ，用 abstract 来修饰该类[抽象类]。 //抽象类的必要性[Demo124.java] public class Demo124 { public static void main(String[] args) { //Animal an=new Animal();抽象类不允许实例化41 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全Animal an=new Cat(); an.cry(); an=new Dog(); an.cry(); } } //抽象类 abstract 关键词 abstract class Animal{ S //动物会叫，使用了 abstract 抽象方法 abstract public void cry();//抽象类中可以没有 abstract 抽象方法 //抽象类内可以有实现方法 public void sx(){ System.out.println(&实现方法&); } } //当一个子类继承的父类是 abstract 抽象类的话，需要程序员把抽象类的抽象方法全部实 现。 class Cat extends Animal{ //实现父类的 cry，其实类似上节学习中的子类覆盖父类 public void cry(){ System.out.println(&猫猫叫&); } } class Dog extends Animal{ //实现父类的 cry，其实类似上节学习中的子类覆盖父类 public void cry(){ System.out.println(&汪汪叫&); } } 抽象类--深入讨论 抽象类是 java 中一个比较重要的类。 1、用 abstract 关键字来修饰一个类时，这个类就是抽象类。 2、用 abstract 关键字来修饰一个方法时，这个方法就是抽象方法。 3、abstract 抽象类中的 abstract 抽象方法是不允许在抽象类中实现的，一旦实现就不是 抽象方法和抽象类了。abstract 抽象方法只能在子类中实现。 4、抽象类中可以拥有实现方法。 5、抽象方法在编程中用的不是很多，但是在公司笔试时，却是考官比较爱问的知识点。 抽象类--注意事项 1、抽象类不能被实例化42 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全2、抽象类不一定要包含 abstract 方法。也就是说，抽象类可以没有 abstract 抽象方法。 3、一旦类包含了 abstract 抽象方法，则这个类必须声明为 abstract 抽象类。 4、抽象方法不能有主体。 正确的抽象方法例：abstract void abc(); 错语的抽象方法例：abstract void abc(){}java 面向对象编程(3)--接口接口--为什么有？ USB 插槽就是现实中的接口。 什么是接口？ 接口就是给出一些没有内容的方法，封装到一起，到某个类要使用的时候，在根据具体情况 把这些方法写出来。 接口的建立语法：interface 接口名{方法;} 语法：class 类名 implements 接口{ 方法; 变量; } 小结：接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没 有方法体。接口体现了程序设计的多态和高内聚低偶合的设计思想。 接口--注意事项 1、接口不能被实例化 2、接口中所有的方法都不能有主体。错误语法例：void aaa(){}←(注意不能有花括号) 接口可以看作更加抽象的抽象类。 3、一个类可以实现多个接口 4、接口中可以有变量[但变量不能用 private 和 protected 修饰] a、接口中的变量，本质上都是 static 的而且是 final 类型的，不管你加不加 static 修 饰 b、在 java 开发中，我们经常把常用的变量，定义在接口中，作为全局变量使用 访问形式：接口名.变量名 5、一个接口不能继承其它的类，但是可以继承别的接口 //接口的实现[Demo125.java] //电脑，相机，u 盘，手机 //usb 接口 interface Usb{ int a=1;//加不加 static 都是静态的，不能用 private 和 protected 修饰 //声明了两个方法 public void start();//接口开始工作 public void stop();//接口停止工作 } //编写了一个相机类，并实现了 usb 接口43 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全//一个重要的原则：当一个类实现了一个接口，要求该类把这个接口的所有方法全部实现 class Camera implements Usb{ public void start(){ System.out.println(&我是相机，开始工作了..&); } public void stop(){ System.out.println(&我是相机，停止工作了..&); } } //接口继承别的接口 class Base{ } interface Tt{ } interface Son extends Tt{ } //编写了一个手机，并实现了 usb 接口 class Phone implements Usb{ public void start(){ System.out.println(&我是手机，开始工作了..&); } public void stop(){ System.out.println(&我是手机，停止工作了..&); } } //计算机 class Computer{ //开始使用 usb 接口 public void useUsb(Usb usb){ usb.start(); usb.stop(); } } public class Demo125 { public static void main(String[] args) { System.out.println(Usb.a); //创建 Computer Computer computer=new Computer(); //创建 Camera Camera camera1=new Camera(); //创建 Phone Phone phone1=new Phone(); computer.useUsb(camera1);44 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全computer.useUsb(phone1); } } -------------------------------------------------------------------------------45 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全定义类的改进 有了接口，我们类的定义就更加完善了： class 类名{ class 类名{ class 类名{ package 包名; 成员变量; → 成员变量; → 成员变量; → class 类名{ } 成员方法; 构造方法; 成员变量; } 成员方法; 构造方法; } 成员方法; } ↓ ↓←←←←←←←←←←←←←←←←←←←←←←←←← package 包名; package 包名; class 类名 extends 父类{ class 类名 extends 父类 implements 接口名{ 成员变量; → 成员变量; 构造方法; 构造方法; 成员方法; 成员方法; } } ------------------------------------------------------------------------------实现接口 VS 继承类 java 的继承是单继承，也就是一个类最多只能有一个父类，这种单继承的机制可保证类的 纯洁性，比 C++中的多继承机制简洁。但是不可否认，对子类功能的扩展有一定影响。所以： 1、实现接口可以看作是对继承的一种补充。(继承是层级式的，不太灵活。修改某个类就 会打破继承的平衡，而接口就没有这样的麻烦，因为它只针对实现接口的类才起作用) 2、实现接口可在不打破继承关系的前提下，对某个类功能扩展，非常灵活。 //实例：建立子类并继承了父类且连接多个接口[Demo126.java] public class Demo126 { public static void main(String[] args) { System.out.println(&继承了 Monkey 父类&); Monkey mo=new Monkey(); mo.jump(); LittleMonkey li=new LittleMonkey(); li.swimming(); li.fly(); } } //接口 Fish interface Fish{ public void swimming(); } //接口 Bird interface Bird{ public void fly();46 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全} //建立 Monkey 类 class Monkey{ //猴子可以跳 public void jump(){ System.out.println(&猴子会跳!&); } } //建立 LittleMonkey 子类并继承了 Monkey 父类并连接了 Fish 和 Bird 接口 class LittleMonkey extends Monkey implements Fish,Bird{ public void swimming() { System.out.println(&连接了 Fish 接口!&); } public void fly() { System.out.println(&连接了 Bird 接口!&); } } ------------------------------------------------------------------------------用接口实现多态--案例[Demo127.java] java 中多态是个难以理解的概念， 但同时又是一个非常重要的概念。 java 三大特性之一(继 承，封装，多态)，我们可以从字面上简单理解：就是一种类型的多种状态，以下通过卖小 汽车的例子说明什么是多态。 //用接口实现多态 public class Demo127 { public static void main(String []args){ CarShop aShop=new CarShop(); //卖出一辆宝马 aShop.sellCar(new BMW()); //卖出一辆奇瑞 QQ aShop.sellCar(new CheryQQ()); //卖出一辆桑塔纳 aShop.sellCar(new Santana()); System.out.println(&总收入：&+aShop.getMoney()); } } //汽车接口 interface Car{ //汽车名称 String getName(); //获得汽车售价 int getPrice(); }47 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全//宝马 class BMW implements Car{ public String getName(){ return &BMW&; } public int getPrice(){ return 300000; } } //奇瑞 QQ class CheryQQ implements Car{ public String getName(){ return &CheryQQ&; } public int getPrice(){ return 20000; } } //桑塔纳汽车 class Santana implements Car{ public String getName(){ return &Santana&; } public int getPrice(){ return 80000; } } //汽车出售店 class CarShop{ //售车收入 private int money=0; //卖出一部车 public void sellCar(Car car){ System.out.println(&车型：&+car.getName()+&单价：&+car.getPrice ()); //增加卖出车售价的收入 money+=car.getPrice(); } //售车总收入 public int getMoney(){ }48 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全} 运行结果： 车型：BMW 单价：300000 车型：CheryQQ 单价：20000 总收入：320000 继承是多态得以实现的基础。 从字面上理解， 多态就是一种类型(都是 Car 类型)表现出多种 状态(宝马汽车的名称是 BMW，售价是 300000；奇瑞汽车的名称是 CheryQQ，售价是 2000)。 将一个方法调用同这个方法所属的主体(也就是对象或类)关联起来叫做绑定， 分前期绑这下 和后期绑定两种。下面解释一下它们的定义： 1、前期绑定：在程序运行之前进行绑定，由编译器和连接程序实现，又叫做静态绑定。比 如 static 方法和 final 方法，注意，这里也包括 private 方法，因为它是隐式 final 的。 2、后期绑定：在运行时根据对象的类型进行绑定，由方法调用机制实现，因此又叫做动态 绑定，或者运行时绑定。除了前期绑定外的所有方法都属于后期绑定。 多态就是在后期绑定这种机制上实现的。多态给我们带来的好处是消除了类之间的偶合关 系，使程序更容易扩展。比如在上例中，新增加一种类型汽车的销售。只需要让新定义的类 实现 Car 类并实现它的所有方法， 而无需对原有代码做任何修改， CarShop 类的 sellCar(Car car)方法就可以处理新的车型了。 新增代码如下： java 代码 //桑塔纳汽车 class Santana implements Car{ public String getName(){ return &Santana&; } public int getPrice(){ return 80000; } } ------------------------------------------------------------------------------java 面向对象编程(3)--final final 概念 final 中文意思：最后的，最终的。 final 可以修饰变量或者方法。 在某些情况下，程序员可能有以下需求： 1、当不希望父类的某个方法被子类覆盖(override)时，可以用 final 关键字修饰。 2、当不希望类的某个变量的值被修改，可以用 final 修饰。如果一个变量是 final，则必 须赋初值，否则编译出错。 3、当不希望类被继承时，可以用 final 修饰。 //final 方法的使用[Demo128.java] public class Demo128 { public static void main(String[] args) {49 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全Aaa aaa=new Aaa(); aaa.show(); Bbb bbb=new Bbb(); bbb.show(); } } class Aaa{ int a=0;//如果 a 不赋初值,a 是 0。定义类型后应赋值 //圆周率不让修改 //带有 final 修饰的变量命名时应有_下划线来区分表示。这是 java 程序员的标准。 final float reate_1=3.1415926f;//使用 final 可以保证，需要强制不被修改的数据 一定要用 final 锁定 // //使用 final 定义变量时一定要赋初值否则报错。 //b=1; final public void sendMes(){//给成员方法用 final 来修饰则表示不可以被修改， 不可被覆盖。 System.out.println(&发送消息&); } public void show(){ System.out.println(&a=&+a); } } final class Bbb extends Aaa{//定义类前加 final 表示该类不允许被继承 public Bbb(){ a++; //reate_1=reate+1; } /*public void sendMes(){ System.out.println(&发送消息&) }*/ } final--注意事项 1、final 修饰的变量又叫常量，一般用 XX_XX_XX 来命名。(带下划线) 2、final 修饰的变量在定义时，必须赋值，并且以后不能再赋值。 final--什么时候用 1、因为案例的考虑，类的某个方法不允许修改。 2、类不会被其它的类继承。 3、某些变量值是固定不变的，比如圆周率 3.141592650 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全******************************************************************************* 作业： 第一题：目的 1、变量定义、初始化、赋值 2、运算符和表达式 3、输出语句 System.out.println(); 1.作一个加法器，计算它们的和 2.作一个减法器，计算它们的差 3.作一个乘法器，计算它们的积 4.作一个除法器，计算它们的商(和余数) [Work01.java] public class Work01{ public static void main(String []args){ int i=9;int j=4; int k=i+j; int l=i-j; int m=i*j; int n=i/j; int o=i%j; System.out.println(&和：&+k+& 差：&+l+& 积:&+m+& 商:&+n+& 模：&+o); } } ******************************************************************************* 第二题：正方型[Work02.java] //正方形 public class Work02{ public static void main(String []args){ for(int i=1;i&5;i++){ System.out.println(&********&); } } } ******************************************************************************* 第三题：直角三角形[Work03.java] //直角三角形 public class Work03{ public static void main(String []args){ for(int i=1;i&9;i++){ for(int j=1;j&i;j++){ System.out.print(&*&); } System.out.println();51 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全} } } ******************************************************************************* 第四题：三角形[Work04.java] //三角形 public class Work04{ public static void main(String []args){ int lay=10;//行数 for(int i=1;i&=i++){//循环行 for(int k=1;k&=lay-i;k++){//找空格 System.out.print(& &); } for(int j=1;j&=(i-1)*2+1;j++){//找星位置并输入 System.out.print(&*&); } System.out.println();//换行 } } } ******************************************************************************* 第五题： 已知手掌游戏机一台 320 元，MP3 一台 260 元。公司举行抽奖大会，公司有 18 人，一等奖 游戏机，二等奖 MP3，购入 5 公游戏机，13 台 MP3。问总价为多少，公司实际平均给每人花 费多少钱。[Work05.java] //计算总费用和平均费用 import java.util.*;//加载包 public class Work05{ public static int gbGame=320;//静态变量 public static int gbGameT=5; public static int mp3=260; public static int mp3T=13; public static int people=18; public static void main(String []args){ Scanner myScanner=new Scanner(System.in);//调用键盘输入 showInfo(); //调用 showInfo 方法 System.out.print(&请输入手掌游戏机价格：&); gbGame=myScanner.nextInt(); System.out.print(&请输入 MP3 价格：&); mp3=myScanner.nextInt(); System.out.print(&请输入手掌游戏机数量：&); gbGameT=myScanner.nextInt(); System.out.print(&请输入 MP3 数量：&);52 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全mp3T=myScanner.nextInt(); showInfo(); } public static void showInfo(){ // 建立 showInfo 方法 int total=gbGame*gbGameT+mp3*mp3T;//总价 float average=(float)total///平均价 System.out.printf(&总价： %d,平均价是: %f \n&,total,average); } } ******************************************************************************* 第六题 手掌游戏机一台 X 元，mp3 一台 Y 元(X,Y,N,M,Z 由用户输入) 公司举行抽奖大会，一等奖游戏机 N 台，二等奖 mp3 M 台。公司共有 Z 人。问总价为多少， 公司实际平均给每人花费了多少钱。 //计算总费用和平均费用 import java.util.*;//加载包 public class Work06{ public static int gbGame=0;//静态变量 public static int gbGameT=0; public static int mp3=0; public static int mp3T=0; public static int people=0; public static void main(String []args){ Scanner myScanner=new Scanner(System.in);//调用键盘输入 System.out.print(&请输入手掌游戏机价格：&); gbGame=myScanner.nextInt(); System.out.print(&请输入 MP3 价格：&); mp3=myScanner.nextInt(); System.out.print(&请输入手掌游戏机数量：&); gbGameT=myScanner.nextInt(); System.out.print(&请输入 MP3 数量：&); mp3T=myScanner.nextInt(); System.out.print(&请输入员工数：&); people=myScanner.nextInt(); showInfo();//调用 showInfo 方法 } public static void showInfo(){ // 建立 showInfo 方法 int total=gbGame*gbGameT+mp3*mp3T;//总价 float average=(float)total///平均价 System.out.printf(&总价： %d,平均价是: %f \n&,total,average); } } *******************************************************************************53 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全第七题 九九乘法表，要求行列对齐[Work07.java] //九九乘法表 import java.util.*;//加载包 public class Work07{ public static void main(String []args){ Scanner myScanner=new Scanner(System.in);//调用键盘输入 System.out.print(&请输入 1-9 中的一个数：&); int num=myScanner.nextInt(); for(int i=1;i&=i++){ for(int j=1;j&=i;j++){ System.out.print(i+&×&+j+&=&+(i*j)+&\t&); } System.out.println(); } } } ******************************************************************************* 第八题 请使用三个整型变量完成如下功能： 1、用户输入两个整数值；3 5 2、计算两数的和，输出此和； 8 3、求出两数的平均数，输出平均数(整数即可)； 4 4、求出平均数&第二个数的关系表达式的值，输出此值； 0 5、用第一个数减去上面关系表达式的值，得到它们的差，输出差； 3 6、存储第二个数的变量累乘上式的结果，输出此变量的当前值； 15 7、存储第一个数的变量累加第二个变量，输出第一个变量的当前值。 18 //输入两个数完成任务集合[Work08.java] import java.util.*;//加载包 public class Work08{ public static void main(String []args){ Scanner myScanner=new Scanner(System.in);//调用键盘输入 System.out.print(&请输入一个数 A：&); int a=myScanner.nextInt(); System.out.print(&请输入一个数 B：&); int b=myScanner.nextInt(); int e=0;//定义变量 //求和 int c=a+b; System.out.println(&和：&+c); //求平均数 int d=(a+b)/2; System.out.println(&平均数：&+d);54 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全//判断平均数是否大于第二个数 if(d&b){ e=1; System.out.println(&平均数&第二个数&); }else{ e=0; System.out.println(&小于&+b+&输出判断值&+e); } //第一个数减去上式的值 int f=a-e; System.out.println(&第一个数减去上式的值&+f); //第二个数乘上式的值 int g=b*f; System.out.println(&第二个数累乘上式的值&+g); //第一个数累加并赋给第一个数 a+=g; System.out.println(&第一个数累加第二个数赋给第一个数的值&+a); } } ******************************************************************************* 第九题 渔夫出海打鱼，收获若干 1、渔夫卖掉一半的鱼，然后送给海伦 3 条； 2、渔夫又卖掉剩下的鱼的 2/3，自己吃掉 1 条； 3、海伦来看渔夫，问他那天打了多少鱼，渔夫数了数，还剩 4 条鱼，渔夫对海伦怎么说？ //打鱼--共有多少鱼[Work09.java] public class Work09{ public static void main(String []args){ int total=0; int rest=4;//剩余的鱼 total=((rest+1)*3+3)*2;//逆推 System.out.println(&鱼一共有：&+total); } } ******************************************************************************* 第十题 有一只猴子摘了一堆桃子，当即吃了一半，可是桃子太好吃了，它又多吃了一个，第二天它 把第一天剩下的桃子吃了一半，又多吃了一个，就这样到第十天早上它只剩下一个桃子了， 问它共摘了多少桃子[Work10.java] import java.util.*;//加载包 public class Work10{ public static void main(String []args){ Monkey mo=new Monkey();55 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全mo.scan(); } } class Monkey{ //day 哪天的桃子数，sday 吃了多少天剩下一个 public static int peach(int day,int sday){//建一个 peach 方法 if(day==sday){ return 1; }else{ return (peach(day+1,sday)+1)*2;//算法返回值 } } public static void scan(){ //建立输入的方法 int a=1; System.out.println(&请输入要吃几天：&); Scanner sr=new Scanner(System.in); int b=sr.nextInt(); if(a&b){ System.out.print(Monkey.peach(a,b)); }else{ System.out.println(&不能小于等于 1 天&); Monkey.scan(); } } } ******************************************************************************* 第十一题 计算 1+2+3+...+20=?思考如果让用户输入一个整数 n 计算累加和： 1+2+3+...+n 能做到吗？ [Work11.java] import java.util.*;//加载包 public class Work11{ public static void main(String []args){ Scanner myScanner=new Scanner(System.in);//调用键盘输入 System.out.print(&请输入一个数 N：&); int n=myScanner.nextInt(); int i=0; for(int m=0;m&n;m++){ i=i+(m+1); System.out.println(&m 是&+m); } System.out.println(&1+2+3+...+n 的值是&+i); } }56 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全******************************************************************************* 第十二题 请编写一个 Cat 类，要求如下： 该猫可以做四则运算，也可以进行面积计算； 将四则运算器和面积运算器合二为一， 作一个运算器， 主菜单让用户选择是做四则运算还是 面积运算，分为两个子菜单，让用户选择加减乘除或者形状。 //一个 Cat 类进行四则运算和面积计算[Work12.java] //一个 Cat 类进行四则运算和面积计算 import java.util.*;//加载包 public class Work12{ public static void main(String []args){ Cat cat=new Cat(); cat.scan1(); } } class Cat{ //输入方法 public static void scan1(){ System.out.println(&题目类型如下&); System.out.println(&1、四则运算&); System.out.println(&2、面积运算&); System.out.println(&0、退出程序&); System.out.print(&请选择要做题的类型，请入 0-2：&); Scanner sr=new Scanner(System.in); int x=sr.nextInt(); switch(x){ case 0: System.out.println(&谢谢使用，再见!&);//退出 case 1: Cat.szys(); case 2: Cat.mjys(); default: System.out.println(&输入有误，请重新输入!&); Cat.scan1();//重复调用目录 } } //四则运算方法 public static void szys(){ System.out.println(&四则运算&);57 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全System.out.println(&1、加法运算&); System.out.println(&2、减法运算&); System.out.println(&3、乘法程序&); System.out.println(&4、除法程序&); System.out.println(&0、返回上级&); System.out.print(&请选择要做题的类型，请入 0-4：&); Scanner sr=new Scanner(System.in); int y=sr.nextInt(); switch(y){ case 0: System.out.println(&返回上级&); Cat.scan1();//调用主目录 case 1: System.out.println(&进入加法运算，请输入第一个数：&); Scanner jf1=new Scanner(System.in); int jf01=jf1.nextInt(); System.out.println(&进入加法运算，请输入第二个数：&); Scanner jf2=new Scanner(System.in); int jf02=jf2.nextInt(); float jfh=(float)jf01+(float)jf02; System.out.println(jf01+&+&+jf02+&=&+jfh); System.out.println(&已计算完成。&); System.out.println(&是否要继续使用？使用请输入 1，返回请输入 2，退出请输入任意数字:&); Scanner cz01=new Scanner(System.in); int cz001=cz01.nextInt(); if(cz001==1){ Cat.szys(); }else if(cz001==2){ Cat.scan1(); }else if(cz001!=1||cz001!=2){ System.out.println(&谢谢使用，再见!&); } case 2: System.out.println(&进入减法运算，请输入第一个数：&); Scanner jjf1=new Scanner(System.in); int jjf01=jjf1.nextInt(); System.out.println(&进入减法运算，请输入第二个数：&); Scanner jjf2=new Scanner(System.in); int jjf02=jjf2.nextInt(); float jjfh=(float)jjf01-(float)jjf02;58 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全System.out.println(jjf01+&-&+jjf02+&=&+jjfh); System.out.println(&已计算完成。&); System.out.println(&是否要继续使用？使用请输入 1，返回请输入 2，退出请输入任意数字:&); Scanner cz02=new Scanner(System.in); int cz002=cz02.nextInt(); if(cz002==1){ Cat.szys(); }else if(cz002==2){ Cat.scan1(); }else if(cz002!=1||cz002!=2){ System.out.println(&谢谢使用，再见!&); } case 3: System.out.println(&进入乘法运算，请输入第一个数：&); Scanner cff1=new Scanner(System.in); int cff01=cff1.nextInt(); System.out.println(&进入乘法运算，请输入第二个数：&); Scanner cff2=new Scanner(System.in); int cff02=cff2.nextInt(); float cffh=(float)cff01*(float)cff02; System.out.println(cff01+&×&+cff02+&=&+cffh); System.out.println(&已计算完成。&); System.out.println(&是否要继续使用？使用请输入 1，返回请输入 2，退出请输入任意数字:&); Scanner cz03=new Scanner(System.in); int cz003=cz03.nextInt(); if(cz003==1){ Cat.szys(); }else if(cz003==2){ Cat.scan1(); }else if(cz003!=1||cz003!=2){ System.out.println(&谢谢使用，再见!&); } case 4: System.out.println(&进入除法运算，请输入第一个数：&); Scanner cf1=new Scanner(System.in); int cf01=cf1.nextInt(); System.out.println(&进入除法运算，请输入第二个数：&); Scanner cf2=new Scanner(System.in); int cf02=cf2.nextInt();59 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全float cfh=(float)cf01/(float)cf02; System.out.println(cf01+&÷&+cf02+&=&+cfh); System.out.println(&已计算完成。&); System.out.println(&是否要继续使用？使用请输入 1，返回请输入 2，退出请输入任意数字:&); Scanner cf03=new Scanner(System.in); int cf003=cf03.nextInt(); if(cf003==1){ Cat.szys(); }else if(cf003==2){ Cat.scan1(); }else if(cf003!=1||cf003!=2){ System.out.println(&谢谢使用，再见!&); } default: System.out.println(&输入有误，请重新输入!&); Cat.szys();//循环调用子目录 } } //面积运算方法 public static void mjys(){ System.out.println(&面积运算&); System.out.println(&1、三角形面积计算&); System.out.println(&2、圆形面积计算&); System.out.println(&3、方形面积计算&); System.out.println(&0、返回上级&); System.out.print(&请选择要做题的类型，请入 0-3：&); Scanner sr=new Scanner(System.in); int z=sr.nextInt(); switch(z){ case 0: System.out.println(&返回上级&); Cat.scan1();//调用主目录 case 1: System.out.println(&进入三角形面积计算，请输入底：&); Scanner sj1=new Scanner(System.in); int sjx01=sj1.nextInt(); System.out.println(&进入三角形面积计算，请输入高：&); Scanner sj2=new Scanner(System.in); int sjx02=sj2.nextInt(); float sjxh=((float)sjx01*(float)sjx02)/2;60 | 449注：笔记中所有示例都能正常通过编译Java 学习笔记_全System.out.println(&底&+sjx01+& 高：&+sjx02+& 面积=&+sjxh); System.out.println(&已计算完成。&); System.out.println(&是否要继续使用？使用请输入 1，返回请输入 2，退出请输入任意数字:&); Scanner sj03=new Scanner(System.in); int sj003=sj03.nextInt(); if(sj003==1){ Cat.mjys(); }else if(}