Java编程基础-.pdf

《Java编程基础-.pdf》由会员分享，可在线阅读，更多相关《Java编程基础-.pdf（21页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、Java程序设计基础第一节变量和数据类型所有 Java 变量都具有一个数据类型。变量的类型决定了变量的值以及参与的操作。变量定义的一般形式为：type variable_list;其中的 type 是某种有效的Java 类型，variable_list 是变量列表，它由一个或多个变量名组成。当有多个变量时，各变量之间用逗号隔开，变量名必须是合法的Java标识符。Java语言提供了两种变量类型：基本类型和复合类型。基本类型是那些简单的不能被分解的类型，有时也被称为简单类型。Java 基本类型包括数值型、布尔型和字符型三种。参见表 1。表 1 Java的基本变量类型基本变量类型长 度说 明Byte

2、 8bit 字节长度整数Short 16bit 短整数Int 32bit 一般整数Long 64bit 长整数Float 32bit 单精度浮点数Double 64bit 双精度浮点数Char 16bit 单字符Boolean N/A 布尔值（true 或 false）复合类型在Java 中也叫做引用类型。事实上，复合类型数据的值是指向实际数据的指针。数组、类、接口都是复合类型。Java语言中变量名的约定与一般标识符相同，需要区别于程序语言中的保留字，并在其作用域内与其他变量不重名。为习惯起见，变量名以小写字母开头（类名以大写字母开头）。若要在 Java程序中使用变量，首先必须说明该变量。例如

3、：Int iX,iY=0,iZ;String sBig,sCity=Beijing;第二节运算符和表达式运算符是表达式中常用的特殊符号。算术运算和相等及大小的测定式是常用的表达式例子。由于它们会返回一个值，因此可以将它的结果赋值给一个变量，或者在其他Java 语句中测定该值。Java中的运算符包括算术运算符，参见表2 关系运算符，参见表3 条件运算符，参见表4 位运算符，参见表5 逻辑运算符，参见表6 表 2 算术运算符运算符用 法说 明+op1+op2 加（或是字符串的连接）-op1-op2 减*op1*op2 乘/op1/op2 除%op1%op2 余数+op;op+递增 1-op;op-

4、递减 1表 3 关系运算符运算符用 法如果满足以下条件，则返回true op1 op2 op1 大于 op2=op1=op2 op1 大于等于op2 op2 op1 小于 op2=op1 op1 op2 将 op1 右移 op2 op1 op1 op2 将 op1 右移 op2（无符号）&op1&op2 二进制与|op1|op2 二进制或 op1 op2 二进制异或 op 二进制非表 6 赋值运算符运算符用 法等价于+=op1+=op2 op1=op1+op2-=op1-=op2 op1=op1op2*=op1*=op2 op1=op1*op2/=op1/=op2 op1=op1/op2%=o

5、p1%=op2 op1=op1%op2 =op1 =op2 op1=op1 op2 =op1 =op2 op1=op1 =op1 =op2 op1=op1 op2&=op1&=op2 op1=op1&op2|=op1|=op2 op1=op1|op2 =op1 =op2 op1=op1 op2 Java各运算符的优先级定义如下：，()+，-，!，-，instanceof new，(type)*，/，%+，=，!=&|&|?：=，+=，=，*=，/=，%=，=&=，|=，=，=表达式是实际完成某项工作的Java 语句的最简单的形式，是能够返回值的语句。一个表达式包含有一个或多个操作，操作的对象称

6、作运算元，而操作本身是通过运算符来体现的。只有一个运算符称作一元运算符。而二元运算符是具有两个运算元的运算符。表达式在计算时完成一个或多个操作，最终得到一个结果。除去特别声明外，表达式的结果是一个右值，即不能出现在赋值运算的左边，而结果的数据类型则由参加运算的数据类型来决定。当表达式中有两个或多个运算符时，该表达式称作复杂表达式。其中运算符执行的先后顺序由它们的优先级和结合性决定。最简单的表达式只有一个变量式常量。这个运算元没有运算符。例如，下面是几个简单的表达式：3.1415926 china PersonName a+b!var 这里不对 Java 表达式做详细地介绍，感兴趣则可以查阅相关

