电子教案-《Java程序设计及应用》

第1讲：Java入门内容提要课程简介什么是JavaJava的起源与发展搭建开发环境HelloWorld案例JDKAPI文档Java学习建议1课程简介与其它课程的关系你将学到什么？下一步能做什么？考核方式（1）平时：20%，以作业/考勤为依据（2）实训项目:20%（3）单元测验：30%。（4）期末考试：开卷，30%教学目标了解Java语言产生的背景、主要特点、与C/C++的区别以及Java的应用情况和最新进展，激发学习兴趣。会搭建自己的Java程序开发平台。能编写、编译、运行一个简单的Java程序理解Java程序的编译执行过程。教学重点与难点重点：掌握Java程序的编译和执行方法。难点：1）对Java虚拟机概念及其工作原理的理解。2）对Java程序的编译、执行过程的理解。2什么是JavaJava是一种通用的、并发的、基于类的、面向对象的高级编程语言。具有简单、面向对象、分布式、多线程、高性能、可移植、健壮、安全、跨平台等特点。Java在嵌入式软件、桌面软件和网络分布式软件领域具有广泛的应用。3Java的起源与发展Java起源于1991年Sun公司的一个叫“Green”的项目。1995年5月23日，Sun在SunWorld’95上正式发布Java和HotJava浏览器，这标志着Java的诞生。触发了Java进军Internet。1996年1月，Sun发布了JDK1.0，当年12月发布JDK1.1。1998年2月，发布了JDK1.2。1999年，Java技术被分成J2SE（原来的JDK）、J2EE、J2ME三个平台，JavaServerPages（JSP）技术公诸于众，J2SE平台开始支持Linux操作系统。Java的起源与发展（续）2000年5月8日，J2SE1.3发布。2001年9月24日，J2EE1.3发布。2002年2月26日，J2SE1.4发布。2004年9月30日，J2SE1.5发布，是Java语言发展史上的又一里程碑事件。2007年，JavaSE1.6发布，其计算性能又得到了进一步的提升，开始支持脚本（script）语言并进一步加强对多核CPU的支持。4搭建开发环境学习型环境文本编辑（EJE）JDK开发型环境NetBeansEclipse搭建开发环境安装软件文本编辑器件JDK设置环境变量PATHCLASSPATH注意事项安装路径不要有空格、汉字不要装在操作系统分区中JDK安装动画演示动画演示(windows)动画演示(linux)5HelloWorld案例输入代码并保存(文件名为Test.java)classHelloWorld{ publicstaticvoidmain(String[]args){System.out.println("HelloWorld!"); }}编译javacTest.java运行javaHelloWorld动画演示案例分析Java程序源代码区分英文字母的大小写Java源代码文件必须以.java作为扩展名一个源代码文件至多包含一个public类，若在源代码文件中定义了public类，则源代码文件的文件名必须与public类的类名相同（包括英文字母的大小写也要相同）；若在源代码文件中没有定义public类，则源代码文件的文件名任意。编译过程运行过程main方法6JDKAPIDoc该文档的重要性JDKAPI文档是Sun公司为JDK平台提供的一套完整的API文档资料，无论在学习阶段还是在实际软件开发过程中，该文档都是必备文档，以供编程者查阅参考。获取该文档的途径本书配套实训的附带光盘；也可以从直接下载。JDKAPIDoc(续）7Java学习建议打好基础眼手脑并用勤于参考JDKAPI文档有效使用网络资源计算机英语小结介绍了Java的起源和发展Java开发环境的搭建HelloWorld入门程序JDKAPI文档的使用方法最后给出了学习Java的几点建议。其中重点是Java开发环境、HelloWorld案例编程、JDKAPI文档的使用方法等内容，只有这些问题彻底搞清楚了，后面的学习才会顺畅。作业练习搭建开发环境理解环境变量的作用模仿HelloWorld程序，自己编写一个简单的程序，输出字符串“我喜欢Java”。习题1：1-10第2讲：Java语言基础（1）内容提要注释关键字标识符基本数据类型字面值与常量变量教学目标与重点、难点目标能按照程序编写规范，熟练编写简单Java应用程序。正确定义与使用变量、常量，正确使用运算符与表达进行数值计算程序的处理。重点都是难点基本数据类型字面值与常量变量1注释单行注释//多行注释/*…*/文档注释/**…*/2关键字abstractconstfinalinstanceofprivateswitchvoidbooleancontinuefinallyintprotectedsynchronizedvolatilebreakdefaultfloatinterfacepublicthiswhilebytedoforlongreturnthrowassert关键字（续）casedoublegotonativeshortthrowscatchelseifnewstatictransientcharextendsimplementsnullstrictfptrueclassfalseimportpackagesupertry续表3标识符命名原则字母、数字、下划线、$首字符不能是数字字面区分大小写JDK内置多国语言引起的变化：$可用其他国家的货币符号（如£、￥）来代替可以使用汉字或其他国家文字作为标识符建议仍遵循原来的命名原则4基本数据类型数据类型位长（bits）取值范围boolean1true，falsebyte8-27～27-1char16'\u0000'～'\uffff'short16-215～215-1int32-231～231-1long64-263～263-1float32±1.4E-45，±3.4028235E+38double64±4.9E-324，±1.7976931348623157E+3085字面值与常量字面值（literal）是指在程序源代码中直接给出的一个数据值（数值或字符串），目的是为变量赋值或参与表达式运算。常量（也称不变量）是指采用修饰符final修饰的一个变量名（属于标识符）。将一个变量名采用final修饰为常量，然后赋给它一个字面值，这就在二者之间画上了等号。例如：finalinta=123;char字面值一对单引号构成，例如‘a’‘中’注意与字符串字面值区分“abcde”还包括转义符char字面值——转义符转义符含义unicode编码转义符含义unicode编码\'单引号\u0027\"双引号\u0022\\反斜杠\u005c\b退格\u0008\f换纸走页\u000c\n换行newline\u000a\r回车\u000d\t水平制表符tab\u00096变量该部分包括：变量的含义变量的声明变量的作用域变量的初始化6.1变量的含义在程序运行期间，系统为程序分配一块内存单元，用于存储对应类型的数据。系统分配的内存单元在程序源代码中采用一个变量来标识。用一个变量标识一块内存单元后，程序就可以使用变量名代表这块内存单元中的数据，即变量名标识内存单元，变量的值就是存储在内存单元中的数据。6.2变量的声明变量的使用分为变量的声明和变量的赋值两个步骤，这两个步骤是有先后顺序的，即先声明后赋值。声明变量的语法有多种形式：datatypevarname; //声明一个变量

datatypevarName=value;//声明变量的同时赋值

datatypevar1,var2,...,varN;//同时声明多个变量

datatypevar1=val1,var2=val2,...,varN=valN;6.3变量的作用域变量的作用域就是一个变量起作用的代码区域范围或者有效范围。{}内部的代码称为代码块或者块语句，代码块决定了在其中定义的变量的作用域。例如：1{

2intx=0;inta=2;

3{

4inta=1;//错误

5inty=0;

6y=y+1;

7x=2;//正确

8}

9x=x+1;

10y=3;//错误

11}6.4变量的初始化Java中变量分为对象成员变量和方法局部变量，对象成员变量放在面向对象部分再讲，对于方法局部变量，在使用之前必须完成初始化，所谓初始化就是给变量赋初始值。例如：1//LocalVarInitTest.java

2publicclassLocalVarInitTest{

3publicstaticvoidmain(String[]args){

4intx;

5inty=x+1;//错误

6}

7}小结注释关键字标识符基本数据类型字面值与常量变量作业习题2：1，3，4，5，6第3讲：Java语言基础（2）内容提要基本类型的类型转换强制类型转换自动类型转换数组使用数组的基本步骤步骤组合多维数组数组处理工具数组的优缺点教学要求1.正确理解类型转换机制并能够熟练编程处理。2.理解数组的原理，并能够熟练使用数组进行编程。1基本类型的类型转换类型转换的必要性在实际编程过程中经常需要把一种类型的数据赋给另一种类型的变量，或者对不同类型的数据进行运算，这时就需要进行类型的转换。强制类型转换也称为显式类型转换，当被转换数据的类型取值范围大于目标类型的取值范围时，就需要进行强制类型转换，其语法格式如下：(目标类型)被转换的数据举例：intk=3;

byteb=(byte)k;强制类型转换注意事项强制类型转换是从高类型向低类型转换，转换后的结果可能会出现两个问题：（1）精度损失。浮点型→整型，则小数丢失，例如intb=(int)12.12。（2）溢出问题。当被转换数据超出了目标类型的取值范围时会发生溢出问题，例如byteb=(byte)123456789.12。自动类型转换自动类型转换也称为隐式类型转换，在8个基本类型中只有数值型的数据能够进行自动类型转换，且源数据的类型取值范围小于目标类型的取值范围，即

byte<short <int<long<float<double

（*）char <int<long<float<double(*)按照从左到右的顺序能够进行自动转换。类型转换注意事项（1）无论是自动转换还是强制转换，转换的只是变量或者表达式的“读出值”，而变量或者表达式自身的类型和值都未被改变。（2）自动类型转换顺序(*)中注意short和char虽然都占用16bits，但地位不是对等的，例如：1bytea=97;

2shorts=a;//该行正确，发生了类型自动转换

3charc=97;//该行正确，变量c的值是字符'a'

4c=a;//该行编译不通过，原因可能是损失精度

5c=s;注意事项（续）（3）int类型转换为float，当有效数字个数超过8个；或者将long类型转换为double，当有效数字个数超过18个，就会发生精度损失，例如：inti=1234567890;

floatf=i;//此时f=1.23456794E9，而不是1234567890.0（4）由float向double类型转换时，如果使用了关键字strictfp，则精度不会有损失，否则精度可能有损失。2数组数组的概念数组是一种集合数据类型，它是由类型相同的数据组成的有序数据集合，在Java中数组是对象，继承了Object类并实现了Cloneable、java.io.Serializable接口，从而Object中的方法可被继承到数组中使用。数组的变成步骤声明分配空间初始化2.1声明数组语法格式为：datatype[]varName;

datatypevarName[];//也可以把[]放在varName的后面注：[]的前后可以有零个、一个或多个空格。其中的datatype可以是基本数据类型（8个），也可以是引用类型（包括类、抽象类、接口）。例如：int[]a;

int[]b;

Stringc[];

Objectd[];方括号[]在数组变量名的前后都可以，建议采用在变量名前的方式。2.2分配空间语法格式为：变量名=new类型[数组长度];例如：a=newint[3];//分配了3个内存空间

b=newint[4];

c=newString[2];只有创建Java对象时才使用new关键字，从这一点也可看出，数组是Java对象。2.3初始化初始化就是为数组的成员赋初始值，一般采用for循环，例如：for(inti=0;i<a.length;i++){//尽量不要采用i<3，应尽量采用a.length

a[i]=2;

}注意数组的索引（index）是从0开始的，索引的类型是int，故byte、short、char、int类型的变量可以作为索引变量使用。a.length是使用了数组对象的length属性，length的值是在分配空间阶段由系统根据分配空间的大小来自动赋值的。对数组的越界访问是不允许的，虽然编译代码没有问题，但运行过程中Java会进行是否越界访问检查，一旦发现越界访问，则抛出ArrayIndexOutOfBoundsException异常，关于异常处理请详见第5章数组使用的组合上述三个步骤是使用数组编程的三个基本步骤，这三个步骤可以组合在一起，其组合方式有：2.1+2.22.2+2.32.1+2.2+2.3

组合：2.1+2.2语法为：类型[]变量名=new类型[数组长度];类型变量名[]=new类型[数组长度];//也可以这样例如：int[]a=newint[3];

intb[]=newint[4];组合：2.2+2.3语法为：变量名=new类型[]{值1,值2,...,值n};类型[]变量名={值1,值2,...,值n};例如：a=newint[]{1,2,3};//这称为动态创建数组

b={1,2,4,3};//这称为静态创建数组组合:2.1+2.2+2.3语法为：类型[]变量名=new类型[]{值1,值2,..,值n};类型[]变量名={值1,值2,..,值n};例如：int[]a=newint[]{1,2,3};

int[]b=newint[3]{1,2,3};//错误

doubled={1.1,2.1,3.0};多维数组Java并不存在真正的多维数组，所谓的多维数组是由多个一维数组嵌套合成的，即把多维数组看作是数组的数组，使用这种方法把多维数组逐一分解，直到分解成一维数组为止。这种机制使得Java多维数组具有很强的灵活性。多维数组编程同样遵循前面介绍的三个基本步骤，其组合方式同样适用于多维数组。多维数组例程1/*声明*/

2int[][]a;

3int[]b[];

4intc[][];

5int[][]d;

6

7/*分配空间*/

8a=newint[2][3];//2行3列

9

10/*下面代码只分配了3行，没有分配列，此时b是一维数组，

11*其长度为3，而b的每个元素又是一维数组，其空间还未分配。

12*/

13b=newint[3][];

14/*下面代码为b的每个元素分配空间*/

15b[0]=newint[3];//或b[0]=newint[]{1,2,3},或b[0]={1,2,3}

16b[1]=newint[2];

17b[2]=newint[1];

18

例程（续）19/*初始化*/

20for(inti=0;i<a.length;i++){

21for(intj=0;j<a[i].length;j++){

22a[i][j]=i+j;

23}

24}

25

26for(inti=0;i<b.length;i++){

27for(intj=0;j<b[i].length;j++){

28b[i][j]=i+j;

29}

30}

31

32/*静态初始化，分配空间与赋初值同时完成*/

33c={{1,2},{5}};

34

35/*动态分配空间与赋初值同时完成*/

36d=newint[][]{{1,2},{0},{3,4}};数组处理工具java.util.Arrays类是专门用于操作数组的，提供了搜索、排序、复制等静态方法。Arrays类中常用的方法如下：equals()：比较两个数组是否相等，所谓两个数组相等是指两个数组拥有相同的元素个数，且所有对应元素相等。fill()：将值填入数组中。sort()：用来对数组进行排序。binarySearch()：在排好序的数组中寻找元素。另外一个工具是System.arraycopy()，用于对数组进行复制。数组的优缺点数组的优点是数据结构简单，能够进行随机访问，且访问的速度很快。其缺点有：（1）数组一旦分配了空间，其大小就不能再改变。（2）数组中所有元素的数据类型都必须相同。（3）不能对数组实施插入或者删除操作。（4）无法判断数组中实际存在有多少元素，length只是告诉数组的容量。若读者在编程时需要上述特征，则不能使用数组，而是使用JavaCollection框架（Framework）类，详见第8章。小结基本类型的类型转换强制类型转换自动类型转换数组使用数组的基本步骤步骤组合多维数组数组处理工具数组的优缺点作业习题27，9，10，11第4讲：方法与包内容提要方法方法的参数传递方法的可变参数格式化输出包importpackage教学要求重点掌握：方法的参数传递原则使用import/package语句的程序代码的编译、执行过程。这也是一个难点。1方法的参数传递Java方法的参数传递所遵循的规则栈内容拷贝传递。要理解这个规则需要首先弄清楚Java对内存的划分管理。Java把内存分为栈（stack）和堆（heap）两部分。栈是Java访问内存的入口，对堆的访问是通过栈完成的。在栈中存放变量的值，若变量是基本类型的，则变量的值就是数据本身，这时Java直接把数据放在栈中；若变量是引用类型的，则会在堆中开辟一块连续的区域用来存放对象，并把对象的首地址放在栈中，即变量的值是对象的首地址。所谓栈内容拷贝传递就是把栈中变量的值拷贝了一份，然后把副本传给了方法参数。代码演示21inti=10;

22t.methodOne(i);

23System.out.println("i="+i);26Aa=newA();

27t.methodTwo(a);

28System.out.println("a.k="+a.k);30Strings="abc";

31t.methodThree(s);

32System.out.println("s="+s);方法的可变参数所谓可变参数就是指方法的参数个数不是固定的，而是变化的，可以是零个，也可以是任意正整数个。其声明的语法如下：methodName(VarParaType...var){

//...

}例如：voidf(inta,Stringb,int...var){}

voidg(String...str){}可以这样调用上面的方法：g();

g("abc");

g("a","b");

g("a","b","c");格式化输出publicPrintStreamprintf(Stringformat,Object...args)举例4//定义一些变量，用来格式化输出

5doubled=345.678;

6Strings="你好！";

7inti=1234;

8

9//"%"表示进行格式化输出，"%"之后的内容为格式的定义

10System.out.printf("%f\n",d);//"f"表示格式化输出浮点数举例（续）12//"9.2"中的9表示输出的长度，2表示小数点后的位数

13System.out.printf("%9.2f\n",-d);

14

15System.out.printf("%+9.2f\n",d);//"+"表示输出的正数带正号

16

17//"-"表示输出的数左对齐（默认为右对齐）

18System.out.printf("%-9.4f\n",d);

19

20//"+-"表示输出的数带正负号且左对齐

21System.out.printf("%+-9.3f\n",d);

22

23System.out.printf("%d\n",i);//"d"表示输出十进制整数

24System.out.printf("%o\n",i);//"o"表示输出八进制整数

25System.out.printf("%x\n",i);//"x"表示输出十六进制整数

26

举例（续）27//"#x"表示输出带有十六进制标志的整数

28System.out.printf("%#x\n",i);

29

30System.out.printf("%s\n",s);//"s"表示输出字符串

31

32//可以输出多个变量，注意顺序

33System.out.printf("输出一个浮点数："+34"%f，一个整数：%d，一个字符串：%s\n",d,i,s);

35

36//"k$"表示格式字符串之后的第k个参数,k是具体数字

37System.out.printf("字符串：%2$s，%1$d的十六进制数：%1$#x",i,s);

38

包Java采用包机制的原因packageimportpackagepackage语句首先看一个例子：1packageabc.d;

2classTestPackage{

3publicstaticvoidmain(String[]args){

4System.out.println("Youareright!");

5}

6}编译、运行javac-dC:\testTestPackage.java

java-cpC:\testabc.d.TestPackageimport与importstaticimportstaticpkg.ClassName.staticMember;

importstaticpkg.ClassName.*;//也可以这样

例如：1importstaticjava.lang.System.*;

2//不可import静态属性的静态成员，如下行代码所示

3//importstaticjava.lang.System.out.*;//error

4//importstaticSystem.*;//java.lang不可以省略小结方法方法的参数传递方法的可变参数格式化输出包importpackage作业习题22，8，13第5讲：运算符与流程控制内容提要Java运算符算术比较逻辑位赋值Java流程控制顺序分支循环跳转教学要求熟练掌握运算符和流程控制的编程语法。1Java运算符——算术运算符算术运算符有+、-、*、/、%、++、--。（1）+，有三种功能：正号、加号和字符串连接。（2）-，有两种功能：负号和减号。（3）*，要注意乘法运算后结果是否超出了类型的取值范围，例如：inta=123456,b=2345678,c;

c=a*b/b;//结果不是123456,而是778（4）/，当左右两个操作数都是整型数时，/表示的是整除（5）%（取余运算符），其计算结果的符号只与第一个操作数的符号相同，与第二个操作数的符号无关，例如10%3=1，10%-3=1，-10%3=-1，-10%-3=-1，-10.3%3=-1.3。%的操作数可以是整数也可以实浮点数。比较运算符该运算符对左右两端的操作数进行比较，运算结果是boolean类型的。比较运算符有==（相等）、!=（不等）、<、<=、>、>=、instanceof。注意：==与=不同，前者是比较操作符，后者是赋值操作符，例如booleanb=false;

if(b=true){//赋值

System.out.println("Hello");

}

if(b==true){//比较

System.out.println("World");

}逻辑运算符运算符名称说明!NOT（非）!true为false，!false为true&&AND（短路与）左右都是true时，结果为true，否则为false||OR（短路或）只要有一者是true，结果就是true，否则为false&AND（非短路与）同&&|OR（非短路或）同||位运算符运算符功能运算符功能～

按位（bit）非

|按位或

&按位与

按位异或

<<左移，右端移空的低位补

0>>带符号右移，左端移空的高位填补的数值和原来左端最高位相同>>>无符号右移，左端移空的高位补

0位运算符的几点说明（1）位运算符可以与=组合使用，例如a>>=2，a&=b，…。（2）位运算只适用于byte，char，short，int，long类型的数据。（3）位运算不会对原数据实施操作，而是对原数据的副本实施操作，例如inta=10;a>>1;则a的值不变。（4）移位运算的操作数如果类型不一致，则会发生类型的自动提升，例如a>>b，提升规则为：若a，b的类型都低于int，则自动提升为int型，否则运算结果的类型和a，b中的最高类型一致。（5）对移位运算而言，例如a>>b，若a为int型，则实际移动的位数为b%32，例如inta=10；a<<1与a<<33的结果相同。若a的类型为long，则实际移动的位数为b%64。（6）a>>1与a/2的结果相同，a<<1与的结果相同，只是移位运算的速度快。赋值运算符赋值运算符为=，可以单独使用，例如a=10，也可以与其他运算符组合使用，若其他运算符统一抽象用⊙表示，则a⊙=b在功能上和a=a⊙b相同，例如a+=3同a=a+3。可组合使用的运算符有：+、-、*、/、%、&、|、ˆ、<<、>>、>>>。赋值可以连续使用，例如inta，b，c，d；a=b=c=d=10；连续赋值时，赋值顺序自右向左。运算符的优先级上述的各种运算符之间是有优先级的，但本着程序代码的易读性，我们不必要知道他们的优先级。举例inta=20;

b=a+++a/4;

流程控制Bohra和Jacopini提出了程序设计的三种基本结构：顺序结构、条件分支结构和循环结构，并从理论上证明了一切可描述的程序算法均可通过使用这三种结构得到解决。顺序结构顺序结构是程序设计中最基本最简单的结构，一切程序设计算法，归结到计算机指令，都是顺序执行的，顺序结构要求按顺序执行每一条指令。条件分支结构if语句条件表达式switch语句if语句if语句有以下几种表现形式：（1）if(boolean表达式){

语句块;

}（2）if(boolean表达式){

语句块1;

}else{

语句块2

}（3）if(boolean表达式1){

语句块1;

}elseif(boolean表达式2){

语句块2;

}

elseif(boolean表达式n){

语句块n;

}else{

语句块n+1

}（4）if语句的嵌套。if语句可以嵌套使用以表达更复杂的条件判断。如：if(a==2){

if(b==3){

语句块1;

}else{

语句块2;

}

语句块3;

}条件表达式语法为：表达式1?表达式2:表达式3;含义是若表达式1的结果为true，则执行表达式2并返回其值，否则执行表达式3并返回其值。条件表达式相当于if…else…结构，例如：intx=-10;

intabsX=x>0?x:-x;//执行完后absX=10switch语句switch(表达式){

case常量表达式1:

语句块1;

break;

case常量表达式2:

语句块2;

break;

case常量表达式n:

语句块n;

break;

default:

语句块n+1;

break;

}说明（1）switch表达式的类型只能是byte、char、short、int中的一种。（2）case语句后常量表达式的类型与switch表达式的类型一致，常量表达式中不能含有变量。（3）break语句为可选项，放在每个case语句块的末尾，当执行break语句后，就会结束switch语句的执行。若没有break语句，则会继续执行后续的case分支语句，直到遇到break语句或switch语句结束。（4）default语句的数量可为0或1，case语句的数量可为0或1或多个。default与case语句之间没有先后顺序，只是习惯上把default语句放在最后。循环结构Java的循环结构有三种：whiledo…whilefor循环。whilewhile(boolean表达式){

循环体;

}含义是首先计算boolean表达式的值，若为true则执行循环体，直到boolean表达式的值变为false为止。注意boolean表达式不能为字面常量false，试比较booleanb=false;

