一米树

JAVA语言基础  复习题

                  （课程代码 252243）

 

• 单项选择题（本大题共30小题）
• 给出下面代码，关于该程序以下哪个说法是正确的？（  D）

public class Person{

static int arr[ ] = new int[5];

public static void main(String a[ ])

{

　　System.out.println(arr[0]);　}

}

A、编译时将产生错误

B、编译时正确，运行时将产生错误

C、输出空

D、输出空输出零

• 应用程序的main方法中有以下语句，则执行后输出的结果是 ( D  )。

int[ ]  x={125,21,5,168,98};

int  max=x[0];

for(int i=1;i<x.length;i++){

if(x[i]> max)

max =x[i];

}

System.out.println(max);

A、125               B、5             C、98            D、168    

• 有以下程序片段，下列哪个选项不能插入到行1。（    D）

1).

2 ).public  class  Interesting{

3). //do sth   

4).}

A、import java.awt.*;                    B、package mypackage;

C、class OtherClass{   }                 D、public class MyClass{  }

• 设有下面两个赋值语句：

    a = Integer.parseInt(“12”);

    b = Integer.valueOf(“12”).intValue( );

    下述说法正确的是（  D   ）。

A、a是整数类型变量，b是整数类对象。

B、a是整数类对象，b是整数类型变量。

C、a和b都是整数类对象并且值相等。

D、a和b都是整数类型变量并且值相等。

• 有以下方法的定义，请选择该方法的返回类型（  D）。

ReturnType  method(byte x, double y)

{

return (short) x/y*2;

}

A、byte            B、short           C、int           D、double

• 下列程序段执行后的结果是( A)。

String s = new String("abcdefg");

for (int i=0; i<s.length(); i+=2){

    System.out.print(s.charAt(i));

}  

A、aceg           B、ACEG            C、abcdefg        D、abcd                                               

• 有整型数组：int[]  x={12,35,8,7,2};,则调用方法Arrays.sort(x)后，数组x中的元素值依次是(  A ).

A、2   7   8   12   35      B、12  35  8    7    2     

C、35  12  8    7    2      D、8   7   12   35   2

• 下面的程序段创建了BufferedReader类的对象in，以便读取本机c盘my文件夹下的文件a.txt。File构造函数中正确的路径和文件名的表示是( B)。

File f = new File(填代码处);

file =new FileReader(f);

in=new BufferedReader(file);

A、 "./a.txt"                               B、"c:\\my\\a.txt"    

C、 "../my/a.txt"                           D、"c:\ my\a.txt"   

• 应用程序的main方法中有以下语句，则输出的结果是 ( B  )。

String   s="12345#aaa#bbb#67890";

int     n=s.indexOf("#");

     int     k=s.indexOf("#",n+1);

int     m=s.indexOf("#",k+1);

String  s2=s.substring(m+1);

System.out.println(s2);

A、123456             B、67890           C、aaa         D、bbb   

• 应用程序的main方法中有以下语句，则输出的结果是 (  B)。

   Hashtable hashtable=new Hashtable( );

        hashtable.put("x","12345");

        hashtable.put("y","67890");

        hashtable.put("a","abcde");

 System.out.println(hashtable.get("a"));       

 A、a                 B、abcde            C、12345      D、67890    

• 在Java语言中，当定义一个变量为基本数据类型时，Java的JVM就为该变量分配内存，并给该变量赋初值，当定义一个复合数据类型变量时，该变量代表该类型对象的引用名。Java的JVM并不为对象创建内存空间，该变量引用的值为null，要创建对象实例，需要使用的关键字为（    A    ）。

A、new;            B、public ;           C、super ;         D、this ;

• 有整型数组：int[ ] x={2,33,88,5,10};, 则调用方法 Arrays.sort(x) 后，数组x中的元素值依次是（　 B   ）。

A、 88102335 ;     B、 25103388;        C、 53321088 ;     D、 88331052 ;

• 下列程序代码段运行后,变量x的结果是(       C      )。

   int x=0;

   int y=3;

   switch(y){

   case 1:x++;

   case 2:x++;x++;

   case 3:x++;x++;x++;

   case 4:x+=4;

   }

A、10 ;           B、6 ;                  C、7;             D、3 ;