7、的书籍或资料。第三节控制语句Java的控制语句包括条件、循环和转移三种。1.条件语句条件语句也称为选择语句，用于实现选择结构，它包括if 和 switch 两个语句。(1)if 语句if 语句的一般格式为：if(expression)statement;else statement;其中的语句项statement 可以是一个单独的语句，也可以是用一对 括起来的语句块。Else 从句是可选的。注意在Java 中 if 语句的条件判断表达式的值必须是一个布尔类型。上面 if 语句和 else 子句的语句项中可以包含另一个if 语句，就是说可以实现多重嵌套的 if 语句。If(bEngineOn=t

8、rue)System.out.println(Engine is already on.);else System.out.println(Now starting Engine.);If(gasLevel=1)BengineOn=true;Else System.out.println(Low on gas!Can t start engine.);(2)switch 语句switch 语句根据表达式的值来执行多个操作中的一个，它的一般格式如下：switch(expression)case value1:statement1;break;case value2:statement2;brea

9、k;case valueN:statemendN;break;default:defaultStatement;表达式expression 可以返回任一简单类型的值（如整型、实型、字符型），switch语句把表达式返回的值与每个case子句中的值相比。如果匹配成功，则执行该case子句后的语句序列。case子句中的值value1 必须是常量，而且所有case子句中的值是不同的。default 子句是任选的。当表达式的值与任一case 子句中的值都不匹配时，程序执行 default 后面的语句。如果表达式的值与任一case 子句中的值都不匹配且没有default 子句，则程序不作任何操作，而是直

10、接跳出switch 语句。break 语句用来在执行完一个case分支后，使程序跳出switch 语句，即终止switch语句的执行。因为case 子句只是起到一个标号的作用，用来查找匹配的入口处从此处开始执行，对后面的case子句不再进行匹配，而是直接执行其后的语句序列，因此该在每个case分支后，要用break 来终止后面的case分支语句的执行。在一些特殊情况下，多个不同的case值要执行一组相同的操，这时可以不用break。case分支中包括多个执行语句时，可以不用大括号 括起。switch 语句的功能可以用if-else 来实现，但在某些情况下，使switch 语句更简炼，可读性强，

11、而且程序的执行效率提高。2.循环语句循环语句也称为迭代语句，用于实现需要重复执行的控制结构，它包括while、for 和do-while 三个语句。循环语句的作用是反复执行一段代码，直到满足终止循环的条件为止，一个循环一般应包括四部分内容：初始化部分（initialization）：用来设置循环的一些初始条件，如计数器清零等。循环体部分（body）：这是反复循环的一段代码，可以是单一的一条语句，也可以是复合语句。迭代部分（iteration）：这是在当前循环结束，下一次循环开始时执行的语句，常常用来使计数器加1 或减 1。终止部分（termination）：通常是一个布尔表达式，每一次循环要对

12、该表达式求值，以验证是否满足循环终止条件。(1)while 语句while 语句实现“当型”循环，它的一般格式为：initialization while(termination)body;iteration;当布尔表达式（termination）的值为true 时，循环执行大括号中语句。并且初始化部分和迭代部分是任选的。while 语句首先计算终止条件，当条件满足时，才去执行循环体中的语句。这是“当型”循环的特点。例如：int iCount=0;while(iCount iArray.length&iArrayiCount!=0)iArray1iCount=(float)iArrayiCou

13、nt+;(2)do-while 语句do-while 语句实现 直到型 循环,它的一般格式为:initialization do body;iteration;while(termination);do-while 语句首先执行循环体，然后计算终止条件，若结果为true，则循环执行大括号中的语句，直到布尔表达式的结果为false。与 while 语句不同的是，do-while 语句的循环体至少执行一次，这是“直到型”循环的特点。例如：int iX=1;do System.out.println(Looping,round+iX);iX+;while(iX=5)下面是上一个程序段的输出：Loop