while(b){//正确，但该循环体一次也得不到执行

}

while(false){//编译错误，在程序中该段代码的存在没有任何意义

}dowhile循环do{

循环体;

}while(boolean表达式);for循环for(表达式1;表达式2;表达式3){

循环体;

}表达式1表达式2循环体表达式3truefalse退出循环优化的for循环从JDK5.0开始新增加了for循环的一种新用法，称为优化的for循环，用于遍历数组或者集合对象，集合详见8.2.2节。例如：String[]s={"a","b","c"};//对象类型的数组

for(Stringi:s){

//i是s的元素变量，变量i需要声明其类型，即s的元素的类型。

//s可以是数组或者集合。

System.out.println(i);

}

int[]i={1,2,3};//基本类型的数组

for(intk:i){

System.out.println(k);

}跳转语句break语句continue语句return语句break语句break语句可以中断switch语句或循环语句的执行。break语句分为带标号和不带标号两种形式，其格式为：break[标号];int[]a={1,2,3};

lab1:while(true){

for(inti=0;i<a.length;i++){

if(a[i]<0)

break;//跳出当前的for循环

elseif(a[i]==0)

breaklab1;//跳出lab1标记的while循环

}

}continue语句continue语句只适用于循环体语句，其功能是终止当前这一轮循环，不再继续执行continue语句后面的语句，而直接进入下一轮的循环。其格式为：continue[标号];intk=0;

