System.out.print（"（"+c.getCurve（）[i].getX（）+","+c.getCurve（）[i].getY（）+"）to"）;
System.out.print（"（"+c.getCurve（）[n-1].getX（）+","+c.getCurve（）[n-1].getY（）+"）\n"）;
}
}
2.接口
⑴接口的概念和用途
当硬件厂商要在外设与主机之间建立一种新的接口时，必须首先定义该接口的规范（如形状、引脚数、各引脚的功能、电压、信号交换方式等）并进行文字说明，例如USB接口，无论鼠标、打印机还是优盘，当且仅当其满足了所定义的接口规范时，才能够将自己连接到计算机上。
面向对象的“接口”（interface）意义也在于此。
只不过定义的是方法的接口规范，程序员需按照该规范去实现和调用相应的方法。
⑵接口的定义和实现
接口定义与类定义相似，不同点如下：
a.接口是以关键字interface代替class来声明；
b.接口中的属性默认有publicfinalstatic修饰符，即接口中的属性全都是常量；
c.接口中的方法默认有publicabstract修饰符，即全都为公有，且为抽象，即只有声明、没有实现，主要作用是用来定义其实现和调用的规范。
接口定义的语法为：
访问权限interface接口名{
属性和方法声明
}
既然接口中的方法默认为abstract，则它们必须被其它类的方法来实现，实现接口的类在类名之后必须有“implements接口名”:
访问权限class类名implements接口名{
属性和方法定义
}
并且实现接口的方法必须为public，例如：
interfacesortable{//定义接口
booleanlessThan（sortables）;
}
classPointimplementssortable{//实现接口
publicbooleanlessThan（sortables）{
returnthis.x<（（Point）s）.x;
}
}
接口不可以被类继承，但可以被接口继承，从而当父接口中方法的实现和调用规范需要更新时，可直接在父接口之上继承一个子接口，保留原接口规范、定义新的接口规范即可，而不必从头定义一个接口，例如：
interfaceUSB1{
属性和方法声明
}
interfaceUSB2extendsUSB1{
增加的属性和方法声明
}
虽然Java不支持多继承（即一个类继承多个类），但支持一个类实现多个接口，例如：
interfaceSortable0{//比较两对象大小的方法接口
booleanlessThan（Sortable0s）;
}
interfaceSortable1{//交换两对象数据的方法接口
voidswap（Sortable1s）;
}
classPointimemplentsSortable0,Sortable1{//一个类实现两个接口
publicbooleanlessThan（Sortable0s）{
returnthis.x<（（Point）s）.x;
}
publicvoidswap（Sortable1s）{
inttmpX=this.x;
inttmpY=this.y;
this.x=（（Point）s）.x;
this.y=（（Point）s）.y;
（（Point）s）.x=tmpX;
（（Point）s）.y=tmpY;
}
}
⑶接口实例
//以下接口定义了2个方法的规范，它有助于实现对任意类型节点数组的排序操作
interfaceSortable{
booleanlessThan（Sortables）;
voidswap（Sortables）;
}
//整型节点类对Sortable的实现
classIntimplementsSortable{
privateinti;
Int（inti）{
this.i=i;
}
Int（）{}
voidsetInt（inti）{
this.i=i;
}
intgetInt（）{
returni;
}
publicbooleanlessThan（Sortables）{
returnthis.i<（（Int）s）.i;
}
publicvoidswap（Sortables）{
inttmp=this.i;
this.i=（（Int）s）.i;
（（Int）s）.i=tmp;
}
}
//双精度节点类对Sortable的实现
classDblimplementsSortable{
privatedoubled;
Dbl（doubled）{
this.d=d;
}
Dbl（）{}
voidsetDbl（doubled）{
this.d=d;
}
doublegetDbl（）{
returnd;
}
publicbooleanlessThan（Sortables）{
returnthis.d<（（Dbl）s）.d;
}
publicvoidswap（Sortables）{
doubletmp=this.d;
this.d=（（Dbl）s）.d;
（（Dbl）s）.d=tmp;
}
}
//平面坐标节点类对Sortable的实现
classPointimplementsSortable{
privateintx,y;
Point（intx,inty）{
this.x=x;
this.y=y;
}
Point（Pointp）{
this.x=p.x;
this.y=p.y;
}
Point（）{}
voidsetPoint（intx,inty）{
this.x=x;
this.y=y;
}
intgetX（）{returnx;}
intgetY（）{returny;}
PointgetPoint（）{returnthis;}
publicbooleanlessThan（Sortables）{
returnthis.x<（（Point）s）.x;
}
publicvoidswap（Sortables）{
inttmpX=this.x;
inttmpY=this.y;
this.x=（（Point）s）.x;
this.y=（（Point）s）.y;
（（Point）s）.x=tmpX;
（（Point）s）.y=tmpY;
}
}
//对整型数组元素排序
classInts{
privateInt[]a;
intn;
Ints（Int[]a,intn）{
this.a=newInt[n];
for（inti=0;ithis.a[i]=newInt（a[i].getInt（））;
}
this.n=n;
}
Ints（intn）{
this.a=newInt[n];
for（inti=0;ithis.a[i]=newInt（）;
}
this.n=n;
}
voidSetInts（Int[]a,intn）{
for（inti=0;ithis.a[i].setInt（a[i].getInt（））;
this.n=n;
}
Int[]getInts（）{
returna;
}
intgetN（）{
returnn;
}
voidbubbleSort（）{
for（inti=n;i>1;i--）{
for（intj=1;jif（a[j-1].lessThan（a[j]））{
a[j-1].swap（a[j]）;
}
}
}
}
}
//对双精度数组元素排序
classDbls{
privateDbl[]a;
intn;
Dbls（Dbl[]a,intn）{
this.a=newDbl[n];
for（inti=0;ithis.a[i]=newDbl（a[i].getDbl（））;
}
this.n=n;
}
Dbls（intn）{
this.a=newDbl[n];
for（inti=0;ithis.a[i]=newDbl（）;
}
this.n=n;
}
voidSetDbls（Dbl[]a,intn）{
for（inti=0;ithis.a[i].setDbl（a[i].getDbl（））;
this.n=n;
}
Dbl[]getDbls（）{
returna;
}
intgetN（）{
returnn;
}
voidbubbleSort（）{
for（inti=n;i>1;i--）{
for（intj=1;jif（a[j-1].lessThan（a[j]））{
a[j-1].swap（a[j]）;
}
}
}
}
}
//对平面坐标数组元素排序
classPoints{
privatePoint[]a;
intn;
Points（Point[]a,intn）{
this.a=newPoint[n];
for（inti=0;ithis.a[i]=newPoint（a[i]）;
this.n=n;
}
Points（intn）{
this.a=newPoint[n];
for（inti=0;ithis.a[i]=newPoint（）;
this.n=n;
}
voidSetPoints（Point[]a,intn）{
for（inti=0;ithis.a[i].setPoint（a[i].getX（）,a[i].getY（））;
this.n=n;
}
Point[]getPoints（）{returna;}
intgetN（）{returnn;}
publicvoidbubbleSort（）{
for（inti=n;i>1;i--）{
for（intj=1;jif（a[j-1].lessThan（a[j]））
a[j-1].swap（a[j]）;
}
}
}
}
//测试程序
publicclassUseInterface{
publicstaticvoidmain（String[]args）{
intn=10;
Int[]I=newInt[n];
for（inti=0;iI[i]=newInt（i）;
}
Intsis=newInts（I,n）;
for（inti=0;iSystem.out.println（is.getInts（）[i].getInt（））;
}
is.bubbleSort（）;
for（inti=0;iSystem.out.println（is.getInts（）[i].getInt（））;
}
Dbl[]D=newDbl[n];
for（inti=0;iD[i]=newDbl（i）;
}
Dblsds=newDbls（D,n）;
for（inti=0;iSystem.out.println（ds.getDbls（）[i].getDbl（））;
}
ds.bubbleSort（）;
for（inti=0;iSystem.out.println（ds.getDbls（）[i].getDbl（））;
}
Point[]P=newPoint[n];
for（inti=0;iP[i]=newPoint（i,i）;
}
Pointsps=newPoints（P,n）;
for（inti=0;iSystem.out.println（ps.getPoints（）[i].getX（）+""+ps.getPoints（）[i].getY（））;
}
ps.bubbleSort（）;
for（inti=0;iSystem.out.println（ps.getPoints（）[i].getX（）+""+ps.getPoints（）[i].getY（））;
}
ps.SetPoints（P,n）;
for（inti=0;iSystem.out.println（ps.getPoints（）[i].getX（）+""+ps.getPoints（）[i].getY（））;
}
}
}
3.异常处理
⑴异常处理的概念
异常是指那些编程时可以预测、程序运行时可以处理的错误，例如除数为零、对负数取对数等。
Ｃ语言处理异常的办法往往是让被调函数返回一个特殊值（例如-1）、让主调函数打印错误信息并进行适当处理（退出或恢复），因此Ｃ语言的系统函数通常都是有返值函数（如printf）。
在本来就是有返值函数的情况下，则只能人为设置一些特殊值（如整数-9999、浮点数-1.e38等等）让主调函数来识别。
这种机制显然十分牵强，如下例：
#includ
升级会员 