14、,round 1 Loop,round 2 Loop,round 3 Loop,round 4 Loop,round 5(3)for 语句for 语句也用来实现“当型”循环，它的一般格式为：for(initialization;termination;iteration)body;initialization是对循环的开始进行初始化的一个表达式。如果有一个循环指数，那么这个表达式可以对它进行说明和初始化，例如：int iLoopIndex=0。在 for 循环中的这部分中说明的变量均属该循环本身内部的变量，当循环完成后，它们便不存在。termination 是在每次通过循环之后和循环指数递增之

15、前进行的测试。该测试必须是布尔表达式或布尔函数，它可以返回一个布尔值，比如iLoopIndex10。如果测试结果返回true，便执行该循环。如果测试结果是false，该循环便停止执行。iteration 是对任何表达式或函数的调用。通常情况下，递增用于改变循环指数的值，使循环的状态更接近于返回false，从而退出该循环。在初始化部分和迭代部分可以使用逗号语句，来进行多个操作。逗号语句是用逗号分隔的语句序列。例如：for(i=0,j=10;i j;i+,j-),初始化、终止以及迭代部分都可以为空语句（但分号不能省)，三者均为空的时候，相当于一个无限循环。3.转移语句转移语句用于实现控制的转移，它

16、包括break、continue 和 return 三个转移语句。(1)continue 语句continue 语句用来结束本次循环，跳过循环体中下面尚未执的语句，接着进行终止条件的判断，以决定是否继续循环。对于for 语句，在进行终止条件判断前，还要先执行迭代语句。它的格式为：continue;也可以用 continue 跳转到括号指明的外层循环中，这时的格式为continue outerLable;例如：outer:for(int i=0;i 10;i+)外层循环for(int j=0;j 20;j+)内层循环if(j i),continue outer;,该例中，当满足ji 的条件时，程

17、序执行完相应的语句后跳转至外层循环，执行外层循环的迭代语句i+；然后开始下一次循环。(2)return 语句return 语句从当前方法中返回到调用该方法的语句处，并为方法返回一个返回值，语句继续程序的执行。返回语句有两种格式：return expression 返回一个值给调用该方法的语句，返回值的数据类型必须在方法声明中的返回值类型一致。可以使用强制类型转换来使类型一致。return 当方法说明中用void 声明返回类型为空时，应使用这种格式，则不返回任何值。return 语句通常用在一个方法体的最后，以退出该方法并返回一个值。Java 中，单独的return 语句用在一个方法体的中间时，

18、会产生编译错误，因为这时会有一些语句执行不到。但可以通过把return 语句嵌入某些语句（如if-else）来使程序在未执行完方法中的所有语句时退出。例如：int method(int num)return num;will cause compile time error if(num 0)return num;,may or may not be executed depending on the value of num(3)break 语句Java的 break 语句的用途是从一个封闭的语句，如 switch 开关语句或循环中跳出，使程序从封闭语句后的第一个语句开始执行。在 Java

19、中，可以为每个代码块加一个括号，一个代码块通常用大括号 括起来的一段代码。加标号的格式如下：BlockLabel:codeBlock break 语句的第二种使用情况就是跳出它所指定的块，并从紧跟该块的第一条语句处执行。其格式为：break BlockLabel;例如：a:/标记代码块a b:/标记代码块b c:/标记代码块c break b;,/will not be executed ,/will not be executed ,/execute from here 与 C、C+不同，Java 中没有 goto 语句来实现任意的跳转，因为goto 语句破坏程序的可读性，而且影响编译的优化

20、。但是从上例可以看出，Java 用 break 来实现 goto 语句所特有的一些优点。如果 break 后所指定的标号不是一个代码块的标号，而是一个语句，则这时 break完全实现goto 的功能。第四节Java 面向对象的程序设计因为 JSP程序设计会使用到标准的Java语言，所以本节对Java程序设计语言进行简单的介绍。4.1对象对象是一个具有状态和行为的软件模块。对象的状态包含在其成员变量中，对象的行为通过其方法来实现。通常，在Java 中可以以类为原型建立多个对象，这些对象通过发送消息相互影响，消息传递的结果是产生行为或修改指定对象的状态。通过对象的交互，Java 程序可以实现图形用

