Java程序设计与应用开发课件_第1页
Java程序设计与应用开发课件_第2页
Java程序设计与应用开发课件_第3页
Java程序设计与应用开发课件_第4页
Java程序设计与应用开发课件_第5页
已阅读5页，还剩431页未读， 继续免费阅读

下载本文档

版权说明：本文档由用户提供并上传，收益归属内容提供方，若内容存在侵权，请进行举报或认领

文档简介

Java程序设计与应用开发第一章快速入门

1.1Java简介1.1.1发展简史1.1.2Java的特点1.2Java开发环境的构建

1.2.1Java开发包的安装1.2.2环境变量设定1.2.3基本DOS命令基本要求Java开发包＋纯文本编辑器

Java开发包：JDK写字板、UltraEdit等TextPad、JCreator、JBuiler、VisualAge、Eclipse等1.2.1Java开发包的安装Step1:从获取免费的Java开发包安装程序

Step2:双击Java开发包安装程序，出现安装界面

Java开发包的安装-1Step3:随后，安装程序会弹出许可证协议阅读画面

Java开发包的安装-2Step4:选择接受协议条款，然后点击“下一步”按钮，出现安装类型选择画面Java开发包的安装-3Step5:点击选中自定义，然后点击“下一步”按钮，出现下图所示的自定义安装内容选择画面Java开发包的安装-4Step6:点击“下一步”按钮进入正式安装。其他版本的开发包安装过程中除了显示画面略有不同，其他方面类似

1.2.2环境变量设定PATH－路径环境变量，用来指定Java开发包中的一些可执行程序(如java.exe、javac.exe等)所在的位置。

CLASSPATH－类路径环境变量，参见第四章。PATH设定之一(Win2K/NT/XP)（1）右击“我的电脑”，在弹出菜单中选择“属性”，出现系统属性对话框，

（2）选择“高级”属性页，在该属性页面中有一个“环境变量”按钮，点击该按钮进入环境变量编辑窗口

（3）在系统变量区域找到变量Path，双击该行就可以编辑该环境变量的值。在该变量已有的值后追加

“;c:\jdk1.4\bin”(注意：不包括引号，分号不能缺少，c:\jdk1.4是开发包的安装路径，如果安装到其他路径，需作相应修改)，点击“确定”按钮进行保存工作。至此，完成了Path环境变量的设定工作。所追加的值是用来指定Java开发包中的一些可执行程序(如编译、解释以及调试等可执行的工具程序)所在的位置的。

1.2.3基本DOS命令

如何进入DOS控制台窗口?这里以Window200为例，点击“开始”→“运行”，在弹出的对话框中输入“CMD”，点击“确定”，即可进入DOS控制台窗口。需要注意的，这种方式进入DOS控制台窗口后，当前目录为系统缺省目录，如果你想转换到其他盘符，例如D:，可以在提示符后输入“D:”，然后回车就转换到D:盘了。

DOS命令简介DIR[功能]显示目录中的文件以及子目录。CLS

[功能]清除屏幕DEL

[功能]删除一个或是多个文件。MD[功能]创建目录。COPY[功能]文件复制，将一份或多份文件复制到另一个位置。HELP[功能]帮助EXIT[功能]退出DOS窗口。1.3Java应用程序

（1）编写源代码

代码输入完毕后，将其保存成一个文件，取名为HelloWorld.java。并存放到一个指定的目录中去

(如F:\Chapter01\code)。

观察可以发现目录F:\Chapter01\code中有一个文件，名字为HelloWorld.java，这就是我们刚才保存的源代码文件

编写源代码注意事项由于Java编译器和解释器对于代码中的字符是大小写敏感的，所以您在按照本书内容输入代码、命令以及文件名时，注意大小写是否正确。该文件名必须是HelloWorld(和公开类的类名相同，并且大小写也要一样，这是由Java编译器和解释器是大小写敏感而决定的)，并且扩展名一定是.java。1.3.2编译源代码

在命令提示行输入以下命令并回车：

javacHelloWorld.java观察如果屏幕上没有出现错误提示，则表示已经正常完成了编译工作。再次使用DIR命令，可以发现目录下多了一个文件HelloWorld.class，即编译好的中间字节代码(bytecode)文件

1.3.3运行程序

在命令提示行输入：

javaHelloWorld1.3.4常见问题解答

Windows系统对于DOS命令中字符的大小写是不敏感的。例如：输入DIR、dir或是Dir得到的结果是相同的。Java编译器和解释器对于代码中的字符是大小写敏感的。所以在输入代码时要特别注意字符的大小写，例如HelloWorld和helloWorld是不同的，同样public和Public也是不同的。

常见问题－续1保存源代码为文件时，要注意文件的命名。文件名一定要和源代码中公开类的类名一致(包括大小写)，并且文件扩展名必须为.java。注意，如果将例1.3.1中的publicclassHelloWorld改为classHelloWorld(即HelloWorld不再是公开类)，则可以将其保存为任何一个合法的、并以.java为扩展名的文件，例如NotHelloWorld.java。

常见问题－续2如果在进行编译时报类似如下错误(如果读者使用的是英文版的操作系统，错误信息将是英文)：

'javac'不是内部或外部命令，也不是可运行的程序或批处理文件。