• 下述4行代码组成的小程序总共创建String对象的个数为： （   D    ）。

       String s1 = "abc";

       String s2 = new String("abc");

       String s3 = "abc";

       String s4 = new String("abc");

A、 1 ;           B、 4 ;                C、 2 ;            D、 3;

• 编译运行下面的代码会发生什么情况为（D     ）。

public class Bground extends Thread{

public static void main(String argv[ ])

    {

        Bground b = new Bground( );

        b.run();

    }

    public void start( )

    {

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

           System.out.println("Value of i = " + i);  }  }

}

A、 运行时错误，Thread类中的run方法没有定义 ;

B、 编译错误，Thread类中的run方法没有定义 ;

C、 编译无错，打印0到9 ;

D、 编译无错，不打印任何值;

• 编译运行以下程序后，关于输出结果的说明正确的是 （B    ）。

 public  class   Conditional{

      public  static  void  main(String  args[  ]){

             int  x=4;

             System.out.println(“value  is  “ + ((x>4) ? 99.9 :9)); }

}

A、输出结果为：value is 99.99 ;             B、输出结果为：value is 9.0;

C、编译错误 ;                            D、输出结果为：value is 9 ;

• main方法是java Application 程序执行的入口点,关于main方法的方法头以下( B) 是合法的。

