Java面试题程序相关

Java面试题总结一、选择题1．要创建一个类，下面的哪种定义方式是正确的？A．staticclassFooBar{} B．privateclassFooBar{}C．abstractclassFooBar{} D．finalabstractclassFooBar{}1．答案（C）A.用static可以修饰内部类，普通类是不允许声明为静态的，只有内部类才可以。被static修饰的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。B不能用protected和private修饰类。D.abstract修饰的类是用于继承的，而final修饰的类不能被继承，故final和abstract不能同时修饰类。

2．根据下面的代码，哪一个结论是正确的？

PublicclassTest{ PublicintMethodA(){ Staticinti=0; i++; returni; } }

A．编译失败 B．编译成功，并且返回值为“0”C．编译成功，并且返回值为“1”D．编译成功，并且返回值为“2”2．答案(A)

解析:static变量是不属于方法的，是属于一个类的,

是在类加载的时候执行的（也就是初始化）,而方法则是在类实例化的时候才开始执行,

所以在方法里定义static变量不可以，所以会出现编译错误。

3．在下面的代码中，当“m”的值为“0”时输出的结果是什么？Switch(m){ case0:System.out.println(“0”); case1:System.out.println(“1”); default:System.out.println(“A”); case2:System.out.println(“2”); case3:System.out.println(“3”);}A．编译失败 B．编译成功，并且输出01AC．编译成功，并且输出01A23 D．编译成功，并且输出0123A3答案（C）原因:case语句分支中没有break语句,将执行所有的分支。4．在下面的代码中，输出的结果是什么？publicclassTest{ staticbooleanfoo(charc) { System.out.println(c); returntrue; } publicstaticvoidmain(String[]args){ inti=0; for(foo('A');foo('B')&&(i<2);foo('C')) { i++; foo('D'); } }}A．编译失败 B．在运行时抛出异常C．ABDCBDCB D．ABCDABCD4．答案（C）&&连接多个表达式时，当有一个表达式为假时整个表达式的值为假。foo()函数的返回值为真；退出循环的条件i值等于2；5．根据下面的代码，哪一个结论是正确的？publicclassIfElse{ publicstaticvoidmain(Stringargs[]){ if(odd(5)){ System.out.println("odd");} else{ System.out.println("even");} } publicstaticintodd(intx){returnx%2;}}A．输出结果为“odd” B．输出结果为“even”C．由第3行代码导致编译失败 D．由第8行代码导致编译失败5．答案（C）Java当中的布尔类型值只有True和False,odd(5)的返回值为3，所以会出现编译错误。6．再下面的代码中，输出的结果为？publicclassStringTest{ publicstaticvoidmain(String[]args){ Stringstr1="Iamstring"; Stringstr2="Iamstring"; Stringstr3=newString(str2); System.out.println(str1==str2); System.out.println(str1==str3); System.out.println(str1.equals(str2)); System.out.println(str1.equals(str3)); }}A．true，true，true，true B．true，false，true，trueC．true，false，true，false D．false，true，true，false6答案（B）String字符串具有常量不变性。"Iamstring"常量池堆"Iamstring"Str1Str2Str3==和equals的判别规则：

（1）基本数据类型：只比较值的大小（2）引用数据类型先比较地址值是否相等再比较值是否相等。7．在下边的代码中，若A处出现异常，执行的结果是什么？publicclassTest{ publicstaticvoidmain(String[]args){ try{ System.out.println("BeforeA"); A System.out.println("AfterA"); }catch(Exceptione){ System.out.println("catch"); }finally{ System.out.println("finally"); } }}A．输出“BeforeA”，“AfterA”，“catch”，“finally” B．输出“BeforeA”，“catch”，“finally” C．输出“BeforeA”，“catch” D．输出“catch”，“finally” 7答案(B)

当发生异常时，跳转到catch语句，最后执行finally.8．根据下面的代码，哪一种结论是正确的？privatebooleancheckFlag(Strings){ booleanflag=false; if(s.equals("error")){ flag=true; returnflag; }}A．编译正常，运行正常 B．编译正常，运行异常C．编译异常 8（C）当if语句条件为假时，没有返回值，故编译不通过。9．根据下面的代码，哪一种结论是正确的？