int[]a={1,2,3,-1,0};

lab2:while(k<100){

for(inti=;i<a.length;i++){

if(a[i]<0)

continue;//跳到i++

elseif(a[i]==0)

continuelab2;//跳到lab2处

}

}return语句return语句用在方法中，其功能是终止当前方法的继续执行，并返回到调用该方法的位置之后。其格式为：return[表达式];小结Java运算符算术比较逻辑位赋值Java流程控制顺序分支循环跳转作业编程输出：Fibonacci数列。编程为学生成绩分类：不及格：0-59及格：60-69中：70-79良：80-89优：90-100第6讲：面向对象（1）内容提要人与计算机的关系物理世界与面向对象类与对象面向对象基本特征封装访问修饰符继承多态重载覆盖教学要求物理世界与面向对象的思想、方法计算机面向对象的思想、方法如何定义一个类以及创建其实例面向对象的三个基本特征人与计算机的关系人处于主体地位，计算机只能处于从属地位。计算机必须能够模拟这个物理世界。计算机是个小世界，而物理世界是个大世界，小世界来源于大世界物理世界的认知（1）世界由万物构成。（2）事物是运动的、发展的、变化的。（3）事物之间的关系是复杂的、多变的。事物的基本特征（1）封装。保护功能相对独立性（2）继承加快事物发展的速度提高事物发展的质量（3）多态。透过现象抓本质，以不变应万变。事物间的关系泛化关系（Generalization）聚合关系（Aggregation）组合关系（Composition）依赖关系（Dependency）关联（Association）。类与对象世界由万物构成，经由前面的学习，我们知道研究物理世界要用分类的方法。在面向对象程序设计中用类（class）来模拟一类事物。类的定义需用关键字class，定义一个简单类的语法如下：class类名{//该行称为类头，大括号之间的部分称为类体

零或多个属性;

零或多个方法;

}其中属性的定义格式有两种，如下：（1）类型属性名[=属性值];（2）类型属性名1[=属性值1],属性名2[=属性值2],...;类定义举例1classStudent{

2Stringsno;//学号

3Stringname,major;//姓名,专业

4intage;//年龄

5

6voidshowInfo(){

7System.out.println("学号:"+sno+"\t姓名:"+name+

8"\t年龄:"+age+"\t专业:"+major);

9}

10

11Student(){//第一种构造方法

12}

13

14/*第二种构造方法*/

15Student(Stringsno1,Stringname1,Stringmajor1,intage1){

16sno=sno1;

17name=name1;

18major=major1;

19age=age1;

20}

21}