则表示系统不能正确定位编译器javac.exe，原因是未能正确设定PATH环境变量。请参考1.2.2小节关于环境变量的设置。

常见问题－续3编译时，需要用文件的全名，例如javacHelloWorld.java；解释运行时只需要用类名，而不需要带上.class，例如javaHelloWorld。如果输入：

javaHelloWorld.class

那么系统报如下错误：

Exceptioninthread"main"java.lang.NoClassDefFoundError:HelloWorld/class

1.3.5理解例子

Java代码中具有三种类型的注释：

(1)单行注释

//comments

从//至该行结束的内容是注释部分，编译器予以忽略。

(2)多行注释

/*comments*/

在/*和*/之间的所有内容均为注释部分，位于/*和*/之间的内容可以是一行或是多行。(3)文档注释

/**commentsline1*commentsline2*...*commentslinen*/类定义&main方法publicclassHelloWorld{...}

publicstaticvoidmain(String[]args){...}命令行参数&输出语句publicstaticvoidmain(String[]args)System.out.println(Strings)1.4JavaAppletApplet称为小应用程序，和应用程序不同的是，Applet一般是在支持Java的Web浏览器中运行。使用特定的HTML标签(tag)将Applet嵌入在HTML页面中，并且Applet程序和页面均存放在服务器上，当远程用户通过浏览器来访问页面时，页面中所嵌入的Applet程序通过网络被下载到浏览器中并加以运行

1.4.1编写Applet源代码importjavax.swing.JApplet;//引入JApplet类importjavax.swing.JLabel;//引入标签类JLabelpublicclassHelloWorldAppletextendsJApplet{publicvoidinit(){System.out.println("initApplet");}publicvoidstart(){System.out.println("startApplet"); getContentPane().add(newJLabel("HelloWorldApplet"));}publicvoidstop(){System.out.println("stopApplet"); }publicvoiddestroy(){System.out.println("destoryApplet"); }}四个方法init()

－打开嵌有Applet的HTML页面时，该方法被调用以进行必要的初始化工作。start()

－该方法在init方法结束后被调用，用以启动Applet。stop()

－关闭嵌有Applet的HTML页面时，该方法自动调用，以关闭Applet。destroy()

－

stop方法执行完毕后，该方法被调用，用以释放Applet所使用的资源。

1.4.2编写嵌入Applet的HTML文件

例1.4.2HelloWorldApplet.html<html><title>ASimpleAppletExample</title><body>Thisisasimpleapplet.<p><appletcode="HelloWorldApplet.class“width="150"height="150"></applet></body></html>1.4.3运行Applet运行应用程序使用的是java解释器。而运行小应用程序则使用Applet查看器或是WEB浏览器。使用appletviewer

在DOS命令行输入如下命令并回车：

appletviewerHelloWorldApplet.html2.1基本数据类型

2.1.1标识符和保留字1、标识符

程序员对程序中的各个元素加以命名时使用的命名记号称为标识符(identifier)。

标识符可由顺序任意的大小写字母，数字，下划线（_）,美元符($)组成。但标识符不能以数字开头，不能是Java中的保留关键字。

例：userName，User_Name，_sys_val，$num为合法的标识符；

2mailroom#，classhello-world为非法的标识符

2、保留字具有专门的意义和用途，不能当作一般的标识符使用，这些标识符称为保留字(reservedword),也称为关键字。Java语言中的保留字均用小写字母表示。

2.1.2数据类型概述1．Java中的数据类型划分简单数据类型包括：整数类型：byte，short，int，long浮点类型：float，double字符类型：char布尔类型：boolean复合数据类型包括：classinterface数组2、常量和变量常量：用保留字final来实现如：finalintIP=3;变量：intcount;charc=’a';2.1.3简单数据类型1．布尔类型—boolean

布尔型数据只有两个值true和false.

例如：booleanb=true;2．字符类型--char字符常量：字符常量是用单引号括起来的一个字符，如'a'，'A';字符型变量：类型为char，它在机器中占16位，其范围为0～65535。字符型变量的定义如：charc='a';/*指定变量c为char型，且赋初值为'a'*/3、整型数据整型常量：

十进制整数。如123，－456，0八进制整数。以0开头，如0123表示十进制数83，－011表示十进制数－9。十六进制整数。以0x或0X开头，如0x123表示十进制数291，－0X12表示十进制数－18。整型变量：数据类型所占位数数的范围byte8-27～27-1short16-215～215-1

int32-231～231-1

long64-263～263-14．浮点型（实型）数据实型常量：十进制数形式。由数字和小数点组成，且必须有小数点。如0.123,1.23,123.0

科学计数法形式。如：123e3或123E3，其中e或E之前必须有数字，且e或E后面的指数必须为整数。

float型的值,必须在数字后加f或F。如1.23f。

实型变量：

5．简单数据类型的例子：

publicclassAssign{publicstaticvoidmain(Stringargs[]){

数据类型所占位数数的范围floatdouble32643.4e-038～3.4e+038

1.7e-038～1.7e+038

intx,y;//定义x，y两个整型变量floatz=1.234f;//指定变量z为float型，且赋初值为1.234doublew=1.234;//指定变量w为double型，且赋初值为1.234booleanflag=true;//指定变量flag为boolean型，且赋初值为truecharc;//定义字符型变量c

Stringstr;//定义字符串变量strStringstr1="Hi";//指定变量str1为String型，且赋初值为Hic='A';//给字符型变量c赋值'A'str="bye";//给字符串变量str赋值"bye"x=12;//给整型变量x赋值为12y=300;//给整型变量y赋值为300

}

}2.1.4简单数据类型中各类型数据间的优先关系和相互转换1、不同类型数据间的优先关系如下：低--------------------------------------------->高

