java语言程序设计基础篇练习答案

01

publicclassE*ercise13_01{

publicstaticvoidmain(String[]args){

TriangleNewtriangle=newTriangleNew(1,1.5,1);

triangle.setColor("yellow");

triangle.setFilled(true);

System.out.println(triangle);

System.out.println("Theareais"+triangle.getArea());

System.out.println("Theperimeteris"

+triangle.getPerimeter());

System.out.println(triangle);

}

}

classTriangleNewe*tendsGeometricObject{

privatedoubleside1=1.0,side2=1.0,side3=1.0;

/**Constructor*/

publicTriangleNew(){

}

/**Constructor*/

publicTriangleNew(doubleside1,doubleside2,doubleside3){

this.side1=side1;

this.side2=side2;

this.side3=side3;

}

/**ImplementtheabstractmethodfindAreainGeometricObject*/

publicdoublegetArea(){

doubles=(side1+side2+side3)/2;

returnMath.sqrt(s*(s-side1)*(s-side2)*(s-side3));

}

/**ImplementtheabstractmethodfindCircumferencein

*GeometricObject

**/

publicdoublegetPerimeter(){

returnside1+side2+side3;

}

Override

publicStringtoString(){

//Implementittoreturnthethreesides

return"TriangleNew:side1="+side1+"side2="+side2+

"side3="+side3;

}

}

02

importjava.util.ArrayList;

publicclassE*ercise13_02{

publicstaticvoidmain(String[]args){

ArrayList<Number>list=newArrayList<Number>();

list.add(14);

list.add(24);

list.add(4);

list.add(42);

list.add(5);

shuffle(list);

for(inti=0;i<list.size();i++)

System.out.print(list.get(i)+"");

}

publicstaticvoidshuffle(ArrayList<Number>list){

for(inti=0;i<list.size()-1;i++){

intinde*=(int)(Math.random()*list.size());

Numbertemp=list.get(i);

list.set(i,list.get(inde*));

list.set(inde*,temp);

}

}

}

03

importjava.util.ArrayList;

publicclassE*ercise13_03{

publicstaticvoidmain(String[]args){

ArrayList<Number>list=newArrayList<Number>();

list.add(14);

list.add(24);

list.add(4);

list.add(42);

list.add(5);

sort(list);

for(inti=0;i<list.size();i++)

System.out.print(list.get(i)+"");

}

publicstaticvoidsort(ArrayList<Number>list){

for(inti=0;i<list.size()-1;i++){

//Findtheminimuminthelist[i..list.length-1]

NumbercurrentMin=list.get(i);

intcurrentMinInde*=i;

for(intj=i+1;j<list.size();j++){

if(currentMin.doubleValue()>list.get(j).doubleValue()){

currentMin=list.get(j);

currentMinInde*=j;

}

}

//Swaplist.get(i)withlist.get(currentMinInde*)ifnecessary;

if(currentMinInde*!=i){

list.set(currentMinInde*,list.get(i));

list.set(i,currentMin);

}

}

}

}

04

importjava.util.*;