22实例对象实例对象可以使用类的构造方法和new关键字构造出来。语法为：类名对象引用=new构造方法;例如：Studentt=newStudent();类的成员1．成员属性的定义成员属性也称为成员变量，定义一个成员属性，格式为：[修饰符]类型成员属性名[=成员属性值];例如：inta=10;

intb;

Strings1;

Strings2=newString("abc");其中修饰符暂不讲，详见3.8节。2．成员方法的定义语法为：[修饰符]返回类型方法名([形式参数列表])

[throws异常类型列表]{//方法头

执行语句块;//方法体

}成员变量的初始化成员变量类型默认值成员变量类型默认值

booleanfalsechar‘’（即空字符）byte，short，int0long0Lfloat0.0Fdouble0.0D引用类型

null构造方法当使用new关键字创建一个类实例对象时，系统（JVM）会自动调用该类的构造方法来完成类实例对象的构建，从而构造方法对类定义来说是必须的。那么我们在类中如何声明一个构造方法呢？如下：[访问修饰符]类名([参数列表]){

//

}构造方法的几点说明（1）构造方法的访问修饰符可以是public，protected或者缺省（即不用访问修饰符），但不允许private。（2）构造方法的名称和类名相同，但没有返回类型。（3）若没有定义任何构造方法，则在编译阶段编译器会在编译后的字节码文件中插入一个默认的构造方法，默认的构造方法是：无参数列表，访问修饰符和类的访问修饰符相同，方法体内为空。（4）构造方法本身不能递归调用。（5）构造方法体的最后一行语句可以是空的return语句，即“return;”，也可以不用return语句。（6）可在一个类中定义多个构造方法，其区别在于参数列表不同，这是构造方法的重载。关于重载，详见3.5.1节。封装的Java表达与访问修饰符封装有两个作用：保护作用和增强对象的独立性。保护作用是通过设置访问修饰符来实现的。访问修饰符有4个：public、protected、默认访问修饰符、private。其中默认访问修饰符就是没有修饰符，即不用public、protected、private中的任何一个。访问修饰符用于对类、成员属性和成员方法设置访问权限，对它们实施保护作用。访问修饰符（1）public可用于修饰类、成员变量和方法。表明该成员变量和方法是共有的，能在任何情况下被访问。Java应用程序中的main()方法必须用public来修饰（否则能通过编译，但不能运行），就是为了使JVM能够访问它。在一个源代码文件中最多只能定义一个public类，且该类名必须和源代码文件同名。（2）protected只能用于修饰成员属性或成员方法，不能修饰类。用protected修饰的成员可以被同包（package）下其他类方法访问，也可以被不同包下的子类方法访问。（3）默认访问修饰符修饰的成员只能被同包下的类方法访问。（4）private修饰的成员只能被同类中的方法来访问。这4种访问修饰符的访问范围由大到小，或安全保护程度由低到高依次是：public、protected、默认访问修饰符、private。举例1classT{

2privateStrings="abc";

3publicStringgetS(){//称作访问方法

4returns;

5}

6}