intindex=1;Boolean[]test=newBoolean[3];Booleanfoo=test[index];A．foo=0 B．foo=null C．foo=true D．foo=false9答案（D）解析：布尔类型的变量默认值为false.10．根据下面的代码，哪一种结论是正确的？

classA{ publicvoidmain(String[]args){ Strings; testString(s);} publicvoidTestString(StringstrTemp){ if(strTemp.equals("")||strTemp==null){ System.out.println("stTempis''ornull"); }else{ System.out.println("strTempisnot"andnull); } }}A．输出“strTempis''ornull” B．输出“strTempisnot''andnull” C．编译时出现错误 D．编译成功，并且运行正常10答案(C)

s未被赋初值，应改为Strings=null或Strings=newString();System.out.println("strTempisnot"andnull);中应为字符串.11．在继承了A类的子类中，下面的那两个方法是正确的？

classA{protectedintmethod1(inta,intb){return0;}}A．publicintmethod1(inta,intb){return0;}B．privateintmethod1(inta,intb){return0;}C．privateintmethod1(inta,longb){return0;}D．publicshortmethod1(inta,intb){return0;}E．staticprotectedintmethod1(inta,intb){return0;}11答案（BC）A项错误原因，问权限扩大，方法重载要求访问权限不能扩大D项错误原因，参数列表没有改变，不能构成重载。E项错误原因，既不能构成重构也不能构成重载。二、问答题

1．请写出下面代码中的输出结果：父类：publicclassFatherClass{publicFatherClass() { System.out.println("FatherClassCreate"); }}子类：publicclassChildClassextendsFatherClass{ publicChildClass() { System.out.println("ChildClassCreate"); } publicstaticvoidmain(String[]args) { FatherClassfc=newFatherClass(); ChildClasscc=newChildClass(); }}输出结果为：1.输出结果：FatherClassCreateFatherClassCreateChildClassCreate解析：程序执行到newFatherClass()时，调用父类的构造方法输出:FatherClassCreate。程序执行到newChildClass()时，编译器先调用父类默认无参的构造方法，输出:FatherClassCreate，再调用本身的构造方法输出:ChildClassCreat。2．请说明：shorts1=1;s1=s1+1;有什么错?shorts1=1;s1+=1;有什么错?2解析：(1)s=s+1;此表达式的之行分两步，第一步将s的值和1相加，然后将s加1的值赋给s.在s和1相加的过程中，s首先转换成int型再和1相加，得到一个整型的值，再赋给s，而s的类型是short,将一个int型值赋给一个short型值，会发生编译错误.（2）s+=1;+=符号运行时会发生自动类型转换。3．请说明：Math.round(11.5)等于多少?Math.round(-11.5)等于多少?3.答案（1）12（2）-11三.程序找错1.abstractclassName{

privateStringname;

publicabstractbooleanisStupidName(Stringname){}}1答案：错误.错因：抽象方法，没有方法体，以分号结束。正形式如下：abstractclassName{

privateStringname;

publicabstractbooleanisStupidName(Stringname)；}2.publicclassSomething{

voiddoSomething(){

privateStrings="";

intl=s.length();

}}2答案：错误。错因：访问修饰符（public，protected,Private）不能修饰局部变量，可以修饰成员变量。3.abstractclassSomething{

privateabstractStringdoSomething();}答案：错误

错因：Private修饰的方法不能被继承，而abstract修饰的方法是用来继承的，所以二者不能同时修饰方法。

