java论文.docx

java论文.docx

《java论文.docx》由会员分享，可在线阅读，更多相关《java论文.docx（19页珍藏版）》请在冰豆网上搜索。

java论文

标题读书笔记

班级

学号

姓名

日期2012/10/30

1.前言·························································

2.继承、抽象类和接口············································

3.异常处理······················································

4.JAVA语言的输入输出与文件处理·································

5.多线程·························································

6.结论···························································

5.参考文献······················································

前言

如同任何人类语言一样，Java提供了一种表达概念的方式。

如果使用得当，随着问题变得更庞大更复杂，这种表达工具将会比别的可供选择的语言更为简单、灵活。

我们不应该将Java仅仅看作是一些特性的集合——有一些特性在孤立状态下没有任何意义。

只有在考虑到设计，而不仅仅是编码时，才能完整地运用Java的各部分。

而且，要按照这种方式来理解Java，必须理解在语言和编程中经常碰到的问题。

在这个读书笔记中，我将对java2程序设计基础（第二版）中的第八章：

继承、抽象类和接口、第九章：

异常处理、第十章：

JAVA语言的输入输出与文件处理和第十一章：

多线程做出自己的学习心得和自己学习完这几章后所做的读书笔记和大家分享，如果对大家学习java有所帮助，希望大家给与支持，如果有什么需要改进的地方，也希望大家给与纠正，本人将不胜感激。

这个读书笔记讨论的是编程问题，他们为什么成为问题，以及Java已经采取什么样的方案来解决它们。

因此，每章所阐述的内容，都是基于我所看到的这一语言在解决特定类型问题时的方法。

按照这种方法，我希望能够每次引导读者前进一点，直到Java思想意识成为你最自然不过的语言。

自始至终，我一直持这样的观点：

你需要在头脑中创建一个模型，以加强对这种语言能的深入理解；如果你遇到了疑问，就将它反馈到头脑中的模型并推断出答案。

继承、抽象类和接口

继承

继承是一种由已有类创建新类的机制。

利用继承，可以先创建一个公共属性的一般类，根据一般类在创建一个具有特殊属性的新类。

新类继承一般类的状态和行为，并根据需要增加自己的新的状态和行为。

多层继承

类的继承

一个类从另一个类派生出来的过程叫继承，被继承的类称为基类（超类），执行该继承的类称为子类（派生类）。

继承是面向对象编程技术的一块基石，它允许创建分等级层次的类。

运用继承，可以创建一个通用类定义一系列一般特性。

该类可以被更具体的类继承。

子类的创建

类的继承是通过extends关键字来实现的在定义类时若使用ectends关键字指出新定义类的父类，就是在两个类之间建立了继承关系。

新定义的类称为子类它可以从父类那里继承所有非private的成员作为自己的成员。

子类的创建*格式

classSubClassextendsSuperClass

*{

*.

*.

*.

*}

在子类中访问父类的成员

1在子类中使用super不但可以访问父类的构造方法，还可以访问父类成员就是和成员方法。

但super不能访问在子类中添加的成员。

子类中访问父类成员的格式如下

1.super.变量名;2.super.方法名;

2用protected修饰的成员可以被三种类所引用该类自身、与它在同一个包中的其他类、在其他包中该的子类。

3将成员声明为protected的最大好处是可以同时兼顾到成员的安全性和便利性。

例//在学生子类Student中访问父类Person的成员。

用protected修饰符和super关键字访问父类的成员

classPerson3{

protectedStringname;//用protected（保护成员）修饰符修饰

protectedintage;

publicPerson3（）//定义Person3类的“不做事”的无参构造方法

{}

publicPerson3（Stringname,intage）//定义Person3类的有参构造方法{

this.name=name;this.age=age;

}

protectedvoidshow（）{

System.out.println（"姓名"+name+"年龄"+age）;

}

}

classStudent3extendsPerson3//定义子类Student3其父类为Person3

{

privateStringdepartment;

intage=20;//新添加了一个与父类的成员变量age同名的成员变量

publicStudent3（Stringxm,Stringdep）//定义Student3类的有参构造方法

{

name=xm;//在子类里直接访问父类的protected成员name

department=dep;

super.age=25;//利用super关键字将父类的成员变量age赋值为25System.out.println（"子类Student3中的成员变量age="+age）;super.show（）;//去掉super而只写sho（）亦可

System.out.println（"系别"+department）;

}

}

publicclassApp8_3