7

8classTest{

9publicvoidfunc(){

10Tt=newT();

11Strings1=t.s;//非法

12Strings2=t.getS();//合法

13}

14}继承继承的作用：一是提高了软件的开发速度，二是提高了开发软件的质量。继承有广义和狭义之分。广义的继承有些拿来主义的味道，因此在Java中分为横向手法和纵向手法。横向手法是指采用import语句来继承要使用的类或Java接口；纵向手法是指采用extends关键字来实现的手法。狭义的继承就是只指纵向手法。无论是横向手法还是纵向手法都不违背继承的两个作用。在面向对象编程中继承概念通常是指狭义的。举例1classStudent{

2publicvoidfunc(){

3System.out.println("Student");

4}

5}

6

7classFreshmanextendsStudent{

8publicstaticvoidmain(String[]args){

9Freshmanb=newFreshman();

10

11/*能够调用Freshman对象的func方法,

12*说明func来自Student.

13*/

14b.func();

15}

16}Java不支持多重继承，单继承使Java的继承关系很简单，一个类只能有一个父类，易于管理程序，同时一个类可以实现多个接口（详见3.6节），从而克服单继承的缺点。继承描述的是一种isa关系，例如上例FreshmanisaStudent，是一种特殊与一般的关系。继承是在两个不同的类之间发生的一种关系，被继承的内容是建立在访问权限（受访问修饰符控制）可访问的基础上的，有以下结论。（1）子类的访问修饰符不小于父类的访问修饰符（private<默认<protected<public）。（2）private修饰的成员不可以被继承。（3）默认访问修饰符修饰的成员只能被同包下的其他类继承。（4）构造方法不能被继承。父类+属性1#属性2-属性3+方法()子类图3.2类的继承关系（5）不管父类是否是abstract的，子类可以声明为abstract的，同样，父类中的方法不管是否是abstract的，在子类中都可以把该方法声明为abstract的。继承的UML表示父类+属性1#属性2-属性3+方法()子类图3.2类的继承关系this与super关键字this代表类实例对象自身，super代表父类实例对象。在一个类中可以定义多个构造方法，若在一个构造方法中调用另一个构造方法时，必须使用this。super不可以连续使用。多态的Java表达ava表达多态的方式有两种：一是重载（overload）二是覆盖（override）。重载重载是指在同一个类中定义多个同名方法，要求他们的参数列表不同。区分重载方法只能通过参数列表，例如：1classT{