publicclassE*ercise13_04{

staticMyCalendarcalendar=newMyCalendar();

publicstaticvoidmain(String[]args){

intmonth=calendar.get(MyCalendar.MONTH)+1;

intyear=calendar.get(MyCalendar.YEAR);

if(args.length>2)

System.out.println("UsagejavaE*ercise13_04monthyear");

elseif(args.length==2){

//useuser-definedmonthandyear

year=Integer.parseInt(args[1]);

month=Integer.parseInt(args[0]);

calendar.set(Calendar.YEAR,year);

calendar.set(Calendar.MONTH,month-1);

}

elseif(args.length==1){

//useuser-definedmonthforthecurrentyear

month=Integer.parseInt(args[0]);

calendar.set(Calendar.MONTH,month-1);

}

//setdatetothefirstdayinamonth

calendar.set(Calendar.DATE,1);

//printcalendarforthemonth

printMonth(year,month);

}

staticvoidprintMonth(intyear,intmonth){

//getstartdayoftheweekforthefirstdateinthemonth

intstartDay=getStartDay();

//getnumberofdaysinthemonth

intnumOfDaysInMonth=calendar.daysInMonth();

//printheadings

printMonthTitle(year,month);

//printbody

printMonthBody(startDay,numOfDaysInMonth);

}

staticintgetStartDay(){

returncalendar.get(Calendar.DAY_OF_WEEK);

}

staticvoidprintMonthBody(intstartDay,intnumOfDaysInMonth){

//printpaddingspacebeforethefirstdayofthemonth

inti=0;

for(i=0;i<startDay-1;i++)

System.out.print("");

for(i=1;i<=numOfDaysInMonth;i++){

if(i<10)

System.out.print(""+i);

else

System.out.print(""+i);

if((i+startDay-1)%7==0)

System.out.println();

}

System.out.println("");

}

staticvoidprintMonthTitle(intyear,intmonth){

System.out.println(""+calendar.getMonthName()+","+year);

System.out.println("-----------------------------");

System.out.println("SunMonTueWedThuFriSat");

}

}

05

publicclassE*ercise13_05{

//Mainmethod

publicstaticvoidmain(String[]args){

//Createtwoparablecircles

Circle1circle1=newCircle1(5);

Circle1circle2=newCircle1(4);

//Displaythema*circle

Circle1circle=(Circle1)GeometricObject1.ma*(circle1,circle2);

System.out.println("Thema*circle'sradiusis"+circle.getRadius());

System.out.println(circle);

}

}

abstractclassGeometricObject1implementsparable<GeometricObject1>{

protectedStringcolor;

protecteddoubleweight;

//Defaultconstruct

protectedGeometricObject1(){

color="white";

weight=1.0;

}

//Constructageometricobject

protectedGeometricObject1(Stringcolor,doubleweight){

this.color=color;

this.weight=weight;

}

//Gettermethodforcolor

publicStringgetColor(){

returncolor;

}

//Settermethodforcolor

publicvoidsetColor(Stringcolor){

this.color=color;

}

//Gettermethodforweight

publicdoublegetWeight(){

returnweight;

}

//Settermethodforweight

publicvoidsetWeight(doubleweight){

this.weight=weight;

}

//Abstractmethod

publicabstractdoublegetArea();

//Abstractmethod

publicabstractdoublegetPerimeter();

publicintpareTo(GeometricObject1o){

if(getArea()<o.getArea())

return-1;

elseif(getArea()==o.getArea())

return0;

else

return1;

}

publicstaticGeometricObject1ma*(GeometricObject1o1,GeometricObject1o2){

if(o1.pareTo(o2)>0)

returno1;

else

returno2;

}

}

//Circle.java:Thecircleclassthate*tendsGeometricObject

classCircle1e*tendsGeometricObject1{

protecteddoubleradius;

//Defaultconstructor

publicCircle1(){

this(1.0,"white",1.0);

}

//Constructcirclewithspecifiedradius

publicCircle1(doubleradius){

super("white",1.0);

this.radius=radius;

}

//Constructacirclewithspecifiedradius,weight,andcolor

publicCircle1(doubleradius,Stringcolor,doubleweight){

super(color,weight);

this.radius=radius;

}

//Gettermethodforradius

publicdoublegetRadius(){

returnradius;

}

//Settermethodforradius

publicvoidsetRadius(doubleradius){

this.radius=radius;

}

//ImplementthefindAreamethoddefinedinGeometricObject

publicdoublegetArea(){

returnradius*radius*Math.PI;

}

//ImplementthefindPerimetermethoddefinedinGeometricObject

publicdoublegetPerimeter(){

return2*radius*Math.PI;

}

//Overridetheequals()methoddefinedintheObjectclass

publicbooleanequals(Circle1circle){

returnthis.radius==circle.getRadius();

}

Override

publicStringtoString(){

return"[Circle]radius="+radius;

}

Override

publicintpareTo(GeometricObject1o){

if(getRadius()>((Circle1)o).getRadius())

return1;

elseif(getRadius()<((Circle1)o).getRadius())

return-1;

else

return0;

}

}