byte,short,char->int->long->float->double2、自动类型转换规则整型,实型,字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算，转换从低级到高级；3、强制类型转换高级数据要转换成低级数据，需用到强制类型转换，如：

inti;byteb=(byte)i;/*把int型变量i强制转换为byte型*/2.2运算符和表达式

2.2.1运算符参与运算的数据称为操作数，按操作数的数目来分，可有：一元运算符：＋＋，－－，＋，－二元运算符：＋，－，>三元运算符：？：基本的运算符按功能划分，有下面几类：1、算术运算符：+，―，*，/，%，++，――。例：3+2;a-b;i++;--i;2、关系运算符：>，<，>=，<=，==，!=。例：count>3;I==0;n!=-1;3、布尔逻辑运算符：!，&&，||。例：flag=true;!(flag);flag&&false;

4、位运算符：>>，<<，>>>，&，|，^，~。例：a=10011101;b=00111001；则有如下结果：

a<<3=11101000;a>>3=11110011a>>>3=00010011;a&b=00011001;a|b=10111101;

~a=01100010;a^b=10100100;5、赋值运算符=，及其扩展赋值运算符如+=，―=，*=，/=等。例：i=3;i+=3;//等效于i=i+3;6、条件运算符?：例：result=(sum==0?1:num/sum);7、其它：包括分量运算符·，下标运算符[]，实例运算符instanceof，内存分配运算符new，强制类型转换运算符(类型)，方法调用运算符()等。例：

System.out.println("helloworld");intarray1[]=newint[4];2.2.2表达式表达式是由操作数和运算符按一定的语法形式组成的符号序列

1、表达式的类型表达式的类型由运算以及参与运算的操作数的类型决定，可以是简单类型，也可以是复合类型：布尔型表达式：x&&y||z;整型表达式：num1+num2;

2、运算符的优先次序表达式的运算按照运算符的优先顺序从高到低进行,同级运算符从左到右进行。

2.3字符串

2.3.1字符串的表示字符串常量字符串常量是用双引号括住的一串字符。如："HelloWorld!"

String类的构造方法

String(charchars[]);

String(charchars[],intstartIndex,intnumChars);String(byteascii[],inthiByte);String(byteascii[],inthiByte,intstartIndex,intnumChars);String使用示例：Strings=newString();//生成一个空串

用StringBuffer表示字符串

StringBuffer();/*分配16个字符的缓冲区*/StringBuffer(intlen);/*分配len个字符的缓冲区*/StringBuffer(Strings);/*除了按照s的大小分配空间外,再分配16个字符的缓冲区*/2.3.2访问字符串1、类String中提供了length()、charAt()、indexOf()、lastIndexOf()、getChars()、getBytes()、toCharArray()等方法。2、类StringBuffer提供了length()、charAt()、getChars()、capacity()等方法。2.3.3修改字符串1、String类提供的方法：2、StringBuffer类提供的方法：StringBuffer中对字符串的连接操作是对源串本身进行的，操作之后源串的值发生了变化，变成连接后的串。2.3.4其他操作1、字符串的比较String中提供的方法：equals()和equalsIgnoreCase()

2、字符串的转化

java.lang.Object中提供了方法toString()把对象转化为字符串。3、字符串"+"操作运算符'+'可用来实现字符串的连接：

Strings="Heis"+age+"yearsold";

其他类型的数据与字符串进行"+"运算时，将自动转换成字符串。具体过程如下：

Strings=newStringBuffer("heis").append(age).append("yearsold").toString();2.4控制语句

2.4.1分支语句分支语句提供了一种控制机制，使得程序的执行可以跳过某些语句不执行，而转去执行特定的语句。1、条件语句if-elseif(boolean-expression)statement1;[elsestatement2;]

2、多分支语句switchswitch(expression){casevalue1:statement1;break;

casevalue2:statement2;break;

…………

casevalueN:statemendN;break;

[default:defaultStatement;]

}2.4.2循环语1、while语句

[initialization]

while(termination){

body;

[iteration;]

}2、do-while语句

[initialization]

do{

body;

[iteration;]

}while(termination);3．for语句

for(initialization;termination;iteration){

body;

}2.4.3跳转语句

1、break语句

在switch语中，break语句用来终止switch语句的执行。使程序从switch语句后的第一个语句开始执行。在Java中，可以为每个代码块加一个括号，一个代码块通常是用大括号{}括起来的一段代码。2、continue语句

continue语句用来结束本次循环，跳过循环体中下面尚未执行的语句，接着进行终止条件的判断，以决定是否继续循环。如：continue；

可以用continue跳转到括号指明的外层循环中。如：continueouterLable;3、返回语句returnreturn语句从当前方法中退出，返回到调用该方法的语句处。return语句通常用在一个方法体的最后,否则会产生编译错误,除非用在if-else语句中

2.5数组

2.5.1一维数组的定义1.一维数组的定义

