intn=a[j];a[j]=a[i];a[i]=n;}}}
System.out.printf（"%d,%d,%d,%d,%d",a[0],a[1],
a[2],a[3],a[4]）;
}
}
第四章类与对象
1.在声明类时，类名应遵循哪些习惯？
答：
首字母大写，望名知意
2.类体内容有哪两种重要成员？
答：
成员变量，和成员方法。
3。
实例方法可以操作类变量吗？
类方法可以操作实例变量吗？
答：
实例方法可以操作类变量。
而类方法不可以操作实例变量。
4.当类的字节码加载到内存时，类变量就一定分配了内存空间吗？
答：
实例成员变量不分配内存，而类变量一定分配内存。
5.类的实例变量在什么时候分配内存？
答:
声明之后，在用new关键字创建实例的时候才分配内存。
6.一个类的类变量被该类创建的所有对象共享吗？
答：
共享
7.不同对象的实例变量分配的内存地址一定不同吗？
答：
当出现引用赋值语句时两个实例变量的内存地址相同。
8.什么叫方法的重载？
构造方法可以重载吗？
答：
方法的重载是指一个类中可以有多个方法具有相同的名字，但这些方法的参数不同，或者参数的个数不同，或者参数的类型不同。
构造方法可以重载。
9.请阐述为什么类方法不能调用实例方法？
答：
对于类方法在该类加到内存时就分配了相应的入口地址，所以即使该类未创建对象，也可以通过类名调用类方法。
而这时在类对象创建之前，实例方法还没有入口地址。
还不知道一个方法从何处开始执行，当然不能调用。
10.请阐述，为什么类方法中不能操作实例成员变量？
答：
对于类方法在该类加到内存时就分配了相应的入口地址，所以即使该类未创建对象，也可以通过类名调用类方法。
而这时在类创建之前，实例成员变量还没有分配内存空间。
没内存空间当然无法操作。
11.实例方法可以用类名直接调用吗？
答：
不能，因为实例方法，用new创佳对象后才分配入口地址，而类名，一经声明就分配类名地址。
而这时对象创建之前实例方法还没有入口地址。
实例方法表现实例的功能，或改变实例变量。
用类调用改变那个实例的实例变量，表现那个实例的功能，不明确。
12.关键字this可以出现在构造方法中吗？
可以出现在实例方法中吗？
可以出现在类方法中吗？
答：
可以出现在构造方法中，代表该类构造方法所创造出的对象。
可以出现在实例方法中，代表使用该方法的当前对象。
This不能出现在类方法中，因为类方法是通过类名调用的。
13.源文件声明编写的类一定在同一个包中吗？
答：
不一定，当不在同一包中时，可用import语句将其所在的包引入该源文件中。
14.“importjava.awt.*”与“importjava.awt.Button”有什么不同？
答：
前者引入了awt包中的所有类，后者只引入了Button一个类。
15.程序中使用了“importjava.util.*;”程序运行时，是要加载java.util包中的全部类到内存吗？
答：
不，只加载本程序用到的类到内存中，因为java程序是动态加载，字节码类文件。
16.有哪几种访问权限修饰符？
说出一种的作用。
答：
访问权限修饰符有public,private,protected.
Private作用是只允许本类的对象访问。
17.怎样反编译一个类？
答:
使用SDK提供的反编译器javap.exe文件可以实现将字节码文件反编译为源码文件。
可查看源码中public方法和public成员变量的名字。
如加入参数-private则可列出其全部的成员方法和成员变量。
如：
Javap–privatejava.awt.Button则可以列出Button类中全部的方法和成员变量。
18.下面程序中那个语句是错的？
classA
{
privatefloatweight;//weight被修饰为private的float型变量。
publicfloatf（floata,floatb）//方法f是public方法。
{returna;}}
publicclassB
{
voidg（）
{
Aa=newA（）;
a.weight=23f;
a.f（3,4）;
}}
答：
a.weight=23f;错
1.编写一个类，该类创建的对象可以计算等差数列的和。
解：
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;
}
}
publicclassZuoYe04_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））;
DengChaarithmetical=newDengCha（）;
ScannerReader=newScanner（System.in）;
System.out.println（"请输入等差数列开始值"）;
arithmetical.start=Reader.nextInt（）;
System.out.println（"请输入等差数列的差值"）;
arithmetical.d=Reader.nextInt（）;
System.out.println（"请输入等差数列求和的个数"）;
intn=Reader.nextInt（）;
System.out.println（n+"个数的和是"+arithmetical.getSum（n））;
}
}
3.编写一个类，该类封装了一元二次方程的属性和功能，即该类有刻画方程系数的3个成员变量和求根的方法。
要求：
该类所有对象共享常数项。
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;
}
}
}
publicclassZuoYe4_3{
publicstaticvoidmain（Stringargs[]）{
SquareEquationequation1=newSquareEquation（4,5,1）;
SquareEquationequation2=newSquareEquation（3,5,-7）;
equation1.getRoots（）;
equation2.getRoots（）;
}
}
4.程序源文件Example.java如果使用了包语句，例如：
packagetom.jiafei;
并且有c:
\1000\tom\jiafei的目录结构，并且将源文件编译后得到的全部字节码文件拷贝到目录c:
\1000\tom\jiafei中。
问在哪个目录中运行此文件，运行命令是什么？
答：
运行程序时必须到tom\jiafei的上一层目录1000中来运行，如：
c:
\1000\javatom.jiafei.Example
第五章继承、接口与泛型
1。
子类在什么情况下可以继承父类的友好成员？
答：
父子类在同一包中时子类可以继承父类的友好成员。
2。
子类通过什么办法，可以隐藏继承的成员变量。
答：
子类成员变量与父类成员变量同名。
3。
子类重写继承方法的规则是什么？
答：
重写隐藏父类的方法需：
返回的数据类型相同，参数的个数相同，并且类型相同。
如果重写父类的方法后参数的个数或类型不同会出现子类方法的重载。
4.子类的构造方法的第一条语句是什么？
答：
如果需要调用父类构造方法，则应是用super关键词调用父类的构造方法。
5。
子类一旦重写了继承的方法，就会隐藏继承的方法。
是这样吗？
答：
不一定。
在参数的个数或类型不同时会产生重载。
如果只有返回值的类型不同，将会产生编译错误。
（5）子类隐藏父类的方法，参数必须______相同并且__________相同.
答：
个数，类型
6。
子类重写继承方法时，可以降低方法的权限吗？
答：
重写继承方法时不能降低访问权限。
7。
简述关键字super的用法。
答：
1）子类调用父类的构造方法。
2）子类对象引用被隐藏了的父类方法，或成员变量。
8.假设父类有一个方法：
Publicdoublef（doublex,doubley）{
returnx+y;
}
是否允许子类再声明如下的方法：
Publicfloatf（doublex,doubley）{
return23;
}
答：
不允许。
9。
父类的final方法可以被子类重写吗？
答：
不可以
10。
什么类中可以有abstract方法？
答：
被abstract修饰的类。
接口中也可以有abstract方法
11。
什么叫做对象的上转型对象？
答：
用子类的构造方法构造出来的对象，赋值给父类对象。
12。
什么叫接口回调？
答：
用实现接口的类创建的对象，赋值给该接口声明的接口变量。
13。
与类有关的匿名类一定是该类的子类吗？
与接口有关的匿名类一定是实现该接口的一个类吗？
答：
一定，因为类创建对象时，除了构造方法还有类体，此类体被认为是该类的一个子类去掉类声明后的类体。
即匿名类，匿名类就是一个子类。
与接口的匿名类相同。
一定是子类。
14。
怎样声明一个泛型类？
答：
我们可以这样声明一个泛型类：
classA其中A时泛型的名称，E是其中的泛型，即我们没有指定E是何种类型的数据，它可以是任何对象或接口，但不能是基本数据类型。
15阅读下列程序，并说明输出结果。
classNegativeIntegerExceptionextendsException{
Stringmessage;
publicNegativeIntegerException（）{
message="方法的参数值不是正整数";
}
publicStringtoString（）{
returnmessage;
}
}
classMaxCommonDivisor{
publicintgetMaxCommonDivisor（inta,intb）throwsNegativeIntegerException{
if（a<0||b<0）
thrownewNegativeIntegerException（）;
intr=0;
if（a>b）{
intt=a;a=b;b=t;
}
r=a%b;
while（r!
=0）{
a=b;
b=r;
r=a%b;
}
returnb;
}
}
classMinCommonMultipleextendsMaxCommonDivisor{
publicintgetMinCommonMultiple（inta,intb）throwsNegativeIntegerException{
if（a<0||b<0）
thrownewNegativeIntegerException（）;
inty=0;
intx=getMaxCommonDivisor（a,b）;
y=（a*b）/x;
returny;
}
}
publicclassExample{
publicstaticvoidmain（Stringarg[]）{
intmaxCommonDivisor,minCommonMultiple;
MaxCommonDivisormax=newMaxCommonDivisor（）;
MinCommonMultiplemin=newMinCommonMultiple（）;
try{
maxCommonDivisor=max.getMaxCommonDivisor（18,12）;
System.out.println（"最大公约数：
"+maxCommonDivisor）;
minCommonMultiple=min.getMinCommonMultiple（18,12）;
System.out.println（"最小公倍数：
"+minCommonMultiple）;
maxCommonDivisor=max.getMaxCommonDivisor（-64,48）;
System.out.println（"最大公约数：
"+maxCommonDivisor）;
}
catch（NegativeIntegerExceptione）{
System.out.println（e.toString（））;
}
}
}
3。
编写一个类要求实现一个接口，该接口有3个abstract方法：
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.ou
升级会员 