06

publicclassE*ercise13_06{

//Mainmethod

publicstaticvoidmain(String[]args){

//Createtwoarablerectangles

parableCirclecircle1=newparableCircle(5);

parableCirclecircle2=newparableCircle(15);

//Displaythema*rect

parableCirclecircle3=(parableCircle)Ma*.ma*(circle1,circle2);

System.out.println("Thema*circle'sradiusis"+circle3.getRadius());

System.out.println(circle3);

}

}

classparableCirclee*tendsCircleimplementsparable<parableCircle>{

/**ConstructaparableRectanglewithspecifiedproperties*/

publicparableCircle(doubleradius){

super(radius);

}

Override

publicintpareTo(parableCircleo){

if(getRadius()>o.getRadius())

return1;

elseif(getRadius()<o.getRadius())

return-1;

else

return0;

}

}

//Ma*.java:Findama*imumobject

classMa*{

/**Returnthema*imumoftwoobjects*/

publicstaticparableCirclema*

(parableCircleo1,parableCircleo2){

if(o1.pareTo(o2)>0)

returno1;

else

returno2;

}

}

07

publicclassE*ercise13_07{

publicstaticvoidmain(String[]args){

GeometricObject[]objects={newSquare(2),newCircle(5),newSquare(5),newRectangle(3,4),newSquare(4.5)};

for(inti=0;i<objects.length;i++){

System.out.println("Areais"+objects[i].getArea());

if(objects[i]instanceofColorable)

((Colorable)objects[i]).howToColor();

}

}

}

interfaceColorable{

voidhowToColor();

}

classSquaree*tendsGeometricObjectimplementsColorable{

privatedoubleside;

publicSquare(doubleside){

this.side=side;

}

Override

publicvoidhowToColor(){

System.out.println("Colorallfoursides");

}

Override

publicdoublegetArea(){

returnside*side;

}

Override

publicdoublegetPerimeter(){

return4*side;

}

}

08

importjava.util.ArrayList;

publicclassE*ercise13_08{

publicstaticvoidmain(String[]args){

MyStack1stack=newMyStack1();

stack.push("S1");

stack.push("S2");

stack.push("S");

MyStack1stack2=(MyStack1)(stack.clone());

stack2.push("S1");

stack2.push("S2");

stack2.push("S");

System.out.println(stack.getSize());

System.out.println(stack2.getSize());

}

}

classMyStack1implementsCloneable{

privateArrayList<Object>list=newArrayList<Object>();

publicbooleanisEmpty(){

returnlist.isEmpty();

}

publicintgetSize(){

returnlist.size();

}

publicObjectpeek(){

returnlist.get(getSize()-1);

}

publicObjectpop(){

Objecto=list.get(getSize()-1);

list.remove(getSize()-1);

returno;

}

publicvoidpush(Objecto){

list.add(o);

}

/**OverridethetoStringintheObjectclass*/

publicStringtoString(){

return"stack:"+list.toString();

}

publicObjectclone(){

try{

MyStack1c=(MyStack1)super.clone();

c.list=(ArrayList<Object>)this.list.clone();

returnc;

}catch(CloneNotSupportedE*ceptione*){

returnnull;

}

}

}

09

publicclassE*ercise13_09{

publicstaticvoidmain(String[]args){

Circle13_09obj1=newCircle13_09();

Circle13_09obj2=newCircle13_09();

System.out.println(obj1.equals(obj2));

System.out.println(obj1.pareTo(obj2));

}

}

//Circle.java:Thecircleclassthate*tendsGeometricObject