typearrayName[]；类型(type)可以为Java中任意的数据型，包括简单类型和复合类型。例：intintArray[]；DatedateArray[];2、一维数组的初始化静态初始化

intintArray[]={1,2,3,4};

StringstringArray[]={"abc","How","you"};动态初始化

1）简单类型的数组

intintArray[];intArray=newint[5];

2）复合类型的数组

StringstringArray[];StringstringArray=newString[3];/*为数组中每个元素开辟引用空间(32位)*/stringArray[0]=newString("How");//为第一个数组元素开辟空间

stringArray[1]=newString("are");//为第二个数组元素开辟空间

stringArray[2]=newString("you");//为第三个数组元素开辟空间3、一维数组元素的引用

数组元素的引用方式为：

arrayName[index]

index为数组下标，它可以为整型常数或表达式，下标从0开始。每个数组都有一个属性length指明它的长度，例如：intArray.length指明数组intArray的长度。2.5.2多维数组1、二维数组的定义

typearrayName[][]；type[][]arrayName;2、二维数组的初始化静态初始化

intintArray[][]={{1,2},{2,3},{3,4,5}};

动态初始化

inta[][]=newint[2][3]；例：inta[][]=newint[2][]；

a[0]=newint[3];

a[1]=newint[5];

对二维复合数据类型的数组，必须首先为最高维分配引用空间，然后再顺次为低维分配空间。而且，必须为每个数组元素单独分配空间。3、二维数组元素的引用对二维数组中的每个元素，引用方式为：arrayName[index1][index2]

例如：num[1][0];4、二维数组举例：

小结

这一章零碎的知识点很多，要求要记忆的东西也很多，需要大家整理自己的知识体系。如果你在此之前学过其他的计算机语言，那你就会感到很轻松，其实对于学习者，与其他的计算机语言相比，java基本语法学起来并没有什么不同。只是有些规则不要混淆就可以了。课后任务习题：课后习题2.12.22.32.5实验题目：1、编写Java程序，实现字符串的翻转。2、分别用whiledo……whilefor循环求解

1）、50!2）、1!+2!+3!+......+10!3.1类和对象3.1.1类声明

class类名[extends父类名][implements接口列表]{类体}3.1.2类体类中含有两种成员：成员变量，成员方法。成员变量成员变量的声明方式如下：

[public|protected|private][static]

[final]type变量名;//成员变量其中，

static:静态变量(类变量)；相对于实例变量final:常量

成员方法

方法的实现包括两部分内容：方法声明和方法体。

方法声明中的限定词的含义：static:类方法，可通过类名直接调用abstract:抽象方法，没有方法体final:方法不能被重写方法声明方法声明包括方法名、返回类型和外部参数。其中参数的类型可以是简单数据类型，也可以是复合数据类型。方法体方法体是对方法的实现，它包括局部变量的声明以及所有合法的Java指令。3.1.3关键字this

在一个方法内，如果局部变量和成员变量的名字相同，则局部变量被隐藏，若要访问成员变量，要在变量名前加上”this.,”,this表示当前对象的引用。3.1.4方法重载方法重载是指多个方法享有相同的名字，但是这些方法的参数必须不同，或者是参数的个数不同，或者是参数类型不同。返回类型不能用来区分重载的方法。3.1.5类的继承通过继承实现代码复用。Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。继承而得到的类称为子类，被继承的类称为父类。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量。但Java不支持多重继承，即一个类从多个超类派生的能力。类继承的传递性。3.1.6类的初始化过程

当创建一个对象时，对象的各个变量根据其类型被设置为相应的默认初始值，然后调用构造方法，而每次调用构造方法都是要执行三个阶段：

1、调用超类的构造方法；

2、由初始化语句对给变量进行初始化；

3、执行构造方法的体。3.1.7源文件若源文件中不包括public类或者接口，文件名字可以是任意合法的文件名。

Javac*.java;Javac主方法所在的类3.2面向对象特性3.2.1封装java中类的限定词的作用范围比较同一个类同一个包不同包的子类

不同包非子类private*default

**protected***public****3.2.2继承创建子类格式：

classSubClassextendsSuperClass{

…

}3.2.3多态在java语言中，多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。

编译时多态在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。运行时多态由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法3.3关键字static的使用

如果在声明时不用static关键字修饰，则声明为实例变量和实例方法。实例变量和类变量每个对象的实例变量都分配内存，通过该对象来访问这些实例变量，不同的实例变量是不同的。类变量仅在生成第一个对象时分配内存，所有实例对象共享同一个类变量，每个实例对象对类变量的改变都会影响到其它的实例对象。类变量可通过类名直接访问，也可以通过实例对象访问类变量。实例方法和类方法类方法可以由类名直接调用，也可由实例对象进行调用。类方法中不能使用this或super关键字。

实例方法类方法实例变量实例方法类变量类方法可以可以可以可以可以可以不可以不可以实例方法和类方法访问权限示意图3.4关键字final的使用

3.4.1final变量

final变量,则为常量，例如修饰成员变量时，定义时同时给出初始值，而修饰局部变量时不做要求。3.4.2final方法

final修饰的方法不能被子类重写。

finalreturnTypemethodName(paramList){

…

}3.4.3final类

final修饰类，则类不能被继承

