一.异常

　　java对异常的处理同delphi一样,不是刻意的去避免它的发生,而是等它发生后去补救.

　　delphi的异常处理简单来说就是一下语句

try
except//异常发生后就转入此处执行
finally//不管异常发不发生，都转入此处运行
end

　　与此相类似，java的异常处理的基本形式如下

try{
}catch(exceptiontype1 e){
file&://对/异常情况1的处理
}catch(exceptiontype2 e){
file&://对/异常情况2的处理
throw(e)//抛出异常,和delphi中的raise是一回事
}

　　要补充的是,对大多数的异常,假如你要在正常运行的程序中而不是捕捉异常的程序中明确的抛出,java的编译器需要你事先对你要抛出的异常作声明，否则不允许编译通过.这个任务是由throws来完成的.

　　二.java的输入输出流

　　2.1 输出

system.out.print　 file&://这/里out是一个静态方法哦
system.out.println
system.err.print　 file&://err/和out一样也是标准输出,至于有什么不同,我目前还不清楚
system.err.println

　　2.2 输入

system.in.read()

　　2.3 文件的操作

　　只需要几个带注释的例子就可以了。

　　第一个是一个显示文件基本信息的程序

import java.io.*;//调入和io相关的类
class fileinfo{
file&://注/意,main函数一定是静态方法

　public static void main(string args[])throws ioexception{
　　file filetocheck;//使用文件对象创建实例
　　if (args.length>0){
　　　for (int i=0;i<args.length;i++){
　　　　filetocheck=new file(args[i]);//为文件对象分配空间
　　　　info(filetocheck);//这里引用的info一定要是静态方法成员
　　　}
　　}
　　else{
　　　system.out.println("no file given");
　　}
　}

　public static void info(file f)throws ioexception{
　　system.out.println("name:"+f.getname());
　　system.out.println("path:"+f.getpath());
　　if (f.exists()){
　　　system.out.println("file exists.");
　　　system.out.print((f.canread()?" and is readable":""));//判断函数，如果满足条件，输出前者，否则输出后者
　　　system.out.print((f.canwrite()?"and is writable":""));
　　　system.out.print(".");
　　　system.out.println("file is"+f.length()+"bytes.");
　　}
　　else{
　　　system.out.println("file does not exist.");
　　}
　}
}


　　第二个例子是一个存储电话信息的小程序,用户输入姓名和电话号码,程序将其存入phone.numbers文件中，通过fileoutputstream来实现

import java.io.*;

class phones{
　static fileoutputstream fos;
　public static final int linelength=81;
　public static void main(string args[])throws ioexception{
　　byte[] phone=new byte[linelength];
　　byte[] name=new byte[linelength];
　　int i;
　　fos=new fileoutputstream("phone.numbers");
　　while(true){
　　　system.err.println("enter a name(enter ´´done´´ to quit)");
　　　readline(name);
　　　if ("done".equalsignorecase(new string(name,0,0,4))){
　　　　break;
　　　}
　　　system.err.println("enter the phone number");
　　　readline(phone);
　　　for (i=0;phone[i]!=0;i++){
　　　　fos.write(phone[i]);
　　　}
　　　fos.write(´´,´´);
　　　for (i=0;name[i]!=0;i++){
　　　　fos.write(name[i]);
　　　}
　　　fos.write(´´´´);
　 }
　 fos.close();
　}

　private static void readline(byte line[])throws ioexception{
　　int i=0,b=0;
　　while((i<(linelength-1))&&((b=system.in.read())!=´´´´)){
　　　line[i++]=(byte)b;
　　}
　　line[i]=(byte)(0);
　}
}


2.4 流

　　无非是两种

　　输出流,让我们来写的

　　输入流,给我们来读的

　　java.io包中有很多种类的输入输出流：

　　1.fileinputstream和fileoutputstream 节点流

　　2.bufferedinputstream和bufferedoutputstream 过滤流

　　3.datainputstream和dataoutputstream 增强的过滤流

　　4.pipedinputstream和pipledoutputstream 用于线程的流

　　掌握了流的概念,就可以开始sockets的学习了.关于socket的作用,昨天我已经讲了.

　　现在,我们将创建一个简单的通讯程序,以获得对socket的实质性的认识.该程序包括两个部分,客户机(remotefileclient)和服务器(remotefileserver).客户机向服务器发出请求,要求读取服务器上的文件信息.服务器将响应请求,将相应的文件信息传给客户机,将相应的文件信息传给客户机.

　　首先我们创建remotefileclient类：

import java.io.*;//java.io 包提供对流进行读写的工具,也是与 tcp 套接字通信的唯一途径
import java.net.*;//java.net 包提供套接字工具。