classCircle13_09e*tendsGeometricObjectimplementsparable<Circle13_09>{

privatedoubleradius;

/**Returnradius*/

publicdoublegetRadius(){

returnradius;

}

/**Setanewradius*/

publicvoidsetRadius(doubleradius){

this.radius=radius;

}

/**ImplementthegetAreamethoddefinedinGeometricObject*/

publicdoublegetArea(){

returnradius*radius*Math.PI;

}

/**ImplementthegetPerimetermethoddefinedinGeometricObject*/

publicdoublegetPerimeter(){

return2*radius*Math.PI;

}

Override

publicStringtoString(){

return"[Circle]radius="+radius;

}

Override

publicintpareTo(Circle13_09obj){

if(this.getArea()>obj.getArea())

return1;

elseif(this.getArea()<obj.getArea())

return-1;

else

return0;

}

publicbooleanequals(Objectobj){

returnthis.radius==((Circle13_09)obj).radius;

}

}

10

publicclassE*ercise13_10{

publicstaticvoidmain(String[]args){

Rectangle13_10obj1=newRectangle13_10();

Rectangle13_10obj2=newRectangle13_10();

System.out.println(obj1.equals(obj2));

System.out.println(obj1.pareTo(obj2));

}

}

//Rectangle.java:TheRectangleclassthate*tendsGeometricObject

classRectangle13_10e*tendsGeometricObjectimplementsparable<Rectangle13_10>{

privatedoublewidth;

privatedoubleheight;

/**Defaultconstructor*/

publicRectangle13_10(){

this(1.0,1.0);

}

/**Constructarectanglewithwidthandheight*/

publicRectangle13_10(doublewidth,doubleheight){

this.width=width;

this.height=height;

}

/**Returnwidth*/

publicdoublegetWidth(){

returnwidth;

}

/**Setanewwidth*/

publicvoidsetWidth(doublewidth){

this.width=width;

}

/**Returnheight*/

publicdoublegetHeight(){

returnheight;

}

/**Setanewheight*/

publicvoidsetHeight(doubleheight){

this.height=height;

}

/**ImplementthegetAreamethodinGeometricObject*/

publicdoublegetArea(){

returnwidth*height;

}

/**ImplementthegetPerimetermethodinGeometricObject*/

publicdoublegetPerimeter(){

return2*(width+height);

}

Override

publicStringtoString(){

return"[Rectangle]width="+width+

"andheight="+height;

}

Override

publicintpareTo(Rectangle13_10obj){

if(this.getArea()>obj.getArea())

return1;

elseif(this.getArea()<obj.getArea())

return-1;

else

return0;

}

publicbooleanequals(Objectobj){

returnthis.getArea()==((Rectangle13_10)obj).getArea();

}

}

11

publicclassE*ercise13_11{

publicstaticvoidmain(String[]args){

Octagona1=newOctagon(5);

System.out.println("Areais"+a1.getArea());

System.out.println("Perimeteris"+a1.getPerimeter());

Octagona2=(Octagon)(a1.clone());

System.out.println("parethemethods"+a1.pareTo(a2));

}

}

classOctagone*tendsGeometricObject

implementsparable<Octagon>,Cloneable{

privatedoubleside;

/**ConstructaOctagonwiththedefaultside*/

publicOctagon(){

//Implementit

this.side=1;

}

/**ConstructaOctagonwiththespecifiedside*/

publicOctagon(doubleside){

//Implementit

this.side=side;

}

Override/**ImplementtheabstractmethodgetAreain

GeometricObject*/

publicdoublegetArea(){

//Implementit

return(2+4/Math.sqrt(2))*side*side;

}

Override/**ImplementtheabstractmethodgetPerimeterin

GeometricObject*/

publicdoublegetPerimeter(){

//Implementit

return8*side;

}

Override

publicintpareTo(Octagonobj){

if(this.side>obj.side)

return1;

elseif(this.side==obj.side)

return0;

else

return-1;

}

Override/**Implementtheclonemethodin

theObjectclass*/

publicObjectclone(){

//Octagono=newOctagon();

//o.side=this.side;

//returno;

//

//Implementit

try{

returnsuper.clone();//Automaticallyperformashallowcopy

}

catch(CloneNotSupportedE*ceptione*){

returnnull;

}

}

}