{

publicstaticvoidmain（String[]args）

{

@SuppressWarnings（"unused"）Student3stu=newStudent3（"李小四","信息系"）;

}

}/*在子类中访问父类的成员

覆盖

重载是指在同一个类内定义名称相同但参数个数或类型不同的方法。

覆盖overriding是指在子类中定义名称、参数个数与类型均与父类完全相同的方法，用于重写父类里同名方法的功能

覆盖父类的方法：

子类在重新定义父类已有的方法时，应保持与父类完全相同的方法声明，即应与父类有完全相同的方法名、返回值类型和参数列表，否则就不是方法的覆盖而是子类定义自己的与父类无关的方法，父类的方法末被覆盖，所以仍然存在。

*注意

子类中不能覆盖父类中声明为final或static的方法。

在子类中覆盖父类的方法时可以扩大父类中方法权限，但不可以缩小父类方法的权限。

抽象类与抽象方法

抽象类是以修饰符abstract修饰的类定义抽象类的语法格式如下abstractclass类名

{

声名成员变量;

返回值的数据类型方法名（参数表）——————一般方法

{„„}

abstract返回值的数据类型方法名（参数表）;——————抽象方法

}

注意

1.由于抽象类是需要被继承的，所以abstract类不能用final来修饰。

也就说一个类不能既是最终类又是抽象类即关键字abstract与final不能合用。

2.abstract不能与private、stastic、final或native并列修饰同一方法。

3.抽象类的子类必须实现父类中的所有方法或者将自己也声明为抽象的。

4.抽象类中不一定包含抽象方法但包含抽象方法的类一定要声明为抽象类。

5.抽象类可以有构造方法且构造方法可以被子类的构造方法所调用但构造方法不能被声明为抽象的。

6.一个类被定义为抽象类，则该类就不能用new运算符创建具体实例对象，而必须通过覆盖的方式来实现抽象类中的方法。

7.抽象方法在抽象方法里，不能定义方法体。

接口

接口的实现是在声明一个类的同时用关键字implements来实现一个接口。

接口实现的语法格式为

*class类名称implements接口名表

*{

*„„

*}

接口与抽象类非常相似，但又有以下的区别

抽象类（abstractmethod）

接口（interface）

可以包含实现区块

不能包含实现区块

可以包含抽象方法

不能包含抽象方法

可以包含非public成员

不可以包含非public成员

能继承其他的类,包含非抽象类

能继承其他接口

可以控制版本

无法控制版本

不能被实例化

不能被实例化

一个类要实现一个接口时注意以下问题

1、接口由类实现，类可以在继承父类的同时实现多个接口。

2、类实现接口时，必须实现接口中的所有方法，为这些方法提供方法体。

且方法必须声明为public，返回类型和参数必须和接口中声明一致。

3、类实现接口时，每个方法必须有方法体，如果不能实现某个方法，也必须写出一个空方法。

4、如果接口的方法的返回类型不是void的，则在类中实现该接口方法是，方法体至少要有一个return语句。

接口的继承与多重继承

与类相似，接口也有继承性。

定义一个接口时可通过extends关键字声明该新接口是某个已存在的父接口的子接口它将继承父接口的所有变量与方法。

与类的继承不同是，一个接口可以有多个父接口，它们之间用逗号分隔，形成父接口列表。

如果有子接口中有与父接口同名的常量或相同的方法，则父接口中常量被隐藏方法被覆盖。

内部类与匿名类

内部类（InnerClass）是定义在类中的类，内部类的主要作用是将逻辑上相关的类放到一起。

匿名类，没有类名，在定义类的同时就生成该类的一个实例。

匿名内部类：

是指利用内部类创建没有名称的对象，并利用它访问到类里的成员。

内部类的特性

内部类可以声明为private或protected

内部类如有final修饰，则表明该内部类不能被继承

内部类可以定义为abstract，但需要被其他的内部类继承或实现

内部类不能与包含它的外部类同名。

匿名内部类

匿名内部类的定义与创建该类的一个实例同时进行，即类的定义前面有一个new运算符。

匿名内部类名前不能由修饰符，也不能定义构造方法。

一个内部类的类声明只是在创建此类对象时用一次，而且要产生的新类需继承于一个已有的父类或实现一个接口，才考虑用匿名类。

作用：

主要是用来弥补内部类里没有定义到的方法

例//匿名内部类的使用方法

publicclassApp8_14{

publicstaticvoidmain（String[]args）{

（

newInner（）//创建匿名内部类Inner的对象

{

voidsetName（Stringn）

{

name=n;

System.out.println（"姓名"+name）;//以上三句是为弥补内部

}

//类Inner里没有定义到的方法

}//创建匿名内部类Inner的对象

）.setName（"张华"）;//执行匿名内部类里所定义的方法

}

staticclassInner//定义内部类

{

Stringname;

}

}

包

包是Java语言提供的一种区别类名空间的机制，是类的组织方式，每个包对应一个文件夹。

目的：

1）避免重名冲突。

2）实现访问权限控制。

异常处理

异常处理的基本概念

异常是指在程序运行中由代码产生的一种错误。

在不支持异常处理的程序设计语言中，每一个运行时错误必须由程序员手动控制，这样不仅会给程序员增加很大的工作量，而且这种方法本身也很麻烦。

Java语言中的异常处理机制避免了这些问题，把程序运行时错误的管理带到了面向对象的世界中。

错误与异常

按错误的性质分为语法错、语义错、逻辑错。

语法错是由于没有遵循Java语言的语法规则而产生的，这种错误要在编译阶段排除，否则程序不可能运行。

语义错是指程序运行过程中出现了一个不可能执行的操作，就会出现运行时错误，运行时错误有时也可以由逻辑错误引起。

逻辑错是指程序编译正常，也能运行，但结果不是人们所期待的。

Java系统中根据错误严重程度的不同，将运行错分为下面两类

（1）错误

（2）异常

Java语言的异常处理机制

异常处理的主要目的是即使在程序运行时发生了错误，也要保证程序能正常结束，避免由于错误而使正在运行的程序中途停止。

一个好的应用程序，除了具备用户要求的功能外，还要求能预见程序执行过程中可能产生的各种异常，并把处理异常的功能包括在用户程序中。

异常处理机制是JAVA语言的重要特征之一。

通过异常处理机制可防止程序执行期间因出现错误而造成不可预料的结果。

异常处理

publicvoidfun1throwsAppException

{

//code...

try{

//会抛出sql异常的代码

}catch{SQLExceptionex}{

thrownewAppException（"sql异常:

"+ex.getMessage（））;

}

//code....

}

pulicvoidfun2throwsAppException,LogicException

{

//code

try{

//code,可能出现逻辑异常

}catch（AppExceptionex）{

thrownewLogicException（"逻辑异常，比如：

订单已经被取消，不能操作。

"）;

}

//code

fun1（）;//有能力处理，则try这个方法，没有能力处理，抛出给上层调用方法。

}

异常

异常是程序执行期间发生的各种意外或错误。

比如说：

①用户输入出错

②所需文件找不到

③运行时磁盘空间不够

④内存不够

　　　⑤算术运算错（数的溢出，被零除…）

⑥数组下标越界

　　　　．．．．．．

抛出异常

抛出异常有两种方式：

由系统自动抛出和利用抛出语句抛出。

1由系统自动抛出异常

在程序运行过程中，如果出现了可被Java运行系统识别的错误，系统会自动产生与该错误相对应的异常类的对象，即自动抛出。

例如上例。

2人为异常抛出

两种方式：

①在方法头写出需要抛出的异常（利用throws语句）

②在方法体内抛出异常（利用throw语句）

捕获异常

异常抛出后，运行系统从生成异常对象的代码开始，沿方法的调用栈逐层回溯查找，直到找到包含相应异常处理的方法，并把异常对象提交给该方法为止。

用户自定义的异常类

尽管Java提供了很多异常类，但用户还是可以根据需要定义自己的异常类，即创建自定义异常类。

说明：

（1）用户自定义的异常类必须是Throwable类或Exception类的子类。

（2）自定义的异常类，一般只要声明两个构造方法，一个是不用参数的，另一个以字符串为参数。

作为构造方法参数的字符串应当反映异常的信息。

（3）throw关键字通常用在方法体中，并且抛出一个异常对象。

程序在执行到throw语句时立即停止，它后面的语句都不执行。

通常throw抛出异常后，如果想在上一级代码中来捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法声明中指明要抛出的异常；如果要捕获throw抛出的异常，则必须使用try{}catch{}语句。

　　例如：

18px">publicclassMyExceptionextendsException{//创建自定义异常类

Stringmessage;//定义String类型变量

publicMyException（StringErrorMessage）{//父类方法

message=ErrorMessage;

}

publicStringgetMessage（）//覆盖getMessage（）方法

{

returnmessage;

}

}

（4）

publicclassCaptor{//创建类

staticintquotient（intx,inty）throwsMyException{

if（y<0）{//判断参数是否小于0

thrownewMyException（"除数不能使负数"）;//异常信息

}

returnx/y;//返回值

}

publicstaticvoidmain（String[]args）//主方法

{

try{

intresult=quotient（3,-1）;

}catch（MyExceptione）{//处理自定义异常

System.out.println（e.getMessage（））;//输出异常信息

}catch（ArithmeticExceptione）{

//输出ArithmeticException算术异常

System.out.println（"除数不能为0"）;//输出提示信息

}catch（Exceptione）{//处理其他异常

System.out.println（"程序发生了其他异常"）;

}

}

}

定义更详细的异常分类，原则有如下几个

1.比较严重，或者都不能处理的异常，比如IO,SQL等，在触发异常处转化为Runtime异常，这样调用方法代码更清晰，更简洁

2.逻辑异常，调用方法能够处理的（比如调用方法捕获这个异常，显示到网页上）,转换为检查型异常，否则，转换为runtime异常

3.有能力处理的异常，才try，否则throws抛出，留给有能力的方法去处理。

Java语言的输入输出与文件处理

程序的输入和输出可以说是程序与用户之间沟通的桥梁，通过输入输出操作实现用户与程序的交互。

流（stream）是指计算机各部件之间的数据流动。

流是由位或字符组合而成的序列。

分类：

传输方向：

输入流与输出流

内容上：

字符流和字节流

输入输出

在Java中，把不同类型的输入输出源抽象为流，其中输入和输出的数据称为数据流（DataStream）。

数据流是Java程序发送和接收数据的一个通道，数据流中包括输入流（InputStream）和输出流（OutputStream）。

通常应用程序中使用输入流读出数据，输出流写入数据。

缓冲流

为了提高数据的传输效率，引入了缓冲流（BufferedStream）的概念，即为一个流配备一个缓冲区（Buffer），一个缓冲区就是专门用于传送数据的一块内存。

输入输出流类库

Java语言的流类都封装在java.io包中。

字节流每次读写8位（一个字节）的二进制数，一般为二进制文件。

字符流每次读写16位二进制数，并将其作为一个字符而不是二进制为来处理。

可以表示任何的文本信息。

处理字节流：

InputStream和OutputStream

处理字符流：

Reader和Writer

使用InputStream和OutputStream流类

InputStream和OutputStream都是抽象类，InputStream为其他所有字节输入流的超类，而OutputStream为其他所有字节输出流的超类。

InputStream的方法：

publicintread（）throwsIOException

从输入流读取下一个字节，字节值为0-255，如果输入流中不再有数据，返回-1表示输入结束。

这是一个阻塞方法，直到有数据可读，或数据流结束，或发生异常时才返回。

这是一个抽象方法，需要在具体的子类中加以实现。

在OutputStrem中定义了5个方法：

publicabstractvoidwrite（intb）throwsIOException

向输出流写入一个字节。

写出字节为整数b的低字节，整数b的3个高字节被忽略。

这是一个抽象方法，需要在具体的子类中加以实现。

publicvoidwrite（byte[]b）throwsIOException

把缓冲区b中的全部数据写入输出流。

publicvoidwrite（byte[]b,intoff,intlen）throwsIOException

把缓冲区b中从b[off]开始的len个字节的数据写入输出流。

publicvoidflush（）throwsIOException

刷新输出流，强制输出缓冲区的数据立即写出。

publicvoidclose（）throwsIOException

关闭输出流。

很多人搞不清程序要将A文件的内容写入B文件中，程序对A文件的操作所用的是输出类还是输入类这个问题。

读者也先自己想想，再记住下面的话，输入输出类是相对程序而言的，而不是代表文件的，所以我们应该创建一个输入类来完成对A文件的操作，创建一个输出类来完成对B文件的操作。

关闭流对象。

下面以读取文件的代码示例：

importjava.io.*;/***使用FileInputStream读取文件*/

publicclassReadFile1{

publicstaticvoidmain（String[]args）{//声明流对象

FileInputStreamfis=null;

try{//创建流对象

fis=newFileInputStream（"e:

//a.txt"）;//读取数据，并将读取到的数据存储到数组中byte[]data=newbyte[1024];//数据存储的数组

inti=0;//当前下标//读取流中的第一个字节数据

intn=fis.read（）;//依次读取后续的数据

while（n!

=-1）{//未到达流的末尾//将有效数据存储到数组中

data[i]=（byte）n;//下标增加

i++;//读取下一个字节的数据

n=fis.read（）;}//解析数据

Strings=newString（data,0,i）;//输出字符串System.out.println（s）;

}catch（Exceptione）{

e.printStackTrace（）;

}finally{

try{//关闭流，释放资源

fis.close（）;

}catch（Exceptione）{}

}}}

使用Reader和Writer流类

读取器（Reader）和写出器（Writer）是所有字符流的超类，它们是直接继承Object类的抽象类。

用来处理纯文本文件。

Reader和Writer可读写16位的字符流。

作为抽象类，Reader和Writer必须被子类化才能实现字符流的读写工作。

文