public class remotefileclient {
　　protected string hostip;
　　protected int hostport;
　　protected bufferedreader socketreader;//负责读数据的对象
　　protected printwriter socketwriter;//负责写数据的对象

　　file&://类/的构造器有两个参数：远程主机的 ip 地址(hostip)和端口号(hostport)各一个.构造器将它们赋给实例变量

　　public remotefileclient(string ahostip, int ahostport) {
　　　　hostip = ahostip;
　　　　hostport = ahostport;
　　}
　　public static void main(string[] args) {
　　}
file&://连/接到远程服务器
　　public void setupconnection() {
　　}
file&://向/远程服务器请求文件信息
　　public string getfile(string filenametoget) {
　　}
file&://从/远程服务器上断开
　　public void teardownconnection() {
　　}
}


　　首先来实现main()

public static void main(string[] args) {
　　remotefileclient remotefileclient = new remotefileclient("127.0.0.1", 3000);//为了方便调试，我们把本地服务器当作远程服务器
　　remotefileclient.setupconnection();//连接。不能直接使用setupconnection，因为它是非静态变量，需要创建实例后，对实例进行引用，可以看我第一天的日记，上面写的非常详细
　　string filecontents =
　　　　remotefileclient.getfile("remotefile.txt");//读取

　　remotefileclient.teardownconnection();//断开

　　system.out.println(filecontents);//输出读取内容
}


　　步骤非常清楚.那么我们分别看连接,读取,断开是怎么实现的

　　1.连接

public void setupconnection() {
　　try {
　　　　socket client = new socket(hostip, hostport);//创建socket对象


　　　　 outputstream outtoserverstream=client.getoutputstream();
　　　　 inputstream　infromserverstream=client.getinputstream();
　　　　 socketreader = new bufferedreader(new inputstreamreader(infromserverstream));
file&://把/socket的inputstream包装进bufferedreader 以使我们能够读取流的行

　　　　 socketwriter = new printwriter(outtoserverstream);
file&://把/socket的outputstream包装进printwriter 以使我们能够发送文件请求到服务器

　　} catch (unknownhostexception e) {
　　　　system.out.println("error setting up socket connection: unknown host at " + hostip + ":" + hostport);
file&://对/socket对象创建错误的异常处理
　　} catch (ioexception e) {
　　　　system.out.println("error setting up socket connection: " + e);
file&://对/io错误的异常处理
　　}
}

　　2.读取

public string getfile(string filenametoget) {
　　stringbuffer filelines = new stringbuffer();//stringbuffer对象也是string对象，但是比它更灵活，这里是用来存放读取内容的

　　try {
　　　　socketwriter.println(filenametoget);
　　　　socketwriter.flush();//文件存放地址输出到socketwriter中,然后清空缓冲区,让这个地址送到服务器中去


　　　　string line = null;
　　　　while ((line = socketreader.readline()) != null)
　　　　　　filelines.append(line + "");
file&://既/然已经发送到服务器去了,那我们都要等待响应,这里的程序就是等待服务器把我们所需要的文件内容传过来
　　} catch (ioexception e) {
　　　　system.out.println("error reading from file&: " + filenametoget);
　　}

　　return filelines.tostring();//别忘了把buffer中的内容转成string再返回
}

　　3.断开

public void teardownconnection() {
　　try {
　　　　socketwriter.close();
　　　　socketreader.close();
　　} catch (ioexception e) {
　　　　system.out.println("error tearing down socket connection: " + e);
　　}
}

　　teardownconnection() 方法只别关闭我们在 socket 的 inputstream 和 outputstream 上创建的 bufferedreader 和 printwriter。这样做会关闭我们从 socket 获取的底层流，所以我们必须捕捉可能的 ioexception

　　好,现在可以总结一下客户机程序的创建步骤了

　　1.用要连接的机器的ip端口号实例化socket（如有问题则抛出 exception）。

　　2.获取 socket 上的流以进行读写.

　　3.把流包装进 bufferedreader/printwriter 的实例.

　　4.对 socket 进行读写.具体说来,就是在writer上传送文件地址信息给服务器,在reader上读取服务器传来的文件信息




5.关闭打开的流。

　　下面是remotefileclient 的代码清单

import java.io.*;
import java.net.*;