12

publicclassE*ercise13_12{

publicstaticvoidmain(String[]args){

newE*ercise13_12();

}

publicE*ercise13_12(){

GeometricObject[]a={newCircle(5),newCircle(6),

newRectangle13_12(2,3),newRectangle13_12(2,3)};

System.out.println("Thetotalareais"+sumArea(a));

}

publicstaticdoublesumArea(GeometricObject[]a){

doublesum=0;

for(inti=0;i<a.length;i++)

sum+=a[i].getArea();

returnsum;

}

}

//Rectangle.java:TheRectangleclassthate*tendsGeometricObject

classRectangle13_12e*tendsGeometricObject{

privatedoublewidth;

privatedoubleheight;

/**Constructarectanglewithwidthandheight*/

publicRectangle13_12(doublewidth,doubleheight){

this.width=width;

this.height=height;

}

/**Returnwidth*/

publicdoublegetWidth(){

returnwidth;

}

/**Setanewwidth*/

publicvoidsetWidth(doublewidth){

this.width=width;

}

/**Returnheight*/

publicdoublegetHeight(){

returnheight;

}

/**Setanewheight*/

publicvoidsetHeight(doubleheight){

this.height=height;

}

/**ImplementthegetAreamethodinGeometricObject*/

publicdoublegetArea(){

returnwidth*height;

}

/**ImplementthegetPerimetermethodinGeometricObject*/

publicdoublegetPerimeter(){

return2*(width+height);

}

/**OverridetheequalsmethoddefinedintheObjectclass*/

publicbooleanequals(Rectanglerectangle){

return(width==rectangle.getWidth())&&

(height==rectangle.getHeight());

}

Override

publicStringtoString(){

return"[Rectangle]width="+width+

"andheight="+height;

}

}

13

publicclassE*ercise13_13{

/**Mainmethod*/

publicstaticvoidmain(String[]args){

Course1course1=newCourse1("DS");

course1.addStudent("S1");

course1.addStudent("S2");

course1.addStudent("S3");

Course1course2=(Course1)course1.clone();

course2.addStudent("S4");

course2.addStudent("S5");

course2.addStudent("S6");

System.out.println(course1.getNumberOfStudents());

System.out.println(course2.getNumberOfStudents());

}

}

classCourse1implementsCloneable{

privateStringcourseName;

privateString[]students=newString[100];

privateintnumberOfStudents;

publicCourse1(StringcourseName){

this.courseName=courseName;

}

publicvoidaddStudent(Stringstudent){

students[numberOfStudents]=student;

numberOfStudents++;

}

publicString[]getStudents(){

returnstudents;

}

publicintgetNumberOfStudents(){

returnnumberOfStudents;

}

publicStringgetCourse1Name(){

returncourseName;

}

publicvoiddropStudent(Stringstudent){

//Leftasane*erciseinE*ercise10.9

}

publicObjectclone(){

try{

Course1c=(Course1)super.clone();

c.students=newString[100];

System.arraycopy(students,0,c.students,0,100);

c.numberOfStudents=numberOfStudents;

returnc;

}catch(CloneNotSupportedE*ceptione*){

returnnull;

}

}

}

14

