Java程序练习100题.docx

Java程序练习100题.docx

《Java程序练习100题.docx》由会员分享，可在线阅读，更多相关《Java程序练习100题.docx（98页珍藏版）》请在冰豆网上搜索。

Java程序练习100题

上机练习题

练习1（4）

1.取两个小于1000的正随机数，若两个数均小于10，先将它们都放大50倍，否则不改变这两个数最后，求这两个数的和并将结果输出。

要求这些输出结果仅保留小数点后4位（不需四捨五入）。

importjava.awt.*;

importjava.applet.*;

publicclassApplet1extendsApplet

{

publicvoidinit（）

{

Labelout1=newLabel（""）;

Labelout2=newLabel（""）;

doublex,y;

add（out1）;

add（out2）;

x=Math.random（）*1000;

y=Math.random（）*1000;

if（x<10&y<10）{x*=50;y*=50;}

out1.setText（""+x+"+"+y+"约等于"）;

out2.setText（""+（int）（（x+y）*10000）/10000.0）;

}

}

2.取一个小于10000的正随机整数，并输出该数的平方根。

要求这些输出结果在四捨五入后保留小数点后4位。

importjava.awt.*;

importjava.applet.*;

publicclassApplet1extendsApplet

{

publicvoidpaint（Graphicsg）

{

intk;

k=（int）（Math.random（）*1000）;

g.drawString（""+k+"的平方根约等于"+

（int）（（Math.sqrt（k）+0.00005）*10000）/10000.0,20,20）;

}

}

3.取一个50~200之间的正随机整数，如果该数为奇数则求它的平方根并转换成float型数后再输出；如果该数为偶数则求它的平方并输出。

importjava.awt.*;

importjava.applet.*;

publicclassApplet1extendsApplet

{

publicvoidpaint（Graphicsg）

{

intk;

k=50+（int）（Math.random（）*150）;

if（k%2!

=0）

g.drawString（""+k+"的平方根约等于"+（float）Math.sqrt（k）,20,20）;

else

g.drawString（""+k+"的平方等于"+k*k,20,20）;

}

}

4.取一个小于800的正随机整数，将其以如下形式输出：

所取随机数为：

***

它的百位数字为：

*

它的十位数字为：

*

它的个位数字为：

*

//importjava.io.*;

publicclassClass1

{

publicstaticvoidmain（String[]args）

{

intx=（int）（Math.random（）*800）;

System.out.println（"所取随机数为:

"+x）;

System.out.println（"它的百位数字为:

"+x/100）;

System.out.println（"它的十位数字为:

"+x%100/10）;

System.out.println（"它的个位数字为:

"+x%10）;

//try{System.in.read（）;}catch（IOExceptione）{}

}

}

练习2（5）

掌握：

（1）数组的定义、创建和初始化。

（2）方法的定义和调用。

（3）方法的参数是数组、方法的返回值是数组的编程。

（4）方法的递归调用。

（5）在应用程序中，接受并处理命令行参数。

1.请编写一个Applet,其中定义了两个double类型数组a和b，还定义了一个方法square（）。

数组a各元素的初值依次为1.2、2.3、3.4、4.5、5.6，数组b各元素的初值依次为9.8、8.7、7.6、6.5、5.4、4.3；方法square（）的参数为double类型的数组，返回值为float类型的数组,功能是将参数各元素的平方做为返回数组的元素的值。

请在方法paint（）中分别以a和b为实在参数调用方法square（），并将返回值输出在屏幕上。

要求调用square（a）的返回数组输出在Applet的一行上，数组的第一个元素的输出坐标为（20，20），其后的每个元素间隔40个像素。

调用square（b）的返回数组输出在Applet的一列上，即下标为i+1（i=0,1,2,3,......）的元素的值,在下标为i的元素的值的正下方，其返回数组的第一个元素的输出坐标为（20，40），行隔为20像素。

@程序

importjava.awt.*;

importjava.applet.*;

publicclassApplet1extendsApplet