2publicvoidfunc(){

3System.out.println("func()");

4func(10);//输出结果为a=10

5}

6publicvoidfunc(inta){

7System.out.println("a="+a);

8}

9protectedintfunc(inta,intb){...}

10Stringfunc(Strings){...}

11}重载说明重载方法对修饰符列表、返回类型、抛出异常类型（详见第5章）是否相同均不作要求，区别仅仅在于参数列表。重载方法是程序的一种静态结构，即重载方法之间的关系在编译器编译后就确定了，不会随程序代码的执行来动态确定，这一点和覆盖不同，覆盖是程序的一种动态结构。正是由于重载是一种静态结构，所以完全可以把重载方法看作是各自不同的方法，这一点与不同名的方法之间的关系没有什么区别。在一个重载方法内可以直接调用另外一个重载方法，但在一个重载的构造方法内却不能直接调用另一个重载的构造方法，必须使用this。覆盖覆盖是指在具有继承关系的两个不同类中定义同名方法，是建立在继承的基础上的，要求如下：（1）private方法不能被覆盖，因为private方法不允许被继承。（2）方法名、返回类型、参数列表必须相同。（3）子类方法的访问修饰符≥父类方法的访问修饰符。（4）子类中的覆盖方法的修饰符不能是final、static，因为final修饰的标识符是不可改变的，而覆盖就是对父类方法的一种修改，若父类方法不需要修改，只采用继承就好了。static是一种静态行为，而覆盖则是一种动态行为。（5）子类中的覆盖方法声明的抛出异常不能是父类被覆盖方法声明的抛出异常的祖先类，只能是其子类或同类。子类中的覆盖方法也可以不声明抛出异常，尽管父类中的被覆盖方法声明抛出了异常。详见第5章。成员变量的覆盖方法可以被覆盖，成员变量也可以被覆盖。举例1classT1{

2publicStrings="T1";

3publicStringgetS(){

4returns;

5}

6}