21、户界面、运行动画、在网上传递信息等任务。对象一旦完成了它的工作，其资源被回收并循环使用。在 Java 中是通过类来创建具体对象的，即对象通过实例化类来实现。使用new 运算符创建新的对象，例如：Date today=new Date();这条语句做了三件事情：1.把 today 这个变量定义成一个类型为Date 的对象；2.实例化一个新的Date 类的对象；3.初始化这个对象。对象的定义语法如下：type name;type 是类名，用来说明对象所属的类，name 是对象名。例如：Date today;对象的定义不是建立对象的必需部分，通常在对象的建立语句中包含了对象的定义。定义并没有实例化该

22、对象。对象一般用new 运算符进行实例化，它只要求一个单一的参数。例如：new Rectangle(0,0,100,100);在例子中，Rectangle(0,0,100,100)是对 Rectangle 类中的构造方法的调用。所有的 Java 类都有一个特殊的方法叫构造函数（构造方法），用来初始化该类的新对象。构造函数和该类有相同的名字。一个类可以提供多个构造函数，以便对新的对象进行不同的初始化，不同的构造函数是通过不同的参数而区分的。例如：public Rectangle();public Rectangle(intValue,intValue);public Rectangle(intV

23、alue,intValue,intValue,intValue);对象的引用有两种方法：1.直接修改它的变量intValue；引用对象的变量与引用C 的结构的元素相似，其方法是在对象名后跟需要引用的变量，中间用.将它们连结起来。如：objectReference.variable 通过这种引用可以检查或修改对象的变量，例如有一个名叫rectgl 的 Rectangle 对象，则可以用rectgl.x 和 rectgl.y 分别引用rectgl 对象的 x 和 y 变量，并可通过这种引用去检查或修改它们。例如：rectgl.x=12;rectgl.y=38;2.调用该对象中定义的方法move()

24、。调用对象中的方法与引用它的数据成员很相似。方法的调用也使用圆点符号。例如：objectReference.method();所有方法的后面都必须配以圆括号，即使该方法不包含参数。例如：rectgl.move(15,40)当对象不再被访问，空间将要被回收时，Java运行环境通过调用finalize()方法使对象终结，这个方法也叫作析构。Finalize()是 java.lang.Object 类中的成员之一。finalize()方法可以显式调用。4.2类类是组成Java 程序的基本要素。它封装了一类对象的状态和方法，是这一类对象的原型。例如 HelloorldApp类的定义如下所示：publi

25、c class HelloWorldApp public static void main(String args )System.out.println(Hello World!);可以看出，一个类的实现包含两部分的内容，类的说明和类的类体：classDeclaration classBody 类的说明包括class、类名及其属性，类的属性为一些关键字，用以说明类属于那个基类、类的访问权限、是否为抽象类等信息：modifiersclass ClassName extends SuperClassNameimplements InterfaceName List 其中：modifiers：类的

26、修饰符，可以是抽象类、公共类、最终类、私有类以及它们的组合；ClassName：类名；Extends 子句：说明类的父类，其中SuperClassName 是父类名；Implements 子句：说明类中将实现的界面，其中InterfaceName List 是一个用逗号分隔的界面列表。类的类体中定义了该类所有的变量和该类所支持的方法。如下所示：class className memberVariableDeclarations methodDeclarations 定义成员变量至少包括两部分：变量的数据类型和变量名。accessSpecifier static final transient

27、volatile type variableName 其中：accessSpecifier：定义了其他类或对象是否可以存取该变量；static：指明该变量是一个类成员变量而不是一个实例成员变量；final：指明该变量是一个常数；transient：指明该变量不维持该对象的持久状态，其值不需保存；volatile：指明该变量是可以被其他方法异步修改的；variableName：变量名。例如：Bicycle 类class Bicycle extends PersonPoweredVehicle String m_sBikeType;Int m_iChainGear;Int m_iRearCogs;