4.publicclassSomething{

publicintaddOne(finalintx){

return++x;

}}4答案：错误。错因：final关键字修饰的变量是常量，其值不能改变。5.publicclassSomething{

publicstaticvoidmain(String[]args){

Othero=newOther();

newSomething().addOne(o);

}

publicvoidaddOne(finalOthero){

o.i++;

}}classOther{

publicinti;}5答案:正确。原因：在addOnemethod中，参数o被修饰成final。如果在addOnemethod里我们修改了o的引用(比如:o=newOther();)，那么如同上例这题也是错的。但这里修改的是o的成员变量，而o的引用并没有改变。6.classSomething{

inti;

publicvoiddoSomething(){

System.out.println("i="+i);

}}6答案:正确。原因:输出的是"i=0"。inti属於instantvariable(实例变量，或叫成员变量)。instantvariable有default的defaultvalue是0。7.classSomething{

finalinti;

publicvoiddoSomething(){

System.out.println("i="+i);

}}7答案：错误错因：final修饰的成员变量没有初始值。必须在constructor(构造器)结束之前被赋予一个明确的值。可以修改为"finalinti=0;"。8.publicclassSomething{

publicstaticvoidmain(String[]args){

Somethings=newSomething();

System.out.println("s.doSomething()returns"+doSomething());

}

publicStringdoSomething(){

return"Dosomething...";

}}8答案：错误错因：静态方法中不能直接调用非静态的方法。因为类中static块程序是在类被装载的时候开始执行。而不是在创建对象的时候执行。可改成"System.out.println("s.doSomething()returns"+s.doSomething());"。声明为static的方法有以下几条限制：◆它们仅能调用其他的static方法。◆它们只能访问static数据。◆它们不能以任何方式引用this或super9.此处，Something类的文件名叫OtherThing.javaclassSomething{

privatestaticvoidmain(String[]something_to_do){

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

}}

9.答案：运行时错误Main方法声明为private，编译器找不到main方法。10．interfaceA{

intx=0;}classB{

intx=1;}classCextendsBimplementsA{

publicvoidpX(){

System.out.println(x);

}

publicstaticvoidmain(String[]args){

newC().pX();

}}答案：错误。错因：在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配（就象在同时importjava.util和java.sql两个包时直接声明Date一样）。对于父类的变量,可以用super.x来明确，而接口的属性默认隐含为publicstaticfinal.所以可以通过A.x来明确。11.interfacePlayable{

voidplay();} interfaceBounceable{

voidplay();}interfaceRollableextendsPlayable,Bounceable{

Ballball=newBall("PingPang");}classBallimplementsRollable{

privateStringname;

publicStringgetName(){

returnname;

}

publicBall(Stringname){

=name;

}

publicvoidplay(){

ball=newBall("Football");

System.out.println(ball.getName());

}}11.答案:错误原因:接口中的变量默认为public,final.凡是前面有了final修饰符后，该对象或变量将不能更改,对象使用final后，你只能改变此对象属性，而不能其指向其它对象。接口Rollable中的ball变量为public,static,final，classBall实现了接口Rollable，此时classBall中的ball有final关键字修饰，而语句“ball=newBall("Football")”企图使ball指象一个新的对象，因此会出现编译错误。

JAVA编程题1．现在输入n个数字，以逗号，分开；然后可选择升或者降序排序；按提交键就在另一页面显示按什么排序，结果为，提供reset.importjava.util.*;public