7classT2extendsT1{

8publicStrings="T2";

9publicStringgetS(){

10returns;

11}

12}

13classTest{

14publicstaticvoidmain(String[]args){

15T1t1=newT1();

16T2t2=newT2();

17

18System.out.println(t1.s);//输出T1

19System.out.println(t1.getS());//输出T1

20System.out.println(t2.s);//输出T2

21System.out.println(t2.getS());//输出T2

22

23t1=t2;

24System.out.println(t1.s);//输出T1，而不是T2

25System.out.println(t1.getS());//输出T2，而不是T1

26}

27}程序分析从上面程序24、25两行代码的输出结果，可以得出如下结论：（1）成员变量可以被覆盖。（2）若直接访问发生覆盖的成员变量，则只能访问引用类型的成员变量，上例中第24行，虽然t1指向的对象是T2类型的，但引用t1的类型是T1，故输出结果是T1。（3）若通过发生覆盖的方法来访问发生覆盖的成员变量，则访问的成员变量和方法属于同一个对象，例如第25行，t1指向的对象是T2类型的，方法getS()是属于T2实例对象的，故访问的变量是T2实例对象的。所以，若上例中没有第8行代码，则成员变量s会被继承，从而第25行代码的输出是T1。若没有第9～11行代码，会发生方法的继承，但方法本身还是类T1的，不是T2的，故第25行代码的输出是T1。小结物理世界与面向对象类与对象面向对象基本特征封装访问修饰符继承多态重载覆盖作业习题3：1，2，3第7讲：面向对象（2）内容提要接口与抽象类引用类型的类型转换其他修饰符类实例对象的创建过程教学要求重点掌握前三项内容，最后一项内容要理解。接口在Java中提到接口，有两种含义：一是Java接口，Java语言中存在的结构，和类（class）相似，是一种Java引用类型；二是一个成员方法，即API。Java接口的定义有两部分：接口头和接口体。格式如下：[public|abstract]interface接口名[extends接口列表]{

常量声明;

方法声明;

}程序举例interfaceT{

staticfinalStringS1="abc";

StringS2="def";//S2的修饰符和S1的相同

publicabstractvoidfunc1();

voidfunc2();//func2的修饰符和func1的相同

}接口的继承与实现与类相似，接口之间可以有继承关系，而与类的单继承不同的是，接口的继承允许多重继承。例如，若已经定义了两个接口A、B，可以定义C来继承A和B。如下：interfaceCextendsA,B{//多个父接口之间用逗号分隔

......

}一个具体的类采用implements关键字来实现它，例如：classDimplementsA,B{

......

}实现类也可以是抽象类，这时是部分实现了接口。抽象类类与接口是两个极端的情况，前者是所有方法都得到了实现，后者是所有方法都没有实现。在程序设计过程中，有时还需要一种中间状态，那就是只需要部分方法实现，其余的是抽象方法，这就是抽象类存在的必要性。当然抽象类中的方法可以全部都是抽象的，也可以全部都是实现的，这是两种极端的情况。定义一个抽象类的语法是：[访问修饰符]abstractclass抽象类名{

abstractvoidfunc();

......

}说明（1）抽象类必须采用修饰符abstract。（2）含有抽象方法的类必须声明为抽象类。（3）抽象类不能使用关键字new实例化，但抽象类可以有构造方法。（4）抽象类是一种特殊的类，遵循类的单继承规则和（单/多）接口实现规则。一个类可以在继承一个父类的同时，实现一个或多个接口，例如：classDextendsCimplementsA,B{

......

}其中A、B是两个接口，C是父类。引用类型的类型转换自动类型转换在具有继承关系的类与类之间，或者接口与接口之间，或者具有实现关系的接口和类之间，由下层类型向上层类型转换时，发生自动类型转换。自动类型转换也称为类型自动提升。1interfaceI{

2publicvoidfun();

3}