public class remotefileclient {
　　protected bufferedreader socketreader;
　　protected printwriter socketwriter;
　　protected string hostip;
　　protected int hostport;

　　public remotefileclient(string ahostip, int ahostport) {
　　　　hostip = ahostip;
　　　　hostport = ahostport;
　　}
　　public string getfile(string filenametoget) {
　　　　stringbuffer filelines = new stringbuffer();

　　　　try {
　　　　　　socketwriter.println(filenametoget);
　　　　　　socketwriter.flush();

　　　　　　string line = null;
　　　　　　while ((line = socketreader.readline()) != null)
　　　　　　　　filelines.append(line + "");
　　　　} catch (ioexception e) {
　　　　　　system.out.println("error reading from file&: " + filenametoget);
　　　　}

　　　　return filelines.tostring();
　　}
　　public static void main(string[] args) {
　　　　remotefileclient remotefileclient = new remotefileclient("127.0.0.1", 3000);
　　　　remotefileclient.setupconnection();
　　　　string filecontents = remotefileclient.getfile("remotefile.txt");
　　　　remotefileclient.teardownconnection();

　　　　system.out.println(filecontents);
　　}
　　public void setupconnection() {
　　　　try {
　　　　　　socket client = new socket(hostip, hostport);

　　　　　　outputstream outtoserverstream=client.getoutputstream();
　　　　　　inputstream　infromserverstream=client.getinputstream();
　　　　　　socketreader = new bufferedreader(new inputstreamreader(infromserverstream));
　　　　　　socketwriter = new printwriter(outtoserverstream);

　　　　} catch (unknownhostexception e) {
　　　　　　system.out.println("error setting up socket connection: unknown host at " + hostip + ":" + hostport);
　　　　} catch (ioexception e) {
　　　　　　system.out.println("error setting up socket connection: " + e);
　　　　}
　　}
　　public void teardownconnection() {
　　　　try {
　　　　　　socketwriter.close();
　　　　　　socketreader.close();
　　　　} catch (ioexception e) {
　　　　　　system.out.println("error tearing down socket connection: " + e);
　　　　}
　　}
}

　　好了,现在来看服务器端的程序怎么写.

　　创建remoteclientserver类：

import java.io.*;
import java.net.*;

public class remotefileserver {
　　protected int listenport = 3000;
　　public static void main(string[] args) {
　　}
　　public void acceptconnections() {
　　}
　　public void handleconnection(socket incomingconnection) {
　　}
}

　　跟客户机中一样，首先导入 java.net 的 java.io。接着,给我们的类一个实例变量以保存端口,我们从该端口侦听进入的连接。缺省情况下，端口是 3000。

acceptconnections()将允许客户机连接到服务器
handleconnection()负责与客户机 socket 交互以将您所请求的文件的内容发送到客户机。

　　首先看main()

public static void main(string[] args) {
　　remotefileserver server = new remotefileserver();
　　server.acceptconnections();
}

　　非常简单,因为主函数无非是让服务器进入监听状态,所以直接调用acceptconnection().需要注意的是,必须先创建remotefileserver()的实例,而不是直接调用.

　　那么服务器是怎样通过acceptconnection()来监听客户机的连接呢？并且如果兼听到了，又怎样处理呢？我们来看

public void acceptconnections() {
　　try {
　　　　serversocket server = new serversocket(listenport);//同客户机的socket对应,在服务器端,我们需要serversocket对象,参数是兼听的端口号
　　　　socket incomingconnection = null;//创建一个客户端的socket变量,以接收从客户端监听到的socket
　　　　while (true) {
　　　　　　incomingconnection = server.accept();//调用该 serversocket 的 accept() 来告诉它开始侦听,
　　　　　　handleconnection(incomingconnection);
　　　　}
file&://不/断监听直到来了一个连接请求,然后交由handleconnection处理
　　} catch (bindexception e) {
　　　　system.out.println("unable to bind to port " + listenport);
　　} catch (ioexception e) {
　　　　system.out.println("unable to instantiate a serversocket on port: " + listenport);
　　}
}

　　无论何时如果创建了一个无法绑定到指定端口（可能是因为别的什么控制了该端口）的 serversocket，java 代码都将抛出一个错误。所以这里我们必须捕捉可能的 bindexception。同时，与在客户机端上时一样，我们必须捕捉 ioexception，当我们试图在 serversocket 上接受连接时，它就会被抛出。可以通过用毫秒数调用 setsotimeout() 来为 accept() 调用设置超时，以避免实际长时间的等待。调用 setsotimeout() 将使 accept() 经过指定占用时间后抛出 ioexception

　　最关键的处理在handleconnection()中，这时已经连接到了客户端的socket，要从该socket中读取客户端的请求并且响应。