28、Int m_iCurrentGearFront;Int m_iCurrentGearRear;上面的例子显示了Bicycle 类的一个简单类定义，它继承了PersonPoweredVehicle 类的特性。这个类定义包含4 个数据成员。方法的实现包括两部分，即方法的说明和方法体。方法的说明定义了方法名、方法返回值的类型、所需参数的个数和类型以及可调用该方法的其他类或对象。实现方法的一般形式为：returntype methodname(type1 arg1,type2 arg2,type3 arg3.)methodBody 其中 returntype 是该方法返回值的基本数据类型或类。它可以是

29、基本数据类型之一，也可以是一个类名称，如果该方法不返回任何值，则为void。方法的参数列表是用引号括起来的一组变量说明，各个变量说明之间用逗号隔开。这些参数将成为方法本身中的局部变量，它们的值是调用方法时传送的对象或基本数据类型的值。在方法的内部，可以包含语句、表达式、对该类中的其他方法的调用方法以及对其他对象的调用方法等等。下例定义了一个Point 类，并且声明了它的两个变量x、y 坐标，同时实现init()方法对x 和 y 赋初值。class Ponit int x,y;void init(int ix,int iy)x=ix;y=iy;下面是定义了一个makeRange()方法的类的例子

30、。Class RangeClass Int makeRange(int iLower,int iUpper)Int iArr =new int(iUpper-iLower)+1;For(int I=0;I iArr.length;I+)IArrI=iLower+;return iArr;public static void main(String iArg)int iTheArray;RangeClass theRange=new RangeClass();TheArray=theRange.makeRange(1,10);For(int I=0;IiTheArray.length;I+)Sy

31、stem.out.print(iTheArrayI);在 Java 中，当使用对象参数调用一个方法时，传递到方法体中的变量是由对象的引用来传递的。也就是说，无论对方法中的这些对象执行何种操作，都会影响到原始的对象，包括数组以及数组中的所有对象。如果将一个数组传递到一个方法中，并修改它的内容，则原始数组也会受到影响。方法调用中参数的传递方式是值传递。Java语言对于方法和实例对象提供了四个显式级别的保护：Public、Protected、Private、Package。除这四种访问权限指示符外，还有一种不需要显式说明的friendly 指示符，friendly并不是Java 的关键字，它不能被用

32、来显式说明。私有访问（Private）私有访问是用关键字Private 说明的。私有访问意味着方法或变量仅能被同一个类中的其他方法使用。公共访问（Public）公有访问是用关键字Public 说明的。公共访问意味着方法或变量能被任何包中的任何类来存取。保护访问（Protected）保护访问是用关键字Protected 说明的。保护访问意味着方法或变量能允许该类本身、其子类以及同一程序包中的所有其他类来对它进行存取。友好访问（friendly）友好访问是用关键字friendly 说明的。被定义为友好访问的方法或变量允许同一程序包中的所有类对它进行存取。例如：/PassByRefrence 类：c

33、lass PassByRefrence int OneToZero(int iSg)int iCount=0;for(int I=0;IiSg.length;I+)if(iSgI=1)iCount+;iSgI=0;return iCount;/PassByRefrence 类的 main()方法：public static void main(String arg)int iArr =1,3,4,5,1,1,7;PassByRefrence test=new PassByRefrence();Int iNums;System.out.print(Values of the array:);Fo

34、r(int I=0;I iArr.length;I+)System.out.print(iArrI+);System.out.println();INums=test.OneToZero(arr);System.out.println(Number of Ones=+iNums);System.out.print(New values of the array:);For(int I=0;I iArr.length;I+)System.out.print(iArrI+);System.out.println();程序的输出结果为：Values of the array:1 3 4 5 1 1