4

5classT1implementsI{

6publicvoidfun(){}

7}

8

9classT2extendsT1{}

10

11classTest{

12publicstaticvoidmain(String[]args){

13Ii=newT1();//合法，发生自动类型转换

14i=newT2();//合法

15T1t1=newT2();//合法

16}

17}强制类型转换在具有继承关系的类之间或者具有实现关系的接口和类之间，由上层类型向下层类型转换时，发生强制类型转换，注意其前提是对象的类型必须是转换目标类型本身或者是其子孙类型，即objinstanceofRefType表达式的值为true时，否则不能转换。例程1interfaceI{

2publicvoidfun();

3}

4classT1{

5publicvoidfun(){}

6}

7classT2extendsT1{}

8classT3extendsT2{}

9

10classKextendsT1{}

11

12classTest{

13publicstaticvoidmain(String[]args){

14T1t1=newT3();

15T2t2=(T2)t1;//合法，发生强制类型转换

16T3t3=(T3)t2;//合法

17t3=(T3)t1;//合法

18

19t1=newT1();

20t2=(T2)t1;//非法，因为t1指向的对象是T1类型的

21

22t1=newK();

23t2=(T2)t1;//非法，因为虽然T2,K都继承了T1，但t1

24//指向的对象是K类型的，不是T2类型的

25

26Ka=newK();

27Ib=(I)a;//合法28t1=(T1)b;//合法

29t2=(T2)b;//非法

30Kc=(K)b;//合法

31c=(K)t1;//合法

32}

33}自动打包/拆包机制从JDK1.5中引入了一个新的机制，基本类型的自动打包和其对应的引用类型的自动拆包机制。在JDK1.5之前，基本类型与其封装类之间的转换作如下处理（以int类型为例）：inti=123;

Integeric=newInteger(i);//把基本类型打包为一个对象

i=Value();//把一个对象拆包为基本类型而在JDK1.5及以后的版本中，可以如下使用：inti=123;

Integeric=i;//自动把i打包成对象

i=ic;//自动把ic拆包为基本类型这是一个很好的改进，方便了编程。其他修饰符finalstaticnativetransientstrictfpvolatileassertfinal修饰符final是最终、最后的意思，即不能再发生变化、终结了。因此，若final修饰变量（不管是局部变量还是成员变量），则变量一旦被赋值后就不能再改变其值了；若final修饰方法，则该方法就不能再被覆盖了，因为要动态（即在程序运行过程中）修改方法的功能的办法就是采用覆盖；若采用final修饰类，则该类就不能再被继承，当然final类的方法也就不能被覆盖了，这是因为动态修改类的定义的办法只能是在继承的基础上修改，而覆盖的前提是能够继承，现在继承都不允许了，当然其方法也就不能被覆盖了。staticstatic修饰符可以修饰：①成员属性；②成员方法；③代码块。static不能修饰方法内的局部变量（包括方法体内的局部变量和形式参数）。native一个native方法（也称作本地方法）就是一个Java程序调用非Java代码的接口。native方法的实现采用非Java语言实现，比如C、Fortran、汇编语言等。这个特征并非Java所特有，很多其他的编程语言都有