finalclass类名{

…

}4.1接口（interface）接口

接口是抽象类的一种，只包含常量和方法的定义，而没有变量和方法的实现，且其方法都是抽象方法。它的用处体现在下面几个方面：

通过接口实现不相关类的相同行为,而无需考虑这些类之间的关系。

通过接口指明多个类需要实现的方法。

通过接口了解对象的交互界面,而无需了解对象所对应的类。1）接口的定义

接口的定义包括接口声明和接口体。

接口声明的格式如下：

[public]interfaceinterfaceName[extendslistOfSuperInterface]{…}

extends子句与类声明的extends子句基本相同，不同的是一个接口可有多个父接口，用逗号隔开，而一个类只能有一个父类。

接口体包括常量定义和方法定义

常量定义格式为：typeNAME=value;该常量被实现该接口的多个类共享;具有public,final,static的属性。在接口中只能声明常量，不可以声明变量。

方法体定义格式为：(具有public和abstract属性，不能声明为protected)

returnTypemethodName([paramlist])；

注意：在接口的实现类中，实现的接口方法必须声明为public，因为接口中定义的方法为public（默认）。所以其实现必须声明为public.否则编译不会通过。补充由于接口中不能有初始化块和构建器，所以在定义有名常量时必须包含初始化表达式接口中的方法不能被声明为static，因为类方法不是抽象的。2）接口的实现

在类的声明中用implements子句来表示一个类使用某个接口，在类体中可以使用接口中定义的常量，而且必须实现接口中定义的所有方法。一个类可以实现多个接口,在implements子句中用逗号分开。3）接口类型的使用

接口作为一种引用类型来使用。任何实现该接口的类的实例都可以存储在该接口类型的变量中，通过这些变量可以访问类所实现的接口中的方法。例1、接口定义publicinterfaceA{}也可以用extends去继承已有的接口publicinterfaceAextendsB//B是已定义了的接口

{}在类中使用接口需要使用关键字implements：

publicclassAimplementsB //这里A为类，B为接口{}

√Java类只允许单一继承，即一个类只能继承(extends)一个父类；但一个类可以实现多个接口，Java支持接口的多重继承。在Java类定义中，可以同时包括extends子句和implements子句，如果存在extends子句，则implements子句应跟随extends子句后面。

例2接口实现interfaceA{intx=1;voidmethod1();}interfaceBextendsA{intx=2;voidmethod2();}publicclassExampleimplementsB{publicvoidmethod1(){ System.out.println("x="+x); System.out.println("A.x="+A.x); System.out.println("B.x="+B.x); System.out.println("Example.x="+Example.x);}publicvoidmethod2(){}publicstaticvoidmain(String[]args){ Exampled=newExample(); d.method1();}}例3接口作为类型classWorkerimplementsRunnable{publicvoidrun(){ System.out.print("Workerrun!");}}publicclassServer{ publicstaticvoidmain(String[]args){ Runnablew=newWorker(); (newThread(w)).start(); }}接口不应改变修改某个接口，为其添加一个方法，这个简单的修改可能会造成牵一发而动全身的局面：所有实现这个接口的类都将无法工作，因为现在他们已经不再实现这个接口了。你要么放弃对这个接口的修改，要么连同修改所有实现这个接口的所有类。在设计接口的最初，预测出接口的所有功能，这可能是不太现实。如果觉得接口非改不行，可以创建一个新的接口或者扩展这个接口，算是一种折衷的解决方法。其他相关的类可以保持不变，或者重新实现这个新的接口。4.2抽象类什么是抽象

抽象就是抽出事物的本质特性而暂时不考虑它们的细节。过程抽象和数据抽象是常用的两种主要抽象手段。如何用面向对象的方法实现抽象

一个抽象数据类型（AbstractDataType，ADT）可以分解成4个部分，如图4-2所示。语法和语义构成抽象数据类型ADT的说明，让使用者了解这个抽象数据类型的特征。属性和方法构成ADT的实现，展示这个ADT是怎样做成的。当一个类被声明为abstract时，这个类被称为是抽象类。所谓抽象类就是没有具体实例对象的类。针对这个问题，Java专门提供了一种机制，名为“抽象方法”。它属于一种不完整的方法，只含有一个声明，没有方法主体。下面是抽象方法声明时采用的语法：abstractvoidX();人类就是一个典型的抽象类。我们知道，类是对象的集合，对象是类的实例化，而人类这个类却不存在一个仅属于它的具体对象。

抽象方法作为类方法修饰符，abstract则声明了一种仅有方法头，而没有具体的方法体和操作实现的抽象方法。