35、7 Numbers of Ones=3 New values of the array:0 3 4 5 0 0 7 4.3子类、父类和继承与其他面向对象的程序设计语言类似，Java的类可以从已定义的类中派生出来。被派生出来的类称为子类，而已定义的类则称为父类。Java 定义子类的方法是在子类名后加extends 关键字，例如下面代码段由Animal 类创建一个称为Dog 的子类。Class Dog extends Animal 这样就定义了Animal 类的子类Dog。子类可以从父类中继承成员变量的方法，也就是说，在子类中可直接使用父类中定义的成员变量和方法。子类将继承父类中的如下成员变量和方

36、法：被定义为公用的、私有的或保护的成员变量和方法。同一个程序包中的父类的友好变量和方法。子类可以直接应用、修改或重载父类中定义的变量和方法。当子类希望替换或添加父类的一个方法体时，它可以用相同的方法名来重载父类中已经定义过的方法。但是，子类不能重载在父类中被定义为final 的方法。在子类中也同样不能重载在父类中被定义为static 的方法，也就是说，子类不能重载其父类的静态方法。在父类中定义成abstract的方法的实现细节必须由子类来完成，所以，子类必须对这些abstract 方法进行重载。请看下面的程序实例：/PrintClass 类Class PrintClass Int m_iX=0