1. public static void main( )
2. public static void main(String[ ]args)  
3. public static intmain(String[]arg)  　　　　
4. public void main(String arg[ ]

• 以下程序的运行结果是：（B      ）。

public class Increment{

     public static void main(String args[ ]){

            int c;

            c = 2;

            System.out.print(c);

            System.out.print(c++);

            System.out.println(c); }

}

    A、2 2 2 ;           B、2 2 3;          C、3 4 4 ;         D、2 3 3 ;

• 当在命令行输入：java myprog good morning 运行以下代码，输出结果是（       B   ）。

public class myprog{

　　     public static void main(String argv[ ])

　　    {

　　         System.out.println(argv[2]); }

　　}

A、 myprog ;

B、 Exception raised: "java.lang.ArrayIndexOutOfBoundsException: 2";

C、 good ;

D、 morning ;

• 阅读以下代码：

import java.io.*;

import java.util.*;

public class foo{

public static void main (String[ ] args){

String s;

System.out.println("s=" + s);  }

}

输出结果应该是（      B       ）。

A、 代码得到编译，但捕获到 NullPointException异常 ;

B、 由于String s没有初始化，代码不能编译通过;

C、 代码得到编译，并输出“s=null” ;

D、 代码得到编译，并输出“s=” ;

• 根据下面给出的代码，判断那个叙述是对的？（  C）

public class Person{

static int arr[ ]=new int[10];

public static void main(String a[ ]){

System.out.println(arr[1]);

}

}

A、编译时将发生错误                 B、编译时正确但是运行时出错

C、输出为0                         D、输出为null

• 假设A类有如下定义，设a是A类的一个实例，下列语句调用哪个是错误的？（  C ）

class  A  

{    int  i;

   static  String  s;

   void  method1( ) {   }

   static  void  method2( )  {   }

}

A、System.out.println(a.i);                B、a.method1( );   

C、A.method1( );                        D、A.method2( );

• 给出下面一段程序，选择运行结果（ C  ）

public class X{

   public static void main(String [ ] args){

   String names[]=new String[5];

   for(int x=0; x<args.length; x++)  names[x]=args[x];

      System.out.println(names[2]);}

}

命令行执行：java X a b命令后，其输出结果是下面哪一个？

A、names       B、b        C、null    D、运行出现异常

• 看下面一段程序：

　　   class Aclass

{

           void go( )

           {      System.out.println("Aclass");   }

}

public class Bclass extends Aclass

{

           void go()

           {      System.out.println("Bclass");    }

           public static void main(String args[ ]) {

                  Aclass a=new Aclass( );

                  Aclass a1=new Bclass( );

                  a.go();

                  a1.go();

           }

}

以上程序运行结果是：（ C ）    

A、Aclass    Aclass                        B、Bclass   Bclass        

C、Aclass    Bclass                        D、Bclass Aclass　                                                     

• 下列应用程序打印多少行？（C  ）

public class hellotest

{    { System.out.println("hello."); }

      public static void main(String[ ] args) {

         new hellotest( );

new hellotest( );

new hellotest( );

 }

}

A、0      B、1          C、3      D、2

• 以下程序执行完后，c与result的值是：（ B）

　　boolean a=false;

　　boolean b=true;

　　boolean c=(a&&b)&&(!b)；

　　int result=c==false?1:2;

A、c: true;  result:2;                    B、c: false;  result:1;

C、c: true;  result:1;                    D、c: false;  result:2;

• 下面是程序Ojava的代码段：

class Empty{ }

public  class ObjectTest{

public static void main(String[ ] args) {

Empty em=new Empty( );

}

}

以下错误的结论是（ B  ）。

A、类Empty非空，有一个默认的构造方法

B、类Empty是空的，既没有成员变量也没有成员方法

C、类Empty中有一个构造方法Empty()

D、类Empty能够被继承

• 编译并运行下面的程序，运行结果为(B  ).

public class A {

public static void main (String[ ] args)  {

A a=new B( );

a.test( );

}

void test( )  {

System.out.print ("A");  }

}

class B extends A {

void test( ) {

super.test( );

System.out.println("B");  }

}

A、子类B定义了与父类A中同名的方法test，java中称为方法的覆盖。

B、代码可以编译运行，并输出结果：AB

C、代码可以编译运行，并输出结果：A。

D、子类B定义了与父类A中同名的方法test，java中称为方法的重载

• 编译并运行下面的程序，运行结果为( B).

public class T1 {

public static void main (String[ ] args) {

T 1 a=new T1( );

a.method(8);

a.method(1.2f);

}

void method(float i) {

System.out.println("float: "+i);

}

void method(long i) {

System.out.println("long: "+i); }

}

A、程序有编译错误，因为两个method()方法必须定义为静态（static）的。

B、程序可以编译运行，输出结果为：long: 8    float: 1.2

C、程序可以编译运行，输出结果为：float: 1.2   long: 8

D、程序中定义的两个参数不同的method方法称为方法重栽。

• 类Teacher和Student都是类Person的子类

　　 Person p;

　　 Teacher t;

　　 Student s;

　　 p, t and s are all non-null.

　　 If (t instanceof Person) {

s = (Student)t;

}

　这个语句导致的结果是（   B   ）

A、将构造一个Student对象。

B、表达式合法。

C、编译时非法。

D、编译时合法而在运行时可能非法。　

 

• 判断题（本大题共21小题）
• Java的源代码中定义几个类，编译结果就生成几个以.class为后缀的字节码文件。（√ ）
• 静态初始化器是在其所属的类加载内存时由系统自动调用执行。   （√ ）
• 在异常处理中，若try中的代码可能产生多种异常则可以对应多个catch语句，若catch中的参数类型有父类子类关系，此时应该将父类放在后面，子类放在前面。    （√ ）
• 拥有abstract方法的类是抽象类，但抽象类中可以没有abstract方法。（√ ）
• Java语言具有良好的安全性和可移植性及平台无关性。  （√ ）
• Java程序里,创建新的类对象用关键字new，回收无用的类对象使用关键字free。 （× ）
• Java有垃圾回收机制，内存回收程序可在指定的时间释放内存对象。（× ）
• Java中定义接口的关键字是class。（×）
• Java中父类的对象变量可以调用其子类对象的任何方法。 （×）
• interface 中定义的常量不要写public、static、final的修饰词，方法需要写public修饰词。（×）
• Java语言中，变量出现的位置只有一种，即为类体内定义的成员变量。 （×）
• Java语言中，方法调用一律都是传址的引用调用。 （×）
• 对于switch语句下的case语句，必须在每个case分支结束前加上break语句。（√）
• 不要使用循环将集合转为数组，可以使用集合的toArray()方法。（√）
• friendly关键字是Java语言的访问控制修饰符。（× ）
• Java语言规定所有的变量在使用前都必须进行初始化。（× ）
• 在Java中对象可以赋值，只要使用赋值号（等号）即可，相当于生成了一个属性与赋值对象相同的新对象（× ）
• private修饰的顶层类（非内部类）可以被同一个包中的其他类所访问。（× ）
• 在一个抽象类中不能定义构造方法。（× ）
• 在构造方法中如调用super()语句，则必须使其成为构造方法中的D第一条语句。（√ ）
• 调用sleep()方法可以使一个线程停止运行。（√ ）

 

• 程序阅读题（本大题共9小题）
• import java.io.*;

public class abc

{   

public static void main(String args [ ])

{    

AB s = new AB("Hello!","I love JAVA.");

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

    }

}

class AB {

  String s1;

  String s2;

  public AB(String str1, String str2)

  {

s1 = str1;  

s2 = str2;

}

  public String toString( )

  {

return s1+s2;

}

}

写出程序的运行结果。

 

运行结果：Hello! I love JAVA.

• import java.io.* ;

    public class abc

    {

          public static void main(String args[ ])

          {    int i, s = 0 ;

               int a[ ] = { 10 , 20 , 30 , 40 , 50 , 60 , 70 , 80 , 90 };

               for ( i = 0 ; i < a.length ; i ++ )

                     if ( a[i]%3 = = 0 )  s += a[i] ;

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

           }

     }

写出程序的运行结果。

 

运行结果：s = 180

• public class MyClass {

int a[ ] = { 1, 2, 3, 4, 5 };

 

void out( ) {

for (int j = 0; j < a.length; j++)

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

}

 

public static void main(String[ ] args) {

MyClass my = new MyClass( );

my.out( );

}

}

写出程序的运行结果。

输出结果为12345。

• import    java.io.*;

public  class  TestString

{     

public  static  void  main(String args[ ])

      {   

 StringC  s = new  StringC ("cool","java");

           System.out.println(s);      }

}

class   StringC {

  String   s1;

  String   s2;

  StringC( String  str1 , String  str2 )

  {  

s1 = str1;  s2 = str2; }

  public   String   toString( )

  {

return  s1+s2;}

}

写出程序的运行结果。

输出结果为     cooljava              。

 

• class  First{

public  First()

{

aMethod(); }

public  void  aMethod()

{

System.out.println(“in  First  class”);}

}

public  class  Second  extends  First{

public  void  aMethod()

{

System.out.println(“in  Second  class”);}

public static void main(String[ ]  args)

{

new  Second( ); }

}

写出程序的运行结果。

写出输出结果。inSecondclass

 

• class OverloadDemo{

     void   testOverload( int  i )

{

        System.out.println(“int”);     }

     void  testOverload(String  s)

{

          System.out.println(“String”);     }

    public  static  void main(String  args[ ])

{

          OverloadDemo  a=new  OverloadDemo ( );

          char    ch=’x’;

          a.testOverload(ch);     }

}

写出程序的运行结果。

int

• public class CalculateTest{

public static void main(String args[ ]) {

float x,y;

       x = Float.parseFloat(args[0]);

       if(x<1)

y = x;

else if(1<=x&&x<10)

y = 2*x-1;

else

y = 3*x-11;

System.out.println(y); }

}

写出程序的运行结果。

10.0

 

• class Aclass

{

     void go( )

     {  System.out.println("Aclass"); }

}

public class Bclass extends Aclass

{

     void go( )

     {

           System.out.println("Bclass");

      }

      public static void main(String args[ ]) {

           Aclass a=new Aclass( );

           Aclass a1=new Bclass( );

           a.go( );

           a1.go( );  }

}

写出程序的运行结果。

Aclass

           Bclass  

 

• class Test11{

class Dog {

private String name;

private int age;

public int step;

Dog(String s, int a) {

name = s;

age = a;

step = 0;

}

public void run(Dog fast) {

fast.step++; }

}

public static void main(String args[ ])  {

Test11 a = new Test11( );

Dog d = a.new Dog("Kate", 5);

d.step = 35;

d.run(d);

System.out.println(" " + d.step); }

}  

写出程序的运行结果。

36

 

• 简答题（本大题共9小题）
• String是最基本的数据类型吗？Java基本类型有哪些？

参考答案：String不是最基本的数据类型，而是一个对象。

Java基本类型有：

布尔型：boolean  

字符型：char   

整数型：byte、short、int、long  

浮点数型：float、double  

• final、finally、finalize有什么区别？

参考答案：final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法 

• error和exception有什么区别？

参考答案：error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。

 exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

• 简述类变量和实例变量的不同？ 

参考答案：

（1）不同对象的实例变量将分配不同的内存空间，实例变量则属性独有，改变某一个对象的值不影响其他对象；而所有对象的类变量占用同一块内存空间，类变量是所有对象共有的，改变其中一个对象的值，其他对象得到的就是改变后的结果。    

（2）类变量在类被加载到内存是就为其分配内存空间，而实例变量在使用new创建对象时，才为其分配内存空间； 

（3）类变量可以通过对象和类名访问，而实例变量只能通过对象访问。     

（4）类变量通过static关键字修饰，实例变量不需要。

• 请写出抽象类、接口的相同点和不同点？ 

参考答案：

相同点： 

        都不能被实例化 

        都必须通过其他类实现才能使用 

不同点： 

       抽象类是类，其中可包含变量及（抽象、非抽象）方法的定义        

接口实质并不是类，其中只包含类常量及抽象方法的定义

• 什么是抽象方法？抽象方法的特点？

参考答案：

抽象方法： 

用abstract来修饰一个方法时，该方法叫抽象方法，只有方法声明，没有方法体。  

特点： 

抽象方法必须被重写 

抽象方法只有声明，不能有实现     

定义了抽象方法的类必须是抽象类

• 子类对象实例化过程？

参考答案：

（1） 为对象分配内存空间，对域变量进行默认初始化。 

（2） 绑定构造方法，将new对象中的参数传递给构造方法的形式参数。 

（3） 调用this或者super，二者必居其一，不能同时存在。 

（4） 进行域变量的显示初始化。 

（5） 执行当前构造方法中的程序代码。

• 面向对象的主要特征是什么？

参考答案：

封装：利用类将数据与方法绑定在一起，数据被保存在类的内部，系统只有通过被授权的方法才能够访问数据。 

继承：java是通过extends关键字来实现，在定义类的时候使用extends关键字指 

明新定义类的父类，在两个类之间建立继承关系。 

多态：多态是指一个程序中同名的不同方法共存的情况。

• 什么是异常？什么是致命错误？写出异常处理语句的结构。

参考答案：

（1）Java把程序运算中可能遇到的错误分为两类:一类是非致命的错误,可以通过修正后还可以继续运行,这种错误称为异常;另外一类则是致命错误,即系统遇到了十分严重的错误,不能简单的恢复,这就是致命错误,需要操作系统才能处理。 （2）异常处理的程序的一般结构是： 

try{…} 

catch(异常类型 e)

{…} 

catch(异常类型 e)

{…}

Finally

{…}

 

• 编程题（本大题共3小题）
• 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子对数为多少？

参考答案：

public class Program1 {

public static void main(String[] args){

int n=1;

while(true){

System.out.println("请输入你想查询的月数（第"+n+"次查询）：");

Scanner in = new Scanner(System.in);

int month = in.nextInt();

if (month==0){

System.out.println("您已退出。");

break;}

System.out.println("第"+month+"个月兔子的对数为："+f(month) +"。");

System.out.println();

n++;

}

}

private static int f(int month){

if (month==1||month==2){

return 1; }

return f(month-1)+f(month-2);

}

}

 

• 海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？

参考答案：

public class lianxi41 {

public static void main (String[] args) {

int i,m,j=0,k,count;

for(i=4;i<10000;i+=4)

   { count=0;

     m=i;

     for(k=0;k<5;k++)

        {

         j=i/4*5+1;

         i=j;

         if(j%4==0)

            count++;

            else break;

       }

    i=m;

if(count==4)

{System.out.println("原有桃子 "+j+" 个");

break;}

}

}

}

 

• 某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。

参考答案：

import java.util.*;

public class lianxi48   {

public static void main(String args[]) {

Scanner s = new Scanner(System.in);

int num=0,temp;

do{

   System.out.print("请输入一个4位正整数：");

      num = s.nextInt();

     }while (num<1000||num>9999);

int a[]=new int[4];

a[0] = num/1000; //取千位的数字

a[1] = (num/100)%10; //取百位的数字

a[2] = (num/10)%10; //取十位的数字

a[3] = num%10; //取个位的数字

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

{

a[j]+=5;

a[j]%=10; }

for(int j=0;j<=1;j++)

    { temp = a[j];

    a[j] = a[3-j];

    a[3-j] =temp;  }

System.out.print("加密后的数字为：");

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

System.out.print(a[j]);  }  

}