Java上机练习题

Java 复习题

第一章

1、分别用Java应用程序和Java小程序编写程序：在屏幕上输出“Hello，欢迎来到精彩的

Java世界！”。

程序：①应用程序：HelloWorld1.java

②小程序：HelloWorld.java和A.htm

Java 应用程序：

《HelloWorld1.java》

public class HelloWorld1{

public static void main(String[] args){

System.out.println("Hello，欢迎来到精彩的Java世界！");

}

}

Java 小程序：

《HelloWorld.java》

import java.applet.Applet;

import java.awt.Graphics;

public class HelloWorld extends Applet{

public void paint(Graphics g){

g.drawString("Hello，欢迎来到精彩的Java世界！",2,20);

}

}

《A.htm》

第二章

1、26页案例3：TriangleArea.java（三角形面积）

编写一个java程序，已知三角形三边边长，求三角形面积。要求三条边长从控制台输入。其中4,3,6分别代表三角形的三条边。

《TriangleArea.java》

public class TriangleArea{

public static void main(String[] args){

double a=Double.parseDouble(args[0]);

double b=Double.parseDouble(args[1]);

double c=Double.parseDouble(args[2]);

if(a+b<=c||a+c<=b||b+c<=a)

{

System.out.println("三条边长不符合三角形组成条件");

return;

}

double p=(a+b+c)/2; 周长新公式

double s=Math.sqrt(p*(p-a)*(p-b)*(p-c)); [Math.sqrt]开根号

System.out.println("三角形的三边分别为"+a+" "+b+" "+c+" ,");

System.out.println("计算后，面积为："+s);

}

}

第三章

1、36页案例4 闰年的判断：LeapYear.java(闰年)

闰年的判断条件是符合下面二者之一：能被4整除，但不能被100整除；能被4整除，又能被100整除。

《LeapYear.java》

public class LeapYear{

public static void main(String[] args){

int year,leap;

year=2010;

if(year%4==0){

if(year%100==0){

if(year%400==0)

leap=1;

else

leap=0;

}else

leap=1;

} else

leap=0;

if(leap==1)

System.out.println("2010年是闰年");

else

System.out.println("2010年不是闰年");

}

}

2、编写程序，实现下面的要求：将输入的数字1~7分别转化成英文的星期一至星期日（Monday~Sunday）。如果输入的数字不是1~7，则输出“您输入的数字超出范围（1~7）了，请重新输入！”：NumbertoWeek.java

《NumbertoWeek.java》

public class NumbertoWeek{

public static void main(String[] args){

int x=Integer.parseInt(args[0]);

String n="";

switch(x){

case 1:

n="Monday";

break;

case 2:

n="Tuesday";

break;

case 3:

n="Wednesday";

break;

case 4:

n="Thursday";

break;

case5:

n="Friday";

break;

case6:

n="Saturday";

break;

case7:

n="Sunday";

break;

default:

n="您输入的数字超出范围（1~7）了，请重新输入！";

}

System.out.println(n);

}

}

3、42页案例5 水仙花数：Narcissus.java（水仙花）

求三位水仙花数。水仙花数是指一个n位数（n>=3）,它的每个位上的数字的n次幂之和等于它本身，也叫纳西赛斯数。如三位数153，1^3+5^3+3^3的结果为153，四位数1634,1^4+6^4+3^4+4^4结果为1643.

《Narcissus.java》

public class Narcissus{

public static void main(String[] args){

for(int i=100;i<1000;i++)

{

int a=i/100;

int b=i%100/10;

int c=i%10;

if(i==cube(a)+cube(b)+cube(c)) [cube:立方]

{

System.out.println(i);

}

}

}

public static int cube(int value)

{

return value*value*value;

}

}

4、47页四（1）：device.java

编写程序，采用适当的循环和控制流语句实现下述功能：打印输出0~200能被7整除但不能被4整除的所有整数；要求每行显示6个数据。

《device.java》