public void handleconnection(socket incomingconnection) {
　　try {
　　　　outputstream outputtosocket = incomingconnection.getoutputstream();
　　　　inputstream inputfromsocket = incomingconnection.getinputstream();

file&://首/先获取同socket相关联的流outputtosocket和inputstream
file&://其/中outputtosocket是要返回给客户端socket的流
file&://inputstream/是客户端发来的请求,在这里就是文件路径,即"remotefile.txt"

　　　　bufferedreader streamreader =
　　　　　　new bufferedreader(new inputstreamreader(inputfromsocket));

file&://首/先要将inputstream转换到bufferedreader中

　　　　filereader filereader = new filereader(new file(streamreader.readline()));
file&://从/bufferedreader中读出文件路径,建立新对象filereader

　　　　bufferedreader bufferedfilereader = new bufferedreader(filereader);

file&://再/次建立bufferedreader对象，这一次它读取得是文件里面的内容

　　　　printwriter streamwriter =
　　　　　　new printwriter(outputstream);

file&://把/socket的outputtosocket流包装进printwriter 以使我们能够发送文件信息到客户端

　　　　string line = null;
　　　　while ((line = bufferedfilereader.readline()) != null) {
　　　　　　streamwriter.println(line);
　　　　}
file&://从/bufferedfilereader中读出文件信息，再经由streamwriter输出到客户端

　　　　filereader.close();
　　　　streamwriter.close();//注意socket的两个流关闭的顺序
　　　　streamreader.close();
file&://完/成之后关闭所有流

　　} catch (exception e) {
　　　　system.out.println("error handling a client: " + e);
　　}
}


　　请注意完成所有操作之后关闭流的顺序，streamwriter的关闭在streamreader的关闭之前。这不是偶然的,假如将关闭次序颠倒过来,客户端将不会获取到任何文件信息,你可以调试一下看看.这是为什么呢?原因是如果你在关闭 streamwriter 之前关闭 streamreader，则你可以以往 streamwriter中写任何东西，但没有任何数据可以通过通道（通道被关闭了）.但奇怪的是,我不是已经在之前的streamwriter.println()中输出了吗?难道非要等到所有的流关闭之后输出到客户端的信息的东西才能到达?我试着将

streamwriter.close();
streamreader.close();

　　屏蔽掉，看是否依然能够实现正常的通信,结果发现不行,程序死机.可能是因为通道没有闭合导致的.那么至少可以说明,只有将通道按某种顺序正常关闭,才能完成通讯数据的传输,否则客户端收不到信息.

　　最后依然是总结一下创建服务器端程序的步骤

　　1.用一个你想让它侦听传入客户机连接的端口(比如程序中的3000)来实例化一个 serversocket（如有问题则抛出 exception）。

　　2.循环调用serversocket的accept()以监听连接

　　3.获取客户端的socket流以进行读写操作

　　4.包装流

　　5.对客户端的socket进行读写

　　6.关闭打开的流(切记,永远不要在关闭 writer 之前关闭 reader),完成通信

　　下面是

remotefileserver 的代码清单

import java.io.*;
import java.net.*;

public class remotefileserver {
　　int listenport;
　　public remotefileserver(int alistenport) {
　　　　listenport = alistenport;
　　}
　　public void acceptconnections() {
　　　　try {
　　　　　　serversocket server = new serversocket(listenport);
　　　　　　socket incomingconnection = null;
　　　　　　while (true) {
　　　　　　　　incomingconnection = server.accept();
　　　　　　　　handleconnection(incomingconnection);
　　　　　　}
　　　　} catch (bindexception e) {
　　　　　　system.out.println("unable to bind to port " + listenport);
　　　　} catch (ioexception e) {
　　　　　　system.out.println("unable to instantiate a serversocket on port: " + listenport);
　　　　}
　　}
　　public void handleconnection(socket incomingconnection) {
　　　　try {
　　　　　　outputstream outputtosocket = incomingconnection.getoutputstream();
　　　　　　inputstream inputfromsocket = incomingconnection.getinputstream();

　　　　　　bufferedreader streamreader = new bufferedreader(new inputstreamreader(inputfromsocket));

　　　　　　filereader filereader = new filereader(new file(streamreader.readline()));

　　　　　　bufferedreader bufferedfilereader = new bufferedreader(filereader);
　　　　　　printwriter streamwriter = new printwriter(outputtosocket);
　　　　　　string line = null;
　　　　　　while ((line = bufferedfilereader.readline()) != null) {
　　　　　　　　streamwriter.println(line);
　　　　　　}

　　　　　　filereader.close();
　　　　　　streamwriter.close();
　　　　　　streamreader.close();
　　　　} catch (exception e) {
　　　　　　system.out.println("error handling a client: " + e);
　　　　}
　　}
　　public static void main(string[] args) {
　　　　remotefileserver server = new remotefileserver(3000);
　　　　server.acceptconnections();
　　}
}