可见，abstract方法只有方法头的声明，而用一个分号来代替方法体的定义：至于方法体的具体实现，那是由当前类的不同子类在它们各自的类定义中完成的。需要特别注意的是，所有的抽象方法，都必须存在于抽象类之中。除了抽象方法，抽象类也可以有具体的数据和方法。例如，Person类存储人的名字并且用一个具体的方法来返回它。在Java编程语言中抽象方法是非常重要的概念。在接口里你会大量的用到它。抽象方法只能出现在抽象类中例abstractclassGraphic{publicstaticfinaldoublePI=3.1415926;doublearea(){return0;};abstractvoiddraw();}classPointextendsGraphic{protecteddoublex,y;publicPoint(doublex,doubley){this.x=x;this.y=y;}voiddraw(){ //在此实现画一个点

System.out.println("Drawapointat("+x+","+y+")");}publicStringtoString(){ return"("+x+","+y+")";}}classLineextendsGraphic{protectedPointp1,p2;publicLine(Pointp1,Pointp2){ this.p1=p1; this.p2=p2;}voiddraw(){ //在此实现画一条线

System.out.println("Drawalinefrom"+p1+"to"+p2);}}classCircleextendsGraphic{protectedPointo;protecteddoubler;publicCircle(Pointo,doubler){ this.o=o; this.r=r;}doublearea(){ returnPI*r*r;}voiddraw(){ //在此实现画一个圆

System.out.println("Drawacircleat"+o+"andr="+r);}}publicclassGraphicDemo{publicstaticvoidmain(String[]args){ Graphic[]g=newGraphic[3];g[0]=newPoint(10,10);g[1]=newLine(newPoint(10,10),newPoint(20,30));g[2]=newCircle(newPoint(10,10),4);for(inti=0;i<g.length;i++){ g[i].draw(); System.out.println("Area="+g[i].area());}}}抽象类和接口的比较抽象类在Java语言中体现了一种继承关系，要想使得继承关系合理，抽象类和继承类之间必须存在"是一个(isa)"关系，即抽象类和继承类在本质上应该是相同的。而对于接口来说，并不要求接口和接口实现者在本质上是一致的，接口实现者只是实现了接口定义的行为而已。Java中一个类只能继承一个父类，对抽象类来说也不能例外。但是，一个类却可以实现多个接口。在Java中按照继承关系，所有的类形成了一个树型的层次结构，抽象类位于这个层次中的某个位置。而接口却不曾在这种树型的层次结构，位于树型结构中任何位置的任何类都可以实现一个或者多个不相干的接口。在抽象类的定义中，我们可以定义方法，并赋予的默认行为。而在接口的定义中，只能声明方法，不能为这些方法提供默认行为。抽象类的维护要比接口容易一些，在抽象类中，增加一个方法并赋予的默认行为，并不一定要修改抽象类的继承类。而接口一旦修改，所有实现该接口的类都被破坏，需要重新修改。7.3包包在JAVA中的作用：文件夹将文件和应用程序组织为组，包将类组织为组包减少了命名冲突带来的问题，如果所有类放在同一个包中就容易产生命名冲突引入包以后，声明类前必须声明类所在的包，格式：

package包1名.包2名…包n名;

例如:packagejava.awt;或:packagejavax.swing.event;

如果一个类访问另一个包中的类,必须通过包来引用,有两种引用方法

1)声明该类前，使用import语句例如：importjava.awt.Button;//Button为被访问的类，位于包java.awt中

importjava.awt.*;//引入包java.awt中的全部类

2）访问另一个包中的类时，使用包名例如：java.awt.Buttonb=newjava.awt.Button();Example（自定义包使用）//exampleone//类在同一个包中

publicclassDate2{intyear,month,day;voidsetDate(inty,intm,intd){year=y;month=m;day=d;}voidprint(){System.out.println(year+""+month+""+day);}}classUseDate2{publicstaticvoidmain(Stringargs[]){Date2b=newDate2();b.setDate(2004,9,1);b.print();}}//类在不同包中//Date2.javapackagep1.p2;publicclassDate2{intyear,month,day;publicvoidsetDate(inty,intm,intd){year=y;month=m;day=d;}publicvoidprint(){System.out.println(year+""+month+""+day);}}//UseDate2.javaimportp1.p2.Date2;classUseDate2{publicstaticvoidmain(Stringargs[]){Date2b=newDate2();b.setDate(2004,9,1);b.print();}}Example在DOS窗口下的运行DOS窗口下必须手动建立包一编译Date2.java1）建立保存p1.p2.Date2的文件夹,例如E:\db0312）设置环境变量：右击我的电脑选属性、高级、环境变量，双击系统变量中的CLASSPATH，在变量值中加入保存p1.p2.Date2的文件夹，例如;E:\db031（不要忘了环境变量以；隔开）3）E:\db031下建立p1和p2文件夹,将Date2.java保存E:\db031\p1\p2下4）打开DOS窗口,进入Date2所在目录,即E:\db031\p1\p2。打开DOS窗口的方法:显示器左下角,点击开始、程序、附件、命令提示符；进入E:\db031\p1\p2的方法：切换C：\>E:即输入E：然后回车（如文件保存在C盘，不须切换）；进入E\>cd\db031\p1\p25）编译，E:\db031\p1\p2>javacDate2.java并回车二编译并运行UseDate2.java1）建立保存UseDate2的文件夹，例如：C:\db0322）保存UseDate2.java，编译javacUseDate2.java3）3）运行C:\db032下javaq.UseDate2.javaExample

在Jcreator下的运行Jcreator下，系统按源文件中的package语句自动建立包1）建立保存p1.p2.Date2的空project,例如E:\db031,保存Date2.java并编译,可看到p1和p2已经自动生成2）编译UseDate2.java3）建立保存UseDate2.java的空project,保存UseDate2.java,此时编译会报错4）设置环境变量在Jcreator主菜单的project下选择projectsettings…

选择requiredlibraries后按new…

