System.out.print（""+（char）i）;}
}
}
4.用户从键盘只能输入整数，程序输出这些整数的乘积。
importjava.util.*;
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
Scannerreader=newScanner（System.in）;
longs=1;
intm=0;
while（reader.hasNextInt（））{
intx=reader.nextInt（）;
m=m+1;
s=s*x;}
System.out.println（m+"个数的乘积为"+s）;}
}
5.有一函数：
从键盘输入一个X值，程序输出Y值。
importjava.util.*;
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
Scannerreader=newScanner（System.in）;
doubley=0,x=0;
x=reader.nextDouble（）;
if（x<0）
y=-1+2*x;
elseif（x==0）
y=-1;
elseif（x>0）
y=-1+3*x;
System.out.println（（int）y）;}
}
6.使用while循环计算1~1000之间能被3和7同时整除的整数之和。
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
intsum=0,m=3,n=7,a=1;
while（a<=1000）{
if（a%m==0&&a%n==0）
sum=sum+a;
a++;}
System.out.println（"sum="+sum）;}
}
7.编写一个Java应用程序，使用for循环计算8+88+888+8888+88888+…的前10项之和。
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
longsum=0,a=8,item=a,i=1;
for（i=1;i<=10;i++）
{sum=sum+item;
item=item*10+a;}
System.out.println（sum）;}
}
8.编写一个Java应用程序，计算1-1/3+1/5-1/7+1/9-1/11+…的前10000项之和。
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
doublesum=0,a=1,b=1,f=1,item=a/b;
inti=1;
while（i<=1000）
{sum=sum+f*item;
i++;
f=f*（-1）;
b=b+2;
item=a/b;}
System.out.println（"sum="+sum）;}
}
9.编写一个Java应用程序，计算1+2！
+3！
+4！
+…从100项到200项之和。
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
doublesum=0,a=1;
inti=1;
while（i<=20）
{if（i>=10）
sum=sum+a;
i++;
a=a*i;}
System.out.println（"sum="+sum）;}
}
10.编写一个类，该类创建的对象可以计算等差数列的和。
classDengCha{
intstart,d;
DengCha（）{}
DengCha（intstart,intd）{
this.start=start;
this.d=d;}
voidsetStart（ints）{
start=s;}
voidsetD（intd）{
this.d=d;}
intgetSum（intn）{
intsum=0,i=1;
while（i<=n）{
sum=sum+start;
start=start+d;
i++;}
returnsum;}
}
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
DengChashulie=newDengCha（2,3）;
System.out.println（shulie.getSum（100））;
shulie.setStart（10）;
shulie.setD（5）;System.out.println（shulie.getSum（9））;}
}
11.编一个类，该类创建的对象可以输出英文字母表。
classLetter{
publicvoidprintLetter（）{
for（charc='a';c<='z';c++）
System.out.print（""+c）;}
}
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
Letterp=newLetter（）;
p.printLetter（）;}
}
12.编一个类，该类封装了一元二次方程共有的属性和功能，即该类有刻画方程系数的三个成员变量以及计算实根的方法。
要求：
该类的所有对象共享常数项。
classSquareEquation{
doublea,b;
staticdoublec;
doubleroot1,root2;
booleanboo;
publicSquareEquation（doublea,doubleb,doublec）{
this.a=a;
this.b=b;
SquareEquation.c=c;
if（a!
=0）{boo=true;}
else{boo=false;}
}
publicvoidgetRoots（）{
if（boo）{
System.out.println（"是一元2次方程"）;
doubledisk=b*b-4*a*c;
if（disk>=0）{
root1=（-b+Math.sqrt（disk））/（2*a）;root2=（-b-Math.sqrt（disk））/（2*a）;
System.out.printf（"方程的根:
%f,%f\n",root1,root2）;
}
else{
System.out.printf（"方程没有实根\n"）;}
}
else{
System.out.println（"不是一元2次方程"）;}
}
publicvoidsetCoefficient（doublea,doubleb,doublec）{
this.a=a;
this.b=b;
SquareEquation.c=c;
if（a!
=0）{boo=true;}
else{boo=false;}
}
}
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
SquareEquationequation1=newSquareEquation（4,5,1）;
SquareEquationequation2=newSquareEquation（3,5,-7）;
equation1.getRoots（）;
equation2.getRoots（）;}
}
13.编写两个类，A和B，类A创建的对象可以计算两个正整数的最大公约数，类B创建的对象可以计算两个书的最小公倍数。
要求：
类B中有一个成员变量是用类A的声明对象。
importjava.util.Scanner;
classA{
intf（intm,intn）{
if（m*n<0）
{System.out.println（"有负数，程序退出"）;
System.exit（0）;}
if（m{inttemp=m;
m=n;
n=temp;}
inta=m,b=n;
intr=m%n;
while（r!
=0）
{m=n;
n=r;
r=m%n;}
returnn;}
}
classB{
Aa;
B（）{
a=newA（）;}
intg（intm,intn）{
inttemp=a.f（m,n）;
returnm*n/temp;}
}
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
Scannerreader=newScanner（System.in）;
System.out.println（"输入2个正整数,程序计算出它们的最大公约数和最小公倍数"）;
System.out.print（"输入第一个整数:
"）;
intm=reader.nextInt（）;
System.out.print（"输入第二个整数:
"）;
intn=reader.nextInt（）;
Aa=newA（）;
Bb=newB（）;
System.out.println（m+"和"+n+"的最大公约数是"+a.f（m,n））;
System.out.println（m+"和"+n+"的最小公倍数是"+b.g（m,n））;}}
14.编写使用了包语句的类，然后在应用程序中用import语句引入该类，并用该类创建对象。
importjava.applet.Applet;
importjava.awt.*;
publicclassZuoYe2_1extendsApplet{
Buttonredbutton;
publicvoidinit（）{
redbutton=newButton（"我是一个红色的按钮"）;redbutton.setBackground（Color.red）;
redbutton.setForeground（Color.white）;
add（redbutton）;}
}
15.编写一个类，该类有一个方法
Publicintf（inta,intb）{
//要求该方法返回a和b的最大公约数｝
然后编写一个该类的子类，要求子类重写方法f（），而且重写的方法将返回两个整数的最小公倍数。
要求：
在成功写的方法的方法体中首先调用被隐藏的方法返回a和b的最大公约数m，然后将（a*b）/m返回；在应用的程序的主类中分别使用父类和子类创建对象，并分别调用方法f（）计算两个正整数的最大公约数和最小公倍数。
importjava.util.Scanner;
classA{
publicintf（intm,intn）{
if（minttemp=m;
m=n;
n=temp;}
intr=m%n;
while（r!
=0）{
m=n;
n=r;
r=m%n;}
returnn;}
}
classBextendsA{
publicintf（intm,intn）{
intdivision=super.f（m,n）;
return（m*n）/division;}
}
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
Aa=newA（）;
Bb=newB（）;
Scannerreader=newScanner（System.in）;
System.out.println（"输入2个整数,程序计算出它们的最大公约数和最小公倍数"）;
System.out.print（"输入第一个整数:
"）;
intm=reader.nextInt（）;
System.out.print（"输入第二个整数:
"）;
intn=reader.nextInt（）;
if（m*n<0）
{System.out.println（"有负数，程序退出"）;
System.exit（0）;}
System.out.printf（"%d和%d的最大公约数是%d\n",m,n,a.f（m,n））;
System.out.printf（"%d和%d的最小公倍数是%d\n",m,n,b.f（m,n））;}
}
16.首先编写一个抽象类，要求该类有如下3个抽象方法：
Publicabstractvoidf（intx）;
Publicabstractvoidg（intx.inty）;
Publicabstractdoubleh（doublex）;
然后分别给出该类的3个子类。
要求：
在应用程序的主类中使用这些子类创建对象，然后让它们的上转型对象调用方法：
f（）,g（）和h（）。
abstractclassA{
publicabstractvoidf（intx）;
publicabstractvoidg（intx,inty）;
publicabstractdoubleh（doublex）;}
classA1extendsA{
publicvoidf（intx）{
System.out.println（x）;}
publicvoidg（intx,inty）{
intz=x+y;
System.out.println（z）;}
publicdoubleh（doublex）{
returnx*x;}
}
classA2extendsA{
publicvoidf（intx）{
System.out.println（"Hello:
"+x）;}
publicvoidg（intx,inty）{
intz=x-y;
System.out.println（z）;}
publicdoubleh（doublex）{
returnMath.sqrt（x）;}
}
classA3extendsA{
publicvoidf（intx）{
System.out.println（"你好:
"+x）;}
publicvoidg（intx,inty）{
doublez=（double）x/y;
System.out.println（z）;}
publicdoubleh（doublex）{
return1/x;}
}
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
Aa=newA1（）;
a.f（10）;
a.g（12,20）;
System.out.println（a.h（100））;
a=newA2（）;
a.f（10）;
a.g（12,20）;
System.out.println（a.h（100））;
a=newA3（）;
a.f（10）;
a.g（12,20）;
System.out.println（a.h（100））;}
}
17.编写一个类，要求该类实现一个接口，该接口有如下3个抽象方法：
Publicabstractvoidf（intx）;
Publicabstractvoidg（intx.inty）;
Publicabstractdoubleh（doublex）;
要求：
在应用程序的主类中使用该类创建对象，并使用接口回调来调用方法：
f（）,g（）和h（）。
interfaceA{
publicabstractvoidf（intx）;
publicabstractvoidg（intx,inty）;
publicabstractdoubleh（doublex）;}
classA1implementsA{
publicvoidf（intx）{
System.out.println（x）;}
publicvoidg（intx,inty）{
intz=x+y;
System.out.println（z）;}
publicdoubleh（doublex）{
returnx*x;}
}
classA2implementsA{
publicvoidf（intx）{
System.out.println（"Hello:
"+x）;}
publicvoidg（intx,inty）{
intz=x-y;
System.out.println（z）;}
publicdoubleh（doublex）{
returnMath.sqrt（x）;}
}
classA3implementsA{
publicvoidf（intx）{
System.out.println（"你好:
"+x）;}
publicvoidg（intx,inty）{
doublez=（double）x/y;
System.out.println（z）;}
publicdoubleh（doublex）{
return1/x;}
}
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
Aa=newA1（）;
a.f（10）;
a.g（12,20）;
System.out.println（a.h（100））;
a=newA2（）;
a.f（10）;
a.g（12,20）;
System.out.println（a.h（100））;
a=newA3（）;
a.f（10）;
a.g（12,20）;
System.out.println（a.h（100））;
}
}
18.举例说明匿名类的用法。
classCubic{
doublegetCubic（intn）
{return0;}
}
abstractclassSqrt{
publicabstractdoublegetSqrt（intx）;}
classA{
voidf（Cubiccubic）{
doubleresult=cubic.getCubic（3）;
System.out.println（result）;}
}
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）{
Aa=newA（）;
a.f（newCubic（）
{doublegetCubic（intn）
{returnn*n*n;}
}）;
Sqrtss=newSqrt（）
{publicdoublegetSqrt（intx）
{returnMath.sqrt（x）;}
};
doublem=ss.getSqrt（5）;
System.out.println（m）;}
}
19.编写一个异常类，并具体给出一个产生该异常的方法。
在一个应用程序中测试该异常类。
classIntegerExceptionextendsException
{Stringmessage;
IntegerException（intm）
{message="年龄"+m+"不合理";}
publicStringtoString（）
{returnmessage;}
}
classPeople
{privateintage=1;
publicvoidsetAge（intage）throwsIntegerException{
if（age>=160||age<=0）
thrownewIntegerException（age）;
else
this.age=age;}
publicintgetAge（）
{System.out.println（"年龄"+age+"合理"）;
returnage;}
}
publicclassZuoYe2_1{
publicstaticvoidmain（Stringargs[]）
{Peoplewang=newPeople（）,
zhang=newPeople（）;
try{wang.setAge（189）;System.out.println（wang.getAge（））;}
catch（IntegerExceptione）
{System.out.println（e.toString（））;}
try{zhang.setAge（28）;System.out.println（zhang.getAge（））;}
catch（In
升级会员 