classNewRationale*tendsNumberimplementsparable<NewRational>{

//Datafieldsfornumeratoranddenominator

privatelong[]r=newlong[2];

/**Defaultconstructor*/

publicNewRational(){

this(0,1);

}

/**Constructarationalwithspecifiednumeratoranddenominator*/

publicNewRational(longnumerator,longdenominator){

longgcd=gcd(numerator,denominator);

this.r[0]=numerator/gcd;

this.r[1]=denominator/gcd;

}

/**FindGCDoftwonumbers*/

privatelonggcd(longn,longd){

longt1=Math.abs(n);

longt2=Math.abs(d);

longremainder=t1%t2;

while(remainder!=0){

t1=t2;

t2=remainder;

remainder=t1%t2;

}

returnt2;

}

/**Returnnumerator*/

publiclonggetNumerator(){

returnr[0];

}

/**Returndenominator*/

publiclonggetDenominator(){

returnr[1];

}

/**Addarationalnumbertothisrational*/

publicNewRationaladd(NewRationalsecondNewRational){

longn=r[0]*secondNewRational.getDenominator()+

r[1]*secondNewRational.getNumerator();

longd=r[1]*secondNewRational.getDenominator();

returnnewNewRational(n,d);

}

/**Subtractarationalnumberfromthisrational*/

publicNewRationalsubtract(NewRationalsecondNewRational){

longn=r[0]*secondNewRational.getDenominator()

-r[1]*secondNewRational.getNumerator();

longd=r[1]*secondNewRational.getDenominator();

returnnewNewRational(n,d);

}

/**Multiplyarationalnumbertothisrational*/

publicNewRationalmultiply(NewRationalsecondNewRational){

longn=r[0]*secondNewRational.getNumerator();

longd=r[1]*secondNewRational.getDenominator();

returnnewNewRational(n,d);

}

/**Dividearationalnumberfromthisrational*/

publicNewRationaldivide(NewRationalsecondNewRational){

longn=r[0]*secondNewRational.getDenominator();

longd=r[1]*secondNewRational.r[0];

returnnewNewRational(n,d);

}

Override

publicStringtoString(){

if(r[1]==1)

returnr[0]+"";

else

returnr[0]+"/"+r[1];

}

/**Overridetheequalsmethod*/

publicbooleanequals(Objectparm1){

/**todo:Overridethisjava.lang.Objectmethod*/

if((this.subtract((NewRational)(parm1))).getNumerator()==0)

returntrue;

else

returnfalse;

}

/**OverridetheintValuemethod*/

publicintintValue(){

/**todo:implementthisjava.lang.Numberabstractmethod*/

return(int)doubleValue();

}

/**OverridethefloatValuemethod*/

publicfloatfloatValue(){

/**todo:implementthisjava.lang.Numberabstractmethod*/

return(float)doubleValue();

}

/**OverridethedoubleValuemethod*/

publicdoubledoubleValue(){

/**todo:implementthisjava.lang.Numberabstractmethod*/

returnr[0]*1.0/r[1];

}

/**OverridethelongValuemethod*/

publiclonglongValue(){

/**todo:implementthisjava.lang.Numberabstractmethod*/

return(long)doubleValue();

}

Override

publicintpareTo(NewRationalo){

/**todo:Implementthisjava.lang.parablemethod*/

if((this.subtract((NewRational)o)).getNumerator()>0)

return1;

elseif((this.subtract((NewRational)o)).getNumerator()<0)

return-1;

else

return0;

}

}

15

importjava.math.*;