37、;Int m_iY=1;Void printMe()System.out.println(m_iX is+m_iX+,m_iY is +m_iY);System.out.println(I am an instance of class +this.getClass().getName();/PrintSubClass 类Class PrintSubClass extends PrintClass Int m_iZ=3;Public static void main(String args)PrintSubClass obj=new PrintSubClass();Obj.printMe();

38、PrintSubClass 类继承了PrintClass 类的 printMe()方法。下面是PrintSubClass 输出：X is 0,Y is 1 I am an instance of the class PrintSubClass 再来看一种情况：/PrintSubClass2 类Class PrintSubClass2 extends PrintClass Int m_iZ=3;Void printMe()System.out.println(m_iX is+m_iX+,m_iY is+m_iY+,m_iZ is +m_iZ);System.out.println(I am an

39、 instance of class +this.getClass().getName();public static void main(String args)PrintSubClass2 obj=new PrintSubClass2();Obj.printMe();PrintSubClass2 类与 PrintSubClass 类基本相同，只是重新定义了printMe()方法，输出结果为：M_iX is 0,m_iY is 1,m_iZ is 3 I am an instance of the class PrintSubClass2 不能再派生子类的类叫做最终类。定义一个类为最终类，在

40、它的定义的前面加上final关键字。final 关键字通常出现在保护关键字中，如public 或 private 的后面。public final class FinalClassname 将一个类声明为final 的，出于两个原因：防止其他人对你的类进行子类扩展。为了获得更高的效率。由 于 安 全 原 因 而 定 义 为 最 终 类 的 有：java.lang.System、.InetAddress和.Socket。例如：final class Fmm final int value=3;final int Fmm(int a,int b)抽象类的目的是为子类提供公共信息。声明抽象类用关键字

41、abstract：public abstract class Food 抽象类永远不能够实例化，但是抽象类能够包含任何一般的类所包含的内容，还可以包含 abstract 方法。例如：abstract class GraphicObject int x,y;void moveto(int newx,int newy)abstract void draw();GraphicObject 的每个非抽象子类（例如circle 和 Rectangle），都必须为draw()提供应用服务：Class circle extends GraphicObject Void draw()Class Rectang

42、le extends GraphicObject Void draw()4.4程序包和异常处理程序包是Java 语言中另一个重要的概念，是管理大型名字空间、避免冲突的工具。每一个类的名字都包含在某个包中。包的定义语句的一般形式为：package packageName;通过 import 命令输入一个包，import 有三种形式：import package;import package.class;import package.*;例如：import java.awt.peer;import java.util.Vector;import java.io.*;在今后的程序中我们引用了Java

43、 API 和 Java Servlet API 中的类库，它们都是以程序包形式存在：java.lang：包含所有的基本语言类；java.text：包含了与语言无关方式处理的文本、数据、数字和消息的类；java.io：包含输入输出类；java.utl：包含有用的数据类型类；：包含实现网络功能的类；java.sql：包含访问和处理数据源中的数据；javax.servlet：包含了支持普通协议无关的Servlet 的类；javax.servlet.http：包括了对HTTP 协议的特别支持。接下来介绍Java 中错误和异常处理。错误是指与虚拟机或动态装载等相关的问题，如系统崩溃等，这类错误一般被认为

44、是不可恢复和不可捕获的。异常是程序执行过程中出现的违背正常指令流的事件，是可以捕获的。Java中的每个异常都是一个对象，它是 Throwable 类或其子类的实例对象，这个对象从出现异常的方法传递信息给捕获异常并处理它的方法。Throwable 类有两个标准子类：java.lang.Error 和 java.lang.Exception，即错误和异常。基本的异常处理结构为trycatch 结构，例如：public static double Divider(double numerator,double denominator)try double result=numerator/denom

45、inator;return result;catch(ArithmeticException a)System.out.print(An arithmetic exception occurred!);Return 0;如果可能会有其他类型的例外，可以增加其他的catch 语句。唯一的要求是每一个catch语句必须有一个唯一的类型。当一个例外发生的时候，与该类型相关的catch 语句块就会被执行。finally 结构提供了一种最终解决机制。不管 try 结构发生了什么，finally 结构都将运行。通常使用finally 结构来关闭或释放其他系统资源。例如：finally if(pStr!=n

46、ull)System.err.println(Closing PrintStream);else System.err.println(PrintStream not open);throw 语句用来明确地抛出一个“异常”。首先，必须得到一个Throwable 实例的控制柄，通过参数传到catch 子句，或者用new 操作符来创建一个Throwable 实例。下面是throw 语句的通常形式。throw ThrowableInstance;程序会在 throw 语句后立即终止，它后面的语句将不会执行。然后在包含throw 语句的所有 try 块中从里向外查找，寻找含有与其匹配的catch 子句

47、的 try 块。下面是一个含有throw语句的例子。class ThrowDemo static void demoproc()try throw new NullPointerException(de3mo);catch(NullPointerException e)System.out.println(caught inside demoproc);throw e;public static void main(String args)try demoproc();catch(NullPointerException e)system.out.println(recaught:+e);4.

48、5/类和系统类许多 Java 程序需要从输入设备中读数据以及向设备中写数据，Java 的输入输出是建立在流的基础之上的。所谓流是指一个无限长的项目序列，其项目通常是八位的字节码，可以被读写访问。Java 开发环境提供一个名为java.io 的程序包，其中包括用来读写数据的输入和输出流。java.io 程序包包含以下两个类：输入流类，基类为InputStream；输出流类，基类为OutputStream。java.io 程序包中其他的类都是这两个类的子类，只有RandomAccessFile 类例外。输入流是一个抽象的基类，它提供了一个最小的编程接口以及用来处理Java 中输入流的程序接口。输入

49、流类定义了以下内容：读字节或字节数组的方法标记流中的位置跳过输入的字节确定输入的有效字节数在流中重新定位当生成输入流时，它就自动打开了；可用 close()方法关闭一个流或者等到该流对象被回收时，它会自动关闭。输出流也是一个抽象的基类，它提供了一个最小的编程接口以及用来处理Java 中输出流的程序接口。输出流类定义了写字节或字节数组到流中去等方法。当生成输出流时，它就自动打开了，在以下情况下可以关闭输出流：可用 close()方法关闭一个输出流；该输出流对象被回收时，它会自动关闭。输入流的类层次结构如图14.20 所示。Java.io.InputStream FilterInputStream

50、 FileInputStream ByteArrayInputStream PushBackInputStream LineNumberInputStream DataInputStream BufferedInputStream StringInputStream SequenceInputStream PipedInputStream Java.lang.Object 图 4.20 输入流的类层次结构图输出流的类层次如图4.21 所示。PipedOutputStream PrintStream DataOutputStream BufferedOutputStream FilterOutp