{

doublea[]={1.2,2.3,3.4,4.5,5.6};

double[]b={9.8,8.7,7.6,6.5,5.4,4.3};

publicvoidpaint（Graphicsg）

{

float[]x=newfloat[a.length];

float[]y=newfloat[b.length];

x=square（a）;

y=square（b）;

for（inti=0;i

g.drawString（""+x[i],20+i*40,20）;

for（inti=0;i

g.drawString（""+y[i],20,40+i*20）;

}

float[]square（doublex[]）

{

float[]y=newfloat[x.length];

for（inti=0;i

y[i]=（float）（x[i]*x[i]）;

returny;

}

}

2.请编写一个Application实现如下功能：

在主类中定义两个double类型数组a和b，再定义一个方法sqrt_sum（）。

数组a各元素的初值依次为1.2、2.3、3.4、4.5、5.6，数组b各元素的初值依次为9.8、8.7、7.6、6.5、5.4、4.3；方法sqrt_sum（）的参数为double类型的数组，返回值类型为float型,功能是求参数各元素的平方根之和。

请在主方法main（）中分别以a和b为实在参数调用方法sqrt_sum（），并将返回值输出在屏幕上。

@程序

//importjava.io.*;

publicclassClass1

{

staticdoublea[]={1.2,2.3,3.4,4.5,5.6};

staticdoubleb[]={9.8,8.7,7.6,6.5,5.4,4.3};

publicstaticvoidmain（String[]args）

{

System.out.println（"数组a各元素的平方根之和为:

"+sqrt_sum（a））;

System.out.println（"数组b各元素的平方根之和为:

"+sqrt_sum（b））;

//try{charc=（char）System.in.read（）;}catch（IOExceptione）{}

}

staticfloatsqrt_sum（double[]x）

{

doubley=0.0;

for（inti=0;i

y+=Math.sqrt（x[i]）;

return（float）y;

}

}

3.请编写一个Application实现如下功能：

在主类中定义方法f1（intn）和方法f2（intn），它们的功能均为求n!

，方法f1（）用循环实现，方法f2（）用递归实现。

在主方法main（）中，以4为实在参数分别调用方法f1（）和方法f2（），并输出调用结果。

@程序

//importjava.io.*;

publicclassClass1

{

publicstaticvoidmain（String[]args）

{

System.out.println（"用循环实现求n!

的结果（n=4）:

"+f1（4））;

System.out.println（"用递归实现求n!

的结果（n=4）:

"+f2（4））;

//try{charc=（char）System.in.read（）;}catch（IOExceptione）{}

}

staticlongf1（intn）

{

longk=1;

for（inti=1;i<=n;i++）

k*=i;

returnk;

}

staticlongf2（intn）

{

if（n==1）return1;

elsereturnn*f2（n-1）;

}

}

4.请编写一个Application实现如下功能：

接受命令行中给出的三个参数x1、x2和op，其中x1和x2为float型数，op是某个算数运算符（+、—、*、/之一），请以如下形式输出x1和x2执行op运算后的结果（假设x1的值为269，x2的值为18，op为运算符—）：

269–18=251

@程序

publicclassClass1