classbycomma{public

staticString[]splitStringByComma(Stringsource){if(source==null||source.trim().equals(""))return

null;StringTokenizercommaToker=newStringTokenizer(source,",");String[]result=newString[commaToker.countTokens()];inti=0;while(commaToker.hasMoreTokens()){result[i]=commaToker.nextToken();i++;}returnresult;}public

static

voidmain(Stringargs[]){String[]s=splitStringByComma("5,8,7,4,3,9,1");int[]ii=new

int[s.length];for(inti=0;i<s.length;i++){ii[i]=Integer.parseInt(s[i]);}Arrays.sort(ii);//ascfor(inti=0;i<s.length;i++){System.out.println(ii[i]);}//descfor(inti=(s.length-1);i>=0;i--){System.out.println(ii[i]);}}}2．金额转换，阿拉伯数字的金额转换成中国传统的形式如：（￥1011）－>（一千零一拾一元整）输出。packagecom.sitinspring.cuc;/***每一位数字*@author:sitinspring(junglesong@)*@date:2008-3-27*/publicclassCnChar{ /** *阿拉伯字母 */ privatechararabicNumber;

/** *对应的汉字大写数字 */ privateStringchineseNumber;

/** *单位（拾佰仟） */ privateStringunit;

/** *构造函数 *@paramarabicNumber *@paramunit */ publicCnChar(chararabicNumber,Stringunit){ this.arabicNumber=arabicNumber; this.chineseNumber=CnUpperCaser.getCnNumberFrom(arabicNumber); this.unit=unit; }

publicStringtoString(){ if(arabicNumber=='0'){ returnchineseNumber; } else{ returnchineseNumber+unit; } }}packagecom.sitinspring.cuc;importjava.util.ArrayList;importjava.util.List;/***按四位分出的每一段*@author:sitinspring(junglesong@)*@date:2008-3-27*/publicclassCnPiece{ /** *分段字符串序列 */ privateList<CnChar>cnchars;

/** *单位（兆亿万） */ privateStringunit;

/** *构造函数 * */ publicCnPiece(Stringpiece,Stringunit){ this.unit=unit;

cnchars=newArrayList<CnChar>(); for(inti=piece.length()-1;i>=0;i--){ cnchars.add(newCnChar(piece.charAt(i),CnUpperCaser.getPieceUnitBy(i))); } }

/** *取得分段文字 *@paramisTail：是否最后一段 *@return */ publicStringgetString(booleanisTail){ Stringretval="";

for(CnCharcnChar:cnchars){ retval+=cnChar.toString(); }

//将末尾的一堆零替换掉 retval=retval.replaceAll("[零]+","零"); retval=retval.replaceAll("(零+)($)","$2");//零在末尾则去掉*/

//若无数字则把单位也去掉，否则加上单位 if(retval.length()>0){ retval+=unit; }

returnretval; }}packagecom.sitinspring.cuc;importjava.math.BigDecimal;importjava.util.ArrayList;importjava.util.Hashtable;importjava.util.List;importjava.util.Map;importjava.util.regex.Matcher;importjava.util.regex.Pattern;/***将阿拉伯数字转换成汉语大写数字的类**@authorsitinspring*@since2008-03-25*@date2008-03-27*/publicclassCnUpperCaser{ /** *用于存储整数部分 */ privateStringintegerPart;

/** *用于存储小数部分 */ privateStringfloatPart;

/** *用于存储0-9大写的哈希表 */ privatestaticfinalMap<Character,String>zerotoNineHt;

/** *用于存储拾佰仟大写的哈希表 */ privatestaticfinalMap<Integer,String>thHuTenHt;

/** *静态构造函数，用于初始化zerotoNineHt和thHuTenHt */ static{ zerotoNineHt=newHashtable<Character,String>(); zerotoNineHt.put('0',"零"); zerotoNineHt.put('1',"壹"); zerotoNineHt.put('2',"贰"); zerotoNineHt.put('3',"叁"); zerotoNineHt.put('4',"肆"); zerotoNineHt.put('5',"伍"); zerotoNineHt.put('6',"陆"); zerotoNineHt.put('7',"柒"); zerotoNineHt.put('8',"捌"); zerotoNineHt.put('9',"玖");

thHuTenHt=newHashtable<Integer,String>(); thHuTenHt.put(0,""); thHuTenHt.put(1,"拾"); thHuTenHt.put(2,"佰"); thHuTenHt.put(3,"仟"); }

/** *取得拾佰仟等单位 *@paramlevel *@return */ publicstaticStringgetPieceUnitBy(intindex){ if(thHuTenHt.containsKey(index)){ returnthHuTenHt.get(index); } else{ return""; } }

/** *由数字取得中国大写汉字 *@paramnumber *@return */ publicstaticStringgetCnNumberFrom(charnumber){ if(zerotoNineHt.containsKey(number)){ returnzerotoNineHt.get(number); } else{ return""; } }

/** *取得万亿兆等单位 *@paramlevel *@return */ privatestaticStringgetUnitBy(intlevel){ Stringretval="";

for(inti=0;i<level;i++){ retval+="萬"; }

//把万万万变成兆 retval=retval.replaceAll("萬{3}","兆");

//把万万变成億 retval=retval.replaceAll("萬{2}","億");

//颠倒回来，因为刚才是替换的结果是兆》億》萬 retval=reverseStr(retval);

returnretval; }

/** *得到逆序字符串 *@paramstr *@return */ privatestaticStringreverseStr(Stringstr){ Stringretval="";

for(inti=str.length()-1;i>-1;i--){ retval+=str.charAt(i); }

returnretval; }

/** *构造函数 *@paramnumber *@throwsNumberFormatException */ publicCnUpperCaser(floatnumber)throwsNumberFormatException{ this(String.valueOf(number)); }

/** *构造函数 *@paramnumber *@throwsNumberFormatException */ publicCnUpperCaser(doublenumber)throwsNumberFormatException{ this(String.valueOf(number)); }

/** *构造函数 *@paramnumber *@throwsNumberFormatException */ publicCnUpperCaser(intnumber)throwsNumberFormatException{ this(String.valueOf(number)); }

/** *构造函数 *@paramnumber *@throwsNumberFormatException */ publicCnUpperCaser(longnumber)throwsNumberFormatException{ this(String.valueOf(number)); }

/** *构造函数 *@paramnumber *@throwsNumberFormatException */ publicCnUpperCaser(Stringnumber)throwsNumberFormatException{ StringformalNumber=formatNumber(number);

//劈分以给整数部分和小数部分赋值 String[]arr=formalNumber.split("[.]"); if(arr.length==2){ //有小数点 integerPart=arr[0]; floatPart=arr[1]; } else{ //无小数点 integerPart=arr[0]; } }

publicStringtoString(){ Stringretval="";

if(integerPart!=null){ //取得整数部分的大写汉字表示 retval+=parseIntegerPart(); }

if(floatPart!=null){ //取得小数部分的大写汉字表示 retval+=parseFloatPart(); } else{ retval+="整"; }

returnretval; }

/** *得到整数部分的汉字大写表示 *@return */ privateStringparseIntegerPart(){ Stringretval="";

//将整数部分逆序，因为需要反向读取 StringreverseIntegerPart=reverseStr(integerPart);;

//将整数部分按四位分段 Patternp=Ppile("\\d{4}",Pattern.CASE_INSENSITIVE); Matcherm=p.matcher(reverseIntegerPart); StringBuffersb=newStringBuffer(); booleanresult=m.find(); while(result){ //每找到四位放一个逗号 m.appendReplacement(sb,m.group(0)+","); result=m.find(); } m.appendTail(sb);

//按逗号劈分，得到四位分组数据的数组 String[]arr=sb.toString().split(","); List<CnPiece>list=newArrayList<CnPiece>(); for(inti=arr.length-1;i>=0;i--){ list.add(newCnPiece(arr[i],getUnitBy(i))); }

intn=list.size(); for(inti=0;i<n;i++){ CnPiececnPiece=list.get(i); retval+=cnPiece.getString(i==n-1); }

returnretval; }

/** *得到小数部分的汉字大写表示 *@return */ privateStringparseFloatPart(){ Stringretval="点";

for(inti=0;i<floatPart.length();i++){ retval+=getCnNumberFrom(floatPart.charAt(i)); }

returnretval; }

/** *对输入的字符串进行验证，如果不能转化为数字形式则抛出数字转化异常 *，注意这是一个运行时异常(非检查型异常)，程序不用显式捕获 *@paramnumber *@throwsNumberFormatException */ privateStringformatNumber(Stringnumber)throwsNumberFormatException{ return(newBigDecimal(number)).toString(); }

privatestaticStringgetFommetedStr(Stringstr){ //将整数部分逆序，因为需要反向读取 StringreverseIntegerPart="";

for(inti=str.length()-1;i>-1;i--){ reverseIntegerPart+=str.charAt(i); }

//将整数部分按四位分段 Patternp=Ppile("\\d{4}",Pattern.CASE_INSENSITIVE); Matcherm=p.matcher(reverseIntegerPart); StringBuffersb=newStringBuffer(); booleanresult=m.find(); while(result){ //每找到四位放一个逗号 m.appendReplacement(sb,m.group(0)+","); result=m.find(); } m.appendTail(sb);

reverseIntegerPart=sb.toString();

Stringretval="";

for(inti=reverseIntegerPart.length()-1;i>-1;i--){ retval+=reverseIntegerPart.charAt(i); }

returnretval; }

publicstaticvoidmain(String[]args){

//newChineseUpperCaser("123456789123456789123456089123456789123456789123450780").toString(); /*String[]arr={"1.543524304302432","12.432423432","123.454235","1234","12345","123456","1234567","12345678","123456789","1234567891","12345678912","123456789123","1234567891234","12345678912345","123456789123456","1234567891234567","12345678912345678","123456789123456789","123456789123456789123456089123456789123456789123450780","0","00","000","0000","01","001","0001","00001","10","100","1000","10000","101","1001","10001","100001","1.23","21.234","243400031.233234","5400035.980","543.6545"}; //String[]arr={"0","00","000","0000","01","001","0001","00001","10","100","1000","10000","101","1001","10001","100001"}; //String[]arr={"1.23","21.234","243400031.233234","5400035.980","543.6545"}; for(Stringstr:arr){ System.out.println("阿拉伯数字等于："+str+"大写汉字等于："+newChineseUpperCaser(str)); }

newChineseUpperCaser("12345.6789.123456").toString(); */ /*Stringnumber="10000000"; for(inti=0;i<50;i++){ number+="0"; System.out.println("阿拉伯数字等于："+getFommetedStr(number)+"大写汉字等于："+newCnUpperCaser(number)); } */

/*System.out.println("------普通测试-------------------------------"); String[]arr={"1","123","1234","12345","123456","1234567","12345678","123456789","123456789123456789","123456789123456789123456789","123456789123456789123456789","1234567891234567890123456789"}; for(Stringstr:arr){ System.out.println("阿拉伯数字等于："+getFommetedStr(str)+"大写汉字等于："+newCnUpperCaser(str)); } */ Stringnumber="1"; for(inti=0;i<50;i++){ System.out.println("阿拉伯数字等于："+getFommetedStr(number)+"大写汉字等于："+newCnUpperCaser(number)); number+="0"; }

System.out.println("------零测试一-------------------------------"); number="1"; for(inti=0;i<50;i++){ number+="0"; System.out.println("阿拉伯数字等于："+getFommetedStr(number+"1")+"大写汉字等于："+newCnUpperCaser(number+"1")); }

System.out.println("------零测试二-------------------------------"); number="1"; for(inti=0;i<50;i++){ number+="01"; System.out.println("阿拉伯数字等于："+getFommetedStr(number)+"大写汉字等于："+newCnUpperCaser(number)); }

System.out.println("------零测试三-------------------------------"); String[]arr2={"1","101","1001","100101","1000100101","100001000100101","1000000100001000100101","10100100010000100000100000010"}; for(Stringstr:arr2){ System.out.println("阿拉伯数字等于："+getFommetedStr(str)+"大写汉字等于："+newCnUpperCaser(str)); }

System.out.println("------常规测试三-------------------------------"); String[]arr={"1.543524304302432","12.432423432","123.454235","1234","12345","123456","1234567","12345678","123456789","1234567891","12345678912","123456789123","1234567891234","12345678912345","123456789123456","1234567891234567","12345678912345678","123456789123456789","123456789123456789123456089123456789123456789123450780","0","00","000","0000","01","001","0001","00001","10","100","1000","10000","101","1001","10001","100001","1.23","21.234","243400031.233234","5400035.980","543.6545"}; //String[]arr={"0","00","000","0000","01","001","0001","00001","10","100","1000","10000","101","1001","10001","100001"}; //String[]arr={"1.23","21.234","243400031.233234","5400035.980","543.6545"}; for(Stringstr:arr){ System.out.println("阿拉伯数字等于："+str+"大写汉字等于："+newCnUpperCa