选择classes后按add选addpath,找到p1.p2.Date2所在文件夹(E:\db031)

在Name中给该路径命名,按OK

此时可看到该路径名出现在文本框中,选中该路径名,可看到该路径已加入到ClassPath中5）编译UseDate2.java并运行环境变量classpath的配置Classpath的作用当一个类访问位于其它包中的其它类时,Classpath帮助该类找到其它类,Classpath的值：Classpath就是包含被访问的类所在的包的文件夹被访问的类所在的包由被访问的类的package语句声明,并且必须建立同名的文件夹这样,被访问的类的路径包括两部分:Classpath的值和包两个必须的Classpath值

.(实心句号)表示当前文件夹

(J2sdk)的安装目录\lib表示JAVA类库所在文件夹J2sdk和Jcreator的安装J2sdk和JcreatorLE都是自由软件,可免费下载

J2sdk的网址:/j2se/1.4.2/download.html

还可下载Documation及其它资料

JcreatorLE的网址:/download.html

卸载J2sdk和JcreatorLE，方法：我的电脑、添加删除程序选中JcreatorLE并删除，选中Java2runtimeenvironment和J2sdk删除从19下载Jcreator和J2sdk安装软件安装J2sdk，安装时可以设置安装路径，如设为：C:\j2sdk根据安装路径设置环境变量path：右击我的电脑选属性、高级、环境变量，双击系统变量中的path，增加;（J2sdk安装路径）\bin例如;C:\j2sdk\bin

path设置后,打开DOS窗口,键入java命令并回车,可检验设置是否正确设置环境变量classpath：右击我的电脑选属性、高级、环境变量，双击系统变量中的classpath

增加.;（J2sdk安装路径）\lib例如:.;C:\j2sdk\lib

安装JcreatorLEJ2sdk安装时环境变量的设置设置path设置classpath习题1.填空题(1)我们可以通过____________，使得处于不同层次，甚至互不相关的类具有相同的行为，然后由每个类分别去实现这些行为。(2)接口声明的关键字是______________。(3)在声明类的同时，我们可通过关键字__________________实现接口。(4)使用类实现接口时，必须__________该接口的所有方法。(5)Java中，我们可通过________来管理类名空间。(6)创建包的关键字是：____________。(7)引入包grade的best类，可使用语句：____________________________。

2、操作题

1、通过设计一接口，定义有关算术的属性。并创建四个应用该接口的类，分别进行加减乘除的运算。5.1异常的概念例外就是在程序的运行过程中所发生的异常事件，它中断指令的正常执行。Java中提供了一种独特的处理例外的机制，通过例外来处理程序设计中出现的错误。见demo\mod02\NoException.java见demo\mod02\ExceptionDemo1.javademo\mod02\ExceptionDemo2.java异常的处理机制

捕获例外：

当Java运行时系统得到一个例外对象时，它将会沿着方法的调用栈逐层回溯，寻找处理这一例外的代码。找到能够处理这种类型的例外的方法后，运行时系统把当前例外对象交给这个方法进行处理，这一过程称为捕获(catch)例外。这是积极的例外处理机制。如果Java运行时系统找不到可以捕获例外的方法，则运行时系统将终止，相应的Java程序也将退出。

声明抛弃例外：

如果一个方法并不知道如何处理所出现的例外，则可在方法声明时，声明抛弃（throws）例外。这是一种消极的例外处理机制。异常类层次在jdk中，每个包中都定义了例外类，而所有的例外类都直接或间接地继承于Throwable类。下图为jdk中例外类的继承关系。

异常的两大类Error

动态链接失败，虚拟机错误等，通常Java程序不应该捕获这类例外，也不会抛弃这种例外。

Exception

1）运行时例外：

继承于RuntimeException的类都属于运行时例外，例如算术例外（除零错）、数组下标越界例外等等。由于这些例外产生的位置是未知的，Java编译器允许程序员在程序中不对它们做出处理。

2）非运行时例外：

除了运行时例外之外的其他由Exception继承来的例外类都是非运行时的例外，例如FileNotFoundException（文件未找到例外）。Java编译器要求在程序中必须处理这种例外，捕获例外或者声明抛弃例外。throw:用户自己产生异常异常的处理java语言中有两种例外处理机制：捕获例外和声明抛弃例外捕获异常捕获例外是通过try-catch-finally语句实现的。try{

..//常规的代码....

}catch(ExceptionName1e){

//处理异常......

}catch(ExceptionName2e){

......

}

......

}finally{

//不论发生什么异常(或者不发生任何异常),都要执行的部分

}

try捕获例外的第一步是用try{…}选定捕获例外的范围，由try所限定的代码块中的语句在执行过程中可能会生成例外对象并抛弃。在try{…}这一部分,存放常规的代码,期望或可能出错的代码段catch每个try代码块可以伴随一个或多个catch语句，用于处理try代码块中所生成的例外事件。catch语句只需要一个形式参数指明它所能够捕获的例外类型,这个类必须是Throwable的子类,运行时系统通过参数值把被抛弃的例外对象传递给catch块。