{

publicstaticvoidmain（String[]args）

{

floatx,y;

charop;

if（args.length>=3）

{

x=Float.valueOf（args[0]）.floatValue（）;

y=Float.valueOf（args[1]）.floatValue（）;

op=args[2].charAt（0）;

switch（op）

{

case'+':

System.out.println（x+"+"+y+"="+（x+y））;break;

case'-':

System.out.println（x+"-"+y+"="+（x-y））;break;

case'*':

System.out.println（x+"*"+y+"="+（x*y））;break;

case'/':

System.out.println（x+"/"+y+"="+（x/y））;break;

default:

System.out.println（"非法运算符!

"）;

}

}

else{System.out.println（"命令行参数错!

"）;System.exit（-1）;}

}

}

5.编写Application，主类中包含以下两个自定义方法：

voidprintA（int[]array）和int[]myArray（intn）。

方法printA（int[]array）的功能是把参数数组各元素在屏幕的一行中输出。

方法myArray（intn）的功能是生成元素值是50~100之间的随机值的int型数组，数组元素的个数由参数n指定。

在应用程序的main（）方法中，用命令行传入的整数作为myArray（intn）方法调用时的实际参数，生成一个整型数组，并调用方法printA（）输出该数组的所有元素。

@程序

publicclassClass1

{

staticintn;

publicstaticvoidmain（String[]args）

{

if（args.length>0）

{

n=Integer.parseInt（args[0]）;

int[]a=newint[n];

a=myArray（n）;

printA（a）;

}

else{System.out.println（"缺命令行参数!

"）;System.exit（-1）;}

}

staticvoidprintA（int[]x）

{

for（inti=0;i

System.out.print（x[i]+""）;

System.out.println（）;

return;

}

staticint[]myArray（intk）

{

intx[]=newint[k];

for（inti=0;i

x[i]=50+（int）（Math.random（）*50）;

returnx;

}

}

练习3（3）

掌握：

方法的重载。

1.请编写一个Applet，其主类名为Applet1，其中包含两个同名方法arrayMin（）,它们都只有一个参数，其中一个arrayMin（）方法的参数为int型数组，返回值类型为int型数；另一个arrayMin（）方法的参数为double型数组，返回值类型为double型数；这两个方法的功能均为返回参数数组元素的最小值。

通过paint（）方法调用上述两个同名方法arrayMin（），求数组a（其元素的值依次为26，82，-3，65，18，9）和数组b（其元素的值依次为3.6，57.2，8.5，78.8）的最小元素的值并输出。

@程序

importjava.awt.*;

importjava.applet.*;

publicclassApplet1extendsApplet

{

inta[]={26,82,-3,65,18,9};

doubleb[]={3.6,57.2,8.5,78.8};

publicvoidpaint（Graphicsg）

{

g.drawString（"数组a的最小元素的值为:

"+arrayMin（a）,20,20）;

g.drawString（"数组b的最小元素的值为:

"+arrayMin（b）,20,40）;

}

intarrayMin（intx[]）

{

inty=x[0];

for（inti=1;ix[i]）y=x[i];

returny;

}

doublearrayMin（doublex[]）

{

doubley=x[0];

for（inti=1;ix[i]）y=x[i];

returny;

}

}

2.请编写一个Application，其主类名为Class1，其中包含三个同名方法mySqrt（），它们都只有一个参数，参数的类型分别为int型、float型和double型，它们的功能均为返回参数的平方根，返回值的类型与参数的类型相同。

在主方法main（）中调用上面的三个方法，这三个方法的参数均来自命令行参数，最后将计算结果输出在屏幕上。

@程序

publicclassClass1

{

staticintn;

publicstaticvoidmain（String[]args）

{

if（args.length>=3）

{

intn;

floatf;

doubled;

n=Integer.parseInt（args[0]）;

f=Float.valueOf（args[1]）.floatValue（）;

d=Double.valueOf（args[2]）.doubleValue（）;

System.out.println（n+"的平方根为:

"+mySqrt（n））;

System.out.println（f+"的平方根为:

"+mySqrt（f））;

System.out.println（d+"的平方根为:

"+mySqrt（d））;

}

else{System.out.println（"缺命令行参数!

"）;System.exit（-1）;}

}

staticintmySqrt（intx）

{return（int）Math.sqrt（x）;}

staticfloatmySqrt（floatx）

{return（float）Math.sqrt（x）;}

staticdoublemySqrt（doublex）

{returnMath.sqrt（x）;}

}

3.请编写一个Applet，其主类名为Applet1，其中包含三个同名方法addM（intx,bytey）、addM（floatx,doubley）、addM（doublex,doubley），它们的功能均为求两个参数之和，返回值类型与第一个参数的类型相同。

在主类Applet1中，通过paint（）方法调用上面的三个方法，实现12345+67、89.6f+6.9e-8、0.987654321+32.1，然后将计算结果输出，输出位置分别为坐标（20，40）、（20，60）、（20，80）。

@程序

importjava.awt.*;

importjava.applet.*;

publicclassApplet1extendsApplet

{

publicvoidpaint（Graphicsg）

{

g.drawString（"12345+67="+addM（12345,67）,20,40）;

g.drawString（"89.6+6.9e-8="+addM（89.6f,6.9e-8）,20,60）;

g.drawString（"0.987654321+32.1="+addM（0.987654321,32.1）,20,80）;

}

intaddM（intx,bytey）

{returnx+y;}

floataddM（floatx,doubley）

{return（float）（x+y）;}

doubleaddM（doublex,doubley）

{returnx+y;}

}

练习4（3）

掌握:

（1）类的继承。

（2）在子类中如何操作父类中的私有属性。

（3）变量的作用域。

1.请编写Applet，它由三个类定义组成，类名分别为A、B和Applet1：

类A中定义了一个类型为float的属性f和一个类型为byte的私有属性k；类A还定义了一个带有一个参数的构造函数（用于初始化f），和两个公共方法setk（）和getk（）,其中setk（）的功能为给私有属性k赋值,getk（）的功能为返回私有属性k的值。

类B是类A的子类，其中仅定义了一个类型为boolean的属性b和一个带两个参数的构造函数（用来为父类中的变量f和本类的变量b做初始化）。

主类Applet1中定义了一个初值为123的int型变量n和一个B类的对象x，请通过创建x为上述f和b赋值（f的值为68.963,b的值为true）;在paint（）方法中,给A类的私有属性k赋值66，然后显示f，k，b，n的值。

@程序

importjava.awt.*;

importjava.applet.*;

publicclassApplet1extendsApplet

{

intn=123;

Bx=newB（68.963f,true）;

publicvoidpaint（Graphicsg）

{

x.setk（（byte）66）;

g.drawString（"f="+x.f+"k="+x.getk（）+"b="+x.b+"n="+n,10,20）;

}

}

classA

{

floatf;

privatebytek;

A（floatf1）{f=f1;}

publicbytegetk（）{returnk;}

publicvoidsetk（bytem）{k=m;}

}

classBextendsA

{

booleanb;

B（floatff,booleanbb）{super（ff）;b=bb;}

}

2.请按如下要求定义两个类A和B,类A中定义一个double类型变量d（将其赋值为8.8）和一个方法int_d（doubledd），该方法的功能是返回参数dd的整数部分。

类B是类A的子类，其中定义一个float类型变量f（将其赋值为18.3）和一个方法int_f（floatff），该方法的功能是返回参数ff的整数部分。

编写一个Application，创建类B的对象b，在主方法main（）中先显示d和f的值，然后分别以d和f为实在参数调用int_d（）方法和int_f（）方法，并将它们的返回值显示在屏幕上。

@程序

publicclassClass1

{

publicstaticvoidmain（String[]args）

{

Bb=newB（）;

System.out.println（"d="+b.d+"f="+b.f）;

System.out.println（"d的整数部分="+b.int_d（b.d）+"f的整数部分="+b.int_f（b.f））;

}

}

classA

{

doubled=8.8;

intint_d（doubledd）{return（int）dd;}

}

classBextendsA

{

floatf=18.3f;

intint_f（floatff）{return（int）ff;}

}

3.请编写一个Application，在其主类中定义一个int类型变量i，并令其初值为123；主类中还定义了m1（）和m2（）等两个方法。

在主方法main（）和方法m1（）中也各定义一个int类型变量i，它们的初值分别为456和789；方法m1（）的功能是输出它的局部变量i的值；方法m2（）的功能是先输出类变量i的值，然后使类变量i增加值6后再次输出其值；主方法main（）的功能是先输出它的局部变量i的值，然后先后调用m1（）和m2（）实现它们的功能。

@程序