public class device{

public static void main(String args[]){

int i=0;

int j=0;

for(i=0;i<=200;i++){

if(i%7==0&&i%4!=0){

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

j=j+1;

if(j%6==0)

{ System.out.println();}

}

}

}

}

5、47页四（3）：jiou.java

求1~100的所有奇数和偶数并打印输出。

《jiou.java》

public class jiou{

public static void main(String[] args){

int n;

int i=0;

System.out.println("1~100间的奇数为：");

for(n=1;n<=100;n++){

if(n%2!=0) {

System.out.print(n+"\t");

i=i+1;

if(i%6==0)

{ System.out.println(); }

}

}

System.out.println();

System.out.println("1~100间的偶数为：");

i=0;

for(n=1;n<=100;n++){

if(n%2==0) {

System.out.print(n+"\t");

i=i+1;

if(i%6==0)

{System.out.println();}

}

}

}

}

6、47页四（4）：oushuhe.java

试用for循环，计算2+4+6+…+n的总和。n=100。

《oushuhe.java》

public class oushuhe{

public static void main(String[] args){

int sum=0;

int i=2;

int n=100;

for(i=2;i<=n;i=i+2)

sum=sum+i;

System.out.println("2+4+6+……+n的总和"+sum);

}

}

7、47页四（5）：jiecheng.java

编写一个应用程序，计算1~10的各个整数的阶乘，并将结果输出到屏幕上。《jiecheng.java》

public class jiecheng{

public static void main(String[] args){

int n=1;

int ji=1;

for(n=1;n<=10;n++){

ji=ji*n;

System.out.println(n+"!="+ji);（例1！=1）

}

}

}

8、47页四（6）:用while语句编写程序1+2+3+…+100

《Test6.java》

public class Test6{

public static void main(String[] args){

int i=1;

int result=0;

while(i<=100){

result +=i;

i++;

}

System.out.println(result);

}

}

9、47页四（7）:对1~100的奇数进行求和（用for语句并利用continue语句）

《Test7.java》

public class Test7{

public static void main(String[] args){

int sum=0;

for(int i=0;i<=100;i++)

{

if(i%2==0)

continue;

sum=sum+i;

}

System.out.println("1~100中所有的奇数和为:" +sum);

}

}

第四章

1、48页案例6 评委打分：JuryScoring.java

学校举行学生技能大赛，比赛成绩由评委们所的分数决定。评分规则为：去掉一个最高分，再去掉一个最低分后的平均得分。根据评委们所给的分数，以控制台参数的形式输入，再由计算机算出这名参赛学生的比赛分数。

《JuryScoring.java》

public class JuryScoring{

public static final int JURY_COUNT=5;

public static void main(String[] args){

double[] scores=new double[JURY_COUNT];

if(args.length!=JURY_COUNT){

System.out.println("分数数量与评委人数不符，请重新执行！");

System.exit(0);

}

for(int i=0;i

scores[i]=Double.parseDouble(args[i]);

}

double max=scores[0];

double min=scores[0];

double avgScore=0.0;

for(int i=0;i

if(scores[i]>max){

max=scores[i];

}

if(scores[i]

min=scores[i];

}

}

double sum=0;

for(int i=0;i

sum+=scores[i];

}

avgScore=(sum-max-min)/(JURY_COUNT-2);

avgScore=Math.round(avgScore*100)/100.0;

System.out.println("去掉一个最高分 "+max+"分，去掉一个最低分 "+min+"分");

System.out.println("参赛学生最后得分为： "+avgScore);

}

}

2、53页冒泡法排序：BubbleSort.java（冒泡）

《BubbleSort.java》

public class BubbleSort{

public static void main(String[] args){

int[] arr={1,4,9,6,5,7,3,2};

for(int i=0;i

for(int j=0;j

if(arr[j]>arr[j+1]){

int temp;

temp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;

}

}

}

for(int i=0;i

System.out.print(arr[i]+" ");

}

}

}

3、编写Application，从命令行传入任意多个double型数据，求他们的最大值、最小值、平均值，并将它们按从小到大的顺序输出到屏幕上。