在catch块中是对例外对象进行处理的代码，与访问其它对象一样，可以访问一个例外对象的变量或调用它的方法。getMessage()是类Throwable所提供的方法，用来得到有关异常事件的信息，类Throwable还提供了方法printStackTrace()用来跟踪异常事件发生时执行堆栈的内容catchtry{

......}catch(FileNotFoundExceptione){

System.out.println(e);

System.out.println("message:"+e.getMessage());

e.printStackTrace(System.out)；}catch(IOExceptione){

System.out.println(e);}

catch语句的顺序：

捕获例外的顺序和catch语句的顺序有关，当捕获到一个例外时，剩下的catch语句就不再进行匹配。因此，在安排catch语句的顺序时，首先应该捕获最特殊的例外，然后再逐渐一般化。也就是一般先安排子类，再安排父类。

finally捕获例外的最后一步是通过finally语句为例外处理提供一个统一的出口，使得在控制流转到程序的其它部分以前，能够对程序的状态作统一的管理。不论在try代码块中是否发生了异常事件，finally块中的语句都会被执行。

finallyfinally在文件处理时非常有用try{

对文件进行处理的程序;}catch(IOExceptione){//对文件异常进行处理;}finally{

不论是否发生异常,都关闭文件;}捕获异常编写Java程序,包含三种异常算术异常,字符串越界,数组越界观察输出信息:每个异常对象可以直接给出信息声明抛出异常

1．声明抛出异常如果在一个方法中生成了一个例外，但是这一方法并不确切地知道该如何对这一异常事件进行处理，这时，一个方法就应该声明抛弃例外，使得例外对象可以从调用栈向后传播，直到有合适的方法捕获它为止。

声明抛弃例外是在一个方法声明中的throws子句中指明的。例如：

publicintread()throwsIOException{

......}

throws子句中同时可以指明多个例外，之间由逗号隔开。例如：

publicstaticvoidmain(Stringargs[])throws

IOException,IndexOutOfBoundsException{…}

Mod02\Exception1.java观察运行结果声明抛出异常

2．抛出例外

抛出例外就是产生例外对象的过程，首先要生成例外对象，例外或者由虚拟机生成，或者由某些类的实例生成，也可以在程序中生成。在方法中，抛出例外对象是通过throw语句实现的。

例如：

IOExceptione=newIOException();

throwe;

可以抛出的例外必须是Throwable或其子类的实例。下面的语句在编译时将会产生语法错误：

thrownewString("wanttothrow");抛出异常.抛弃异常:不是出错产生,而是人为地抛出throwThrowableObject;thrownewArithmeticException();例:编写程序人为抛出(JavaThrow.prj)ArithmeticException,ArrayIndexOutOfBoundsExceptionStringIndexOutOfBoundsExceptionMod02\JavaThrow.javaAmethodExceptionAnothermethodthrowcaught注意

自定义例外类必须是Throwable的直接或间接子类。

注意：一个方法所声明抛弃的例外是作为这个方法与外界交互的一部分而存在的。所以，方法的调用者必须了解这些例外，并确定如何正确的处理他们。创建自己的异常不是由Java系统监测到的异常(下标越界,被0-除等),而是由用户自己定义的异常.用户定义的异常同样要用try--catch捕获,但必须由用户自己抛出thrownewMyException.异常是一个类,用户定义的异常必须继承自Throwable或Exception类,建议用Exception类.创造自己的异常形如:classMyExceptionextendsException{….};例1:计算两个数之和,当任意一个数超出范围时,抛出自己的异常publicclassNumberRangeExceptionextendsException{publicNumberRangeException(Stringmsg){super(msg);}}

创建自己的异常

publicbooleanaction(Eventevt,Objectarg){try{intanswer=CalcAnswer();answerStr=String.valueOf(answer);}catch(NumberRangeExceptione){answerStr=e.getMessage();}repaint();returntrue;}

4.6创造自己的异常.publicintCalcAnswer()throwsNumberRangeException{intint1,int2;intanswer=-1;Stringstr1=textField1.getText();Stringstr2=textField2.getText();try{int1=Integer.parseInt(str1);int2=Integer.parseInt(str2);if((int1<10)||(int1>20)||(int2<10)||(int2>20)){NumberRangeExceptione=newNumberRangeException(”Numbersnotwithinthespecifiedrange.");throwe

人人文库> 全部分类> 教育资料 > 课件下载

温馨提示

  • 1. 本站所有资源如无特殊说明，都需要本地电脑安装OFFICE2007和PDF阅读器。图纸软件为CAD,CAXA,PROE,UG,SolidWorks等.压缩文件请下载最新的WinRAR软件解压。
  • 2. 本站的文档不包含任何第三方提供的附件图纸等，如果需要附件，请联系上传者。文件的所有权益归上传用户所有。
  • 3. 本站RAR压缩包中若带图纸，网页内容里面会有图纸预览，若没有图纸预览就没有图纸。
  • 4. 未经权益所有人同意不得将文件中的内容挪作商业或盈利用途。
  • 5. 人人文库网仅提供信息存储空间，仅对用户上传内容的表现方式做保护处理，对用户上传分享的文档内容本身不做任何修改或编辑，并不能对任何下载内容负责。
  • 6. 下载文件中如有侵权或不适当内容，请与我们联系，我们立即纠正。
  • 7. 本站不保证下载资源的准确性、安全性和完整性, 同时也不承担用户因使用这些下载资源对自己和他人造成任何形式的伤害或损失。

最新文档

评论

0/150

提交评论