publicclassE*ercise13_15{

publicstaticvoidmain(String[]args){

//Createandinitializetworationalnumbersr1andr2.

Rationalr1=newRational(newBigInteger("4"),newBigInteger("2"));

Rationalr2=newRational(newBigInteger("2"),newBigInteger("3"));

//Displayresults

System.out.println(r1+"+"+r2+"="+r1.add(r2));

System.out.println(r1+"-"+r2+"="+r1.subtract(r2));

System.out.println(r1+"*"+r2+"="+r1.multiply(r2));

System.out.println(r1+"/"+r2+"="+r1.divide(r2));

System.out.println(r2+"is"+r2.doubleValue());

}

staticclassRationale*tendsNumberimplementsparable<Rational>{

//Datafieldsfornumeratoranddenominator

privateBigIntegernumerator=BigInteger.ZERO;

privateBigIntegerdenominator=BigInteger.ONE;

/**Constructarationalwithdefaultproperties*/

publicRational(){

this(BigInteger.ZERO,BigInteger.ONE);

}

/**Constructarationalwithspecifiednumeratoranddenominator*/

publicRational(BigIntegernumerator,BigIntegerdenominator){

BigIntegergcd=gcd(numerator,denominator);

if(denominator.pareTo(BigInteger.ZERO)<0)

this.numerator=numerator.multiply(newBigInteger("-1")).divide(gcd);

else

this.numerator=numerator.divide(gcd);

this.denominator=denominator.abs().divide(gcd);

}

/**FindGCDoftwonumbers*/

privatestaticBigIntegergcd(BigIntegern,BigIntegerd){

BigIntegern1=n.abs();

BigIntegern2=d.abs();

BigIntegergcd=BigInteger.ONE;

for(BigIntegerk=BigInteger.ONE;

k.pareTo(n1)<=0&&k.pareTo(n2)<=0;

k=k.add(BigInteger.ONE)){

if(n1.remainder(k).equals(BigInteger.ZERO)&&

n2.remainder(k).equals(BigInteger.ZERO))

gcd=k;

}

returngcd;

}

/**Returnnumerator*/

publicBigIntegergetNumerator(){

returnnumerator;

}

/**Returndenominator*/

publicBigIntegergetDenominator(){

returndenominator;

}

/**Addarationalnumbertothisrational*/

publicRationaladd(RationalsecondRational){

BigIntegern=numerator.multiply(secondRational.getDenominator()).add(

denominator.multiply(secondRational.getNumerator()));

BigIntegerd=denominator.multiply(secondRational.getDenominator());

returnnewRational(n,d);

}

/**Subtractarationalnumberfromthisrational*/

publicRationalsubtract(RationalsecondRational){

BigIntegern=numerator.multiply(secondRational.getDenominator()).subtract(

denominator.multiply(secondRational.getNumerator()));

BigIntegerd=denominator.multiply(secondRational.getDenominator());

returnnewRational(n,d);

}

/**Multiplyarationalnumbertothisrational*/

publicRationalmultiply(RationalsecondRational){

BigIntegern=numerator.multiply(secondRational.getNumerator());

BigIntegerd=denominator.multiply(secondRational.getDenominator());

returnnewRational(n,d);

}

/**Dividearationalnumberfromthisrational*/

publicRationaldivide(RationalsecondRational){

BigIntegern=numerator.multiply(secondRational.getDenominator());

BigIntegerd=denominator.multiply(secondRational.numerator);

returnnewRational(n,d);

}

Override

publicStringtoString(){

if(denominator.equals(BigInteger.ONE))

returnnumerator+"";

else

returnnumerator+"/"+denominator;

}

Override/**OverridetheequalsmethodintheObjectclass*/

publicbooleanequals(Objectparm1){

if((this.subtract((Rational)(parm1))).getNumerator().equals(BigInteger.ONE))

returntrue;

else

returnfalse;

}

Override/**OverridethehashCodemethodintheObjectclass*/

publicinthashCode(){

returnnewDouble(this.doubleValue()).hashCode();

}

Override/**OverridetheabstractintValuemethodinjava.lang.Number*/

publicintintValue(){

return(int)doubleValue();

}

Override/**OverridetheabstractfloatValuemethodinjava.lang.Number*/

publicfloatfloatValue(){

return(float)doubleValue();

}

Override/**OverridethedoubleValuemethodinjava.lang.Number*/

publicdoubledoubleValue(){

returnnumerator.doubleValue()/denominator.doubleValue();

}

Override/**OverridetheabstractlongValuemethodinjava.lang.Number*/

publiclonglongValue(){

return(long)doubleValue();

}

Override

publicintpareTo(Rationalo){

if((this.subtract((Rational)o)).getNumerator().pareTo(BigInteger.ZERO)>0)

return1;

elseif((this.subtract((Rational)o)).getNumerator().pareTo(BigInteger.ZERO)<0)

return-1;

else

return0;

}

}

}

16

publicclassE*ercise13_1