提示：用main方法的参数args数组接收输入的数据；接收的数据的个数为：args.length；

args数组的数据为String类型，使用Double.parseDouble()方法将其转换成

double型；排序采用冒泡排序：

《DataHandle.java》

public class DataHandle{

public static void main(String[] args){

int len=args.length;

double[] a=new double[len];

for(int i=0;i

a[i]=Double.parseDouble(args[i]);

}

double min=a[0];

double max=a[0];

double average=0.0;

for(int i=0;i

if(max

max=a[i];

if(min>a[i])

min=a[i];

}

double sum=0.0;

for(int i=0;i

sum=sum+a[i];

}

average=sum/len;

System.out.print("输入的数据为：");

for(int i=0;i

System.out.print(a[i]+"\t");

}

System.out.println();

System.out.println("最大数为"+max+"，最小数为"+min);

System.out.println("平均值为"+average);

}

}

4、编写应用程序，统计给定字符串中空格的个数：Space.java

《Space.java》

public class Space{

public static void main(String[] args){

String s="Twinkle twinkle little star How I wonder what you are !";

char c='\u0000';

int count=0;

int len=s.length();

for(int i=0;i

c=s.charAt(i);

if(c==' ')

count++;

}

System.out.println("字符串“"+s+"”有"+count+"个空格。");

}

}

5、编写应用程序，将给定字符串中的字符大写改小写，小写改大写：《Transformation.java》

public class Transformation{

public static void main(String[] args){

String s="Twinkle twinkle little star How I wonder what you are !";

StringBuffer sb=new StringBuffer();

char c='\u0000';

int k='a'-'A';

for(int i=0;i

c=s.charAt(i);

if(c>='a'&&c<='z')

c=(char)(c-k);

else if(c>='A'&&c<='Z')

c=(char)(c+k);

sb.append(c);

}

System.out.println("原来的字符串为："+s);

System.out.println("转化后的字符串为："+sb);

}

}

6、编写应用程序，在命令行输入以下格式的电话号码：3位区号和8位本地电话号码（电话号码的输入格式：xxx-xxxxxxxx或(xxx)xxxxxxxx）。使用字符串类的方法将区号和本地电话号码分别显示在屏幕上：PhoneNumber.java

《PhoneNumber.java》

public class PhoneNumber{

public static void main(String[] args){

String s=args[0];

int k=s.indexOf("-");

String area,phone;

if(k>0){

area=s.substring(0,3);

phone=s.substring(4);

}

else{

area=s.substring(1,4);

phone=s.substring(5);

}

System.out.println("电话号码"+s+"的区号为"+area+"，本地号码为"+phone+" 。");

}

}

7、给定字符串数组：String strings[]={"string","starting","strong","street","stir","studeng","soft","sting"

};编写应用程序，统计以st开头的字符串有多少个，以ng结尾的字符串有多少个：

《StartandEnd.java》

public class StartandEnd{

public static void main(String[] args){

String[]strings={"string","starting","strong","street","stir","studeng","sof t","sting"};

int count1=0;

int count2=0;

for(int i=0;i

if(strings[i].startsWith("st"))

count1++;

if(strings[i].endsWith("ng"))

count2++;

}

System.out.println("以st开头的字符串有"+count1+"个。");

System.out.println("以ng结尾的字符串有"+count2+"个。");

}

}

8、64页三（2）：编写一个程序，从键盘读入10个整数存入整型数组a中，然后逆序输出这10个整数。nixu.java \\ 逆序

《nixu.java》

public class nixu{

public static void main(String[] args){

final int LENGTH=10;

int[] a=new int[LENGTH];

if(args.length!=LENGTH){

System.out.println("输入数据个数不正确");

System.exit(0);

}

for(int i=0;i

a[i]=Integer.parseInt(args[i]);

}

System.out.println("逆序输出数组：");

for(int i=0;i

System.out.print(a[LENGTH-1-i]+",");

}

}

}

9、64页三（3）：某人又5张3分和4张5分的邮票，编写一个程序，计算由这些邮票中的1张或若干张可以得到多少种不同的邮资 Stamp.java

《Stamp.java》

import java.util.HashSet;

public class Stamp{

public static void main(String[] args){

int a=3,b=5;

int sum=0;

HashSet mSet=new HashSet();

for(int i=0;i<=5;i++){

for(int j=0;j<=4;j++){

if(i==0&&j==0) continue;

sum=a*i+b*j;

System.out.println("3分邮票"+i+"张和5分邮票"+j+"张的总邮资为"+sum+"分；");

mSet.add(sum);

}

}

System.out.println("综上所述，共有"+mSet.size()+"种邮资。");

}

}

第五章

1、定义一个描述长方形的类Box，类中有三个整型的成员变量：length，width和height，分别表示长方体的长、宽和高。定义构造函数，初始化这三个变量；定义方法求长方体的体积并返回整型结果；定义方法求长方体的表面积并返回整型结果；定义方法把长方体的长、宽和高，以及长方体的体积和表面积转化为字符串并返回字符串。编写应用程序或小程序，测试类Box，使用类中定义的各个方法，并将其结果输出。《Box.java》

《Box.java》

public class Box{

private int length;

private int width;

private int height;

public Box(int a,int b,int c){

length=a;

width=b;

height=c;

}

public int getVolume(){

return length*width*height;

}

public int getArea(){

return2*(length*width+length*height+width*height);

}

public String toString(){

return "长方体的长为"+length+"，宽为"+width+"，高为"+height+"，表面积为"+getArea()+"，体积为"+getVolume()+"。";

}

}

《TestBox.java》

public class TestBox{

public static void main(String[] s){

Box box=new Box(12,24,36);

System.out.println("Box的表面积是："+box.getArea());

System.out.println("Box的体积是："+box.getVolume());

System.out.println(box.toString());

}

}

2、定义一个类，类中有两个整型变量x和y，并定义构造函数初始化这两个变量。类中还定义以下方法：求两个数的和并返回结果，求两个数的差并返回结果，求两个数的乘积并返回结果，求两个数的商并返回结果，求两个数的余数并返回结果，求两个数的最大值并返回结果，求两个数最小值并返回结果。编写应用程序，测试上面定义的类，使用类中定义的各个方法并将其结果输出。

public class Intest{

int x;

int y;

public Intest(int x,int y){

this.x=x;

this.y=y;

}

public int plus(){

return x+y;

}

public int minus(){

return x-y;

}

public int mutiply(){

return x*y;

}

public int divide(){

return x/y;

}

public int mod(){

return x%y;

}

public int max(){

return x>y?x:y;

}

public int min(){

return x

}

}

《TestIntest.java》

public class TestIntest{

public static void main(String[] args){

Intest ic=new Intest(121,56);

System.out.println("两个数的和"+ic.plus());

System.out.println("两个数的差"+ic.minus());

System.out.println("两个数的商"+ic.multiply());

System.out.println("两个数的乘积"+ic.divide());

System.out.println("两个数的余数"+ic.mod());

System.out.println("两个数的最大值"+ic.max());

System.out.println("两个数的最小值"+ic.min());

}

}

3、定义一个描述平面坐标系统中的点及其操作的类Point。它有两个double型私有属性x 和y描述点在坐标系中的位置。该类还包含如下方法：初始化x和y的构造函数；返回x和y值的方法getX（）和getY（）；将给定坐标点平移w（水平）和h（垂直）的方法shiftPoint （double w，double h）；判断调用该方法的点的坐标和方法中的参数点的坐标是否相等的方法pointEquals（Point p）；判断点在第几象限的方法whatQuadrant（），并返回字符串描述；求给定参数点的距离的方法findDistance（Point p），返回结果保留两位小数；将点的坐标表示为字符串格式（x，y）的方法toString（）。编写应用程序或小程序，测试类Point，使用上面定义的各个方法并将其结果输出。

《Point.java》

public class Point{

private double x;

private double y;

public Point(double x,double y){

this.x=x;

this.y=y;

}

public double getX(){

return x;

}

public double getY(){

return y;

}

public Point shiftPoint(double w,double h){

x=x+w;

y+=h;

return this;

}

public boolean pointEquals(Point p){

if(p.x==x&&p.y==y)

return true;

else

return false;

}

public String whatQuadrant(){

int n=4;

if(x>=0&&y>=0) n=1;

else if(x<=0&&y>=0) n=2;

else if(x<=0&&y<=0) n=3;

return "当前的点在第"+n+"象限";

}

public double findDistance(Point p){

double d=Math.sqrt((p.x-x)*(p.x-x)+(p.y-y)*(p.y-y));

d=Math.round(d*100)/100.0;

return d;

}

public String toString(){

return "点的坐标是("+x+","+y+")";

}

}

《TestPoint.java》

public class TestPoint{

public static void main(String[] args){

Point p1=new Point(2.0,14.5);

Point p2=new Point(-1.0,10.0);

System.out.println(p1.getX());

System.out.println(p2.getY());

System.out.println(p1.shiftPoint(5.0,6.0));

System.out.println(p1.pointEquals(p2));

System.out.println(p2.whatQuadrant());

System.out.println(p1.findDistance(p2));

System.out.println(p1.toString());

System.out.println(p2.toString());

}

}

4、定义一个类，该类中有一个整型数组。类中定义一个方法随机生成一个元素值为三位正整数的数组，数组的元素的个数由参数指定。定义一个参数为整型数组的构造函数，

构造函数中调用上面定义的方法，初始化类中定义饿数组。此外，该类还包含以下方法：将类中定义的数组的所有元素在命令行输出的方法；判断数组元素有多少个偶数的方法，并返回偶数的个数。编写应用程序，使用类中定义的各个方法，将其结果输出。

《IntArray.java》

import java.util.Random;

public class IntArray{

int[] a;

public int[] getArray(int n){

Random r=new Random();

int[] array=new int[n];

for(int k=0;k

array[k]=r.nextInt(1000);//在>=0和<1000之间

}

return array;

}

public IntArray(int[] array){

a=array;

a=getArray(a.length);

}

public void printArray(){

for(int k=0;k

if(k%5==0)

System.out.println();

System.out.print(a[k]+" ");

}

System.out.println();

}

public int HowManyEven(){

int n=0;

for(int k=0;k

if(a[k]%2==0)

n++;

}

return n;

}

}

《TestIntArray.java》

public class TestIntArray{

public static void main(String[] args){

int[] array=new int[20];

IntArray ia=new IntArray(array);

ia.printArray();

System.out.println("数组中偶数的个数是: "+ia.HowManyEven());

}

}

5、编写一个类实现复数的运算。复数类Complex的属性有：

mReal：实部，代表复数的实数部分。

mImage：虚部，代表复数的虚数部分。

复数类Complex的方法有：

Complex（double r，double i）：构造函数，创建复数对象的同时完成复数的实部、虚部的初始化，r为实部的初值，i为虚部的初值。

getReal()：获得复数对象的实部。

getImage()：获得复数对象的虚部。

setReal(double d)：将当前复数对象的实部设置为给定的形式参数的值。

setReal(String s)：将当前复数对象的实部设置为给定的形式参数字符

串字面所代表的值。

setImage(double d)：将当前复数对象的虚部设置为给定的形式参数的值。

setImage(String s)：将当前复数对象的虚部设置为给定的形式参数字符

串字面所代表的值。

complexAdd(Complex c)：当前复数对象与形式参数复数对象相加，所得的

结果也是复数值，返回给此方法的调用者。

complexMinus(Complex c)：当前复数对象与形式参数复数对象相减，所得

的结果也是复数值，返回给此方法的调用者。

complexMul(Complex c)：当前复数对象与形式参数复数对象相乘，所得的

结果也是复数值，返回给此方法的调用者。

toString()：返回以字符串方式表示的复数，例如实部为3，虚部为5，则返

回字符串“3+5i”。

然后编写一个含有main方法的类，创建Complex对象并调用上面定义的方法。

《Complex.java》

public class Complex{

double mReal;

double mImage;

public Complex(double r,double i){

mReal=r ;

mImage=i;

}

public double getReal(){

return mReal;

}

public double getImage(){

return mImage;

}

public void setReal(double d){

mReal=d;

}

public void SetReal(String s){

mReal=Double.parseDouble(s);

}

public void setImage(double d){

mImage=d;

}

public void setImage(String s){

mImage=Double.parseDouble(s);

}

public Complex complexAdd(Complex c){

Complex s=new Complex(0,0);

s.mReal=mReal+c.mReal;

s.mImage=mImage+c.mImage;

return s;

}

public Complex complexMinus(Complex c){ Complex s=new Complex(0,0);

s.mReal=mReal-c.mReal;

s.mImage=mImage-c.mImage;

return s;

}

public Complex complexMul(Complex c){

Complex s=new Complex(0,0);

s.mReal= mReal*c.mReal-mImage*c.mImage; s.mImage=mReal*c.mImage+mImage*c.mReal;

return s;

}

public String toString(){

return mReal+"+"+mImage+"i";

}

}

《TestComplex.java》

public class TestComplex{

public static void main(String[] args){

Complex c=new Complex(3,5);

System.out.println("复数的实部是: "+c.getReal());

System.out.println("复数的虚部是: "+c.getImage());

c.setReal(7);

c.setImage("9");

System.out.println("新的复数为: "+c.toString());

Complex c1=new Complex(11,15);

System.out.println("两个复数的和是: "+https://www.360docs.net/doc/012180769.html,plexAdd(c1).toString());

System.out.println("两个复数的差是: "+https://www.360docs.net/doc/012180769.html,plexMinus(c1).toString());

System.out.println("两个复数的积是: "+https://www.360docs.net/doc/012180769.html,plexMul(c1).toString());

}

}

6、定义一个接口，接口中有三个抽象方法：long factorial(int n); //n的阶乘

long myPower(int m,int n); //m的n次方

boolean findFactorSum(int m, int n); //较小数是否是较大数的因子

编写一个类，类中有两个整形变量x和y，并定义构造函数初始化这两个变量。并且在这个类中实现该接口。编写应用程序，调用接口中的三个方法，并将调用这些方法得到的结果输出。

《DataInf.java》

public interface DataInf{

long factorial(int n); //n的阶乘

long myPower(int m,int n); //m的n次方

boolean findFactorSum(int m, int n); //较小数是否是较大数的

}

《Data.java》

public class Data implements DataInf{

int x;

int y;

public Data(int x,int y){

this.x=x;

this.y=y;

}

public long factorial(int n){

long fact=1;

if(n==0||n==1)

return1;

for(int k=2;k<=n;k++){

fact=fact*k;

}

return fact;

}

public long myPower(int m,int n){ //递归：自己调用自己，要有终结条件if(m==0) return0;

if(m==1||n==0) return1;

return m*myPower(m,n-1) ;

}

public boolean findFactorSum(int m, int n){

int max=m>n?m:n;

int min=m

if(max%min==0)

return true;

return false;

}

}

《TestData.java》

public class TestData{

public static void main(String[] args){

Data d=new Data(2,6);

System.out.println(d.factorial(6));

// System.out.println(d.factorial(d.x));

System.out.println(d.myPower(2,6));

// System.out.println(d.myPower(d.x,d.y));

if(d.findFactorSum(5,6))

System.out.println("较小数是较大数的因子。");

else

System.out.println("较小数不是较大数的因子。");

}

}

8、在屏幕上输出九九乘法表。如下所示：

1*1=1

2*1=2 2*2=4

3*1=3 3*2=6 3*3=9

……

9*1=9 9*2=18 9*3=27 ……9*9=81

《Multiply.java》

public class Multiply{

public static void main(String[] args){

int sum=0;

for(int i=1;i<=9;i++){

for(int j=1;j<=i;j++){

sum=i*j;

System.out.print(i+"*"+j+"="+sum+"\t");

}

System.out.println();

}

}

}