Java常见面试题

1、分析下列Java代码：

       class  A{

              public static void main(String[] args){

                     method();

              }

 

              static void method(){

                     try{

                            System.out.println(“Hello”);

                            System.exit(0);

                     }finally{

                            System.out.println(“good-bye”);

                     }

              }

   }

 

   编译运行后，输出的结果是：（）

a)        “Hello”

b)       “good-bye”

c)       “Hello”后面是”good-bye”

d)       代码不能通过编译

解析：当且仅当JVM推出时不会执行finally{}里的语句。若把System.exit(0)改为：return ;这时将会执行finally{}里的语句后再结束main()。;

 

2、     int index = 1;

        String[] test =new String[3];

        String foo = test[index];

        foo结果是什么？

A、    foo有一个值“”

B、   foo有一个值null

C、   抛出一个异常

D、  代码不会编译

解析：在创建数组时，只是对其分配了空间，并没对它进行初始化。因此里面元素的值都是null值。

 

3、以下代码执行结果是

public class A{

   String s=”123”;

   Public void method(String s){

        System.out.println(s);

        System.out.println(this.s);

}

public static void main(String[] args){

    A  a = new A();

a.method(“abc”);

}

}

A、  abc   123

B、  123   abc

C、  abc   abc

D、  123   123

解析：在程序执行时，将首先检查是否有局部变量，若有将直接调用它的值，否则将会检测全局变量。若还没，这样的程序将不会通过编译。

 

4、public   class  ConstOver{

       public  ConstOver(int  x,int  y,int  z){}

}

说出哪个重载了ConstOver构造器？

A、ConstOver(){}

B、protected  int  ConstOver(){}

C、private  ConstOver(int  z,int  y,byte  z){}

D、public  void  ConstOver(byte  x,byte  y,byte  z){}

E、public  Object  ConstOver(int  x,int  y,int  z){}

解析：这个题要求我们掌握构造方法的形式，及重载的实质。

构造方法：方法名与类名相同，无返回类型。

重载：在一个类中，方法名相同，参数列表不同。

5、

1、public  class  X{

2、       pulbic  Object  m(){

3、                               Object  o = “Str”;

4、                               Object  b = new  Object;

5、                Object[]  oa  =  new  Object[1];

6、                oa[0]  =  o;

7、                oa = b;

8、                o  =  b;

9、                System.out.println(oa[0]);

10、              }

11、}

 

在哪一行执行后发生了垃圾回收？

A、 4行

B、 5行

C、6行

C、 7行

D、8行

E、 9行

解析：垃圾机制回收的时机：在对象没被任何变量指向时，系统将会回收这块内存区域(堆区)。

6、class Tagimplements Runnable{

    inti;

    publicvoid run() {

        try {

            Thread.sleep(5000);

            i=10;

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    publicstaticvoid main(String[] args) {

        try{

            Tag a =new Tag();

            Thread t =new Thread(a);

            t.start();

            (17)

           int j=a.i;

        }catch(Exception e){

            e.printStackTrace();

        }

    }

}

 

在17行加上什么，保证j=10?C

A、a.wait();

B、t.wait();

C、t.join();

D、t.yield();

E、t.notify();

F、a.notify();

G、t.interrupt();

解析：join()用于让子线程执行完毕后在执行主线程。

7、当试图编译并运行下面程序时会出现什么结果？D            

public class MyMain{
public static void main(String argv){
       System.out.println("Hello cruel world");
}

}

A)   编译器报main属于保留字而不能在一个class中使用

B)  代码将编译、运行并输出“Hello cruel world”
C)  代码编译通过，但运行时报没有定义构造方法
D)  代码编译通过，但运行时报main方法没有正确定义
解析：注意main()方法的参数列表，是一个字符数组。本例中编译会通过，因为系统将会认为这是个普通方法，而在程序执行时将会找不到程序入口而报错。

8、当编译并运行下面程序时会出现什么结果？
public class MyAr{
     public static void main(String argv[]){
          int[] i = new int[5];
          System.out.println(i[5]);
     }
}
A) 编译出错
B) 运行出错
C) 输出0
D) 输出“null”

解析：数组越界问题是数组中经常遇到的问题，java将在执行时发现这个问题而引发异常。

9、Java Swing中，JFrame的默认布局管理器是（）。

A） FlowLayout
B）BorderLayout
C）GridLayout
D）GridBagLayout

 

10、Java Swing中，JPanel的默认布局管理器是（A）。

A） FlowLayout
B）BorderLayout
C）GridLayout
D）GridBagLayout

 

11、public class Hope{
      public static void main(String argv[]){
          Hope h = new Hope();
      }
      protected Hope(){
          for(int i =0; i <10; i ++){
               System.out.println(i);
          }
      }
}
A) 编译错误，构造方法不能被声明为protected
B) 运行错误，构造方法不能被声明为protected
C) 编译并运行输出0到10
D) 编译并运行输出0到9
解析：对于构造方法，四种修饰符都可以修饰，只不过它们的使用位置有要求而已。如Class这个类，它的构造方法就是private的，所以我们不能直接产生它的实例。只能通过Class.forName()去得到它的实例。

13、

public class Test{

   public static void stringReplace(String text){

        text=text.replace('j','L');

    }

    public static void bufferReplace(StringBuffer text){

        text=text.append("c");

     }

   public static void main(String args[]){  

        String textString=new String("java");

        StringBuffer textBuffer=new StringBuffer("java");

        stringReplace(textString);

        bufferReplace(textBuffer);

        System.out.println(textString+textBuffer);

      }

   }

A、编译并运行输出Lava   javac
B、编译并运行输出java    java
C、编译并运行输出java    javac
D、编译并运行输出 Lava   java
解析：字符串的长度不可变性，是在面试中经常遇到的一个问题。因此我们一定要牢记这一点。对于字符串的任何改变都是重新创建一段内存空间来保存它。像此题中把字符串当成参数传递，但字符串改变时，并不影响原引用的字符串。

 

14、当编译和运行下面程序时，哪项描述可以最准确的表达发生了什么事情？
public class MyAr{
       public static void main(String argv[]) {
              MyAr m = new MyAr();
              m.amethod();
       }

public void amethod(){
      int i;
      System.out.println(i);
}

}

A、编译并输出0

B、编译错误

C、编译并输出null
D、运行错误

解析：局部变量必须赋初值，是初级程序员经常犯的错误。为了避免此类情形，我们要养成良好的编程习惯：在定义一个变量时就给它赋上一个值。

 

 

15、下面哪些编译正确？
    A、 short myshort = 99;

myshort= myshort+2;

B、 String name = 'Excellent tutorial Mr Green';

C、 char c = 17;
D、 int z = 015;

解析：理解字符在内存中的存放形式及两个short型相加时，得到的结果是int型的。Byte,short,char都是无条件直接转换成int型。

16、关于线程，以下说法正确的是：

A、 sleep方法执行时会释放对象锁。

B、 wait方法执行时会释放对象锁。

C、sleep方法必须写在同步方法或同步块中

D、wait方法必须写在同步方法或同步块中

解析：在学习中要学会将相似的知识点做比较。Wait()是在Object里定义的方法，必须放在同步方法或同步块中，wait()在执行时竟会释放对象锁，它需要其他方法来唤醒才能执行。

而sleep()是在Thread类里定义的，它可以放在程序的任何方法中，它不会释放对象锁，它是在休眠指定时间后自动醒来。

 

17、

给定JAVA代码如下，编译运行后，输出结果是（）。

public class test{

   static int i;

   public int aMethod(){

    i++;

     return i;

  }

public static void main(String args[]){

 Test test=new Test();

  test.aMethod();

   System.out.println(test.aMethod());

  }

}
A、 0

B、 1

C、 2

E、 3

E、 编译错误

F、 运行错误

解析：静态变量在下次调用时将会保存上次调用的值，因为它的这个特点，我们常常把它用做记数器使用。

 

18、给定JAVA代码如下，关于super的用法,以下描述正确的是( ).(选择一项)

class C extends B

{

    public C()

    {

         super();

    }

}

A、用来调用类B中定义的super()方法
B、用来调用类C中定义的super()方法
C、用来调用类B中的无参构造方法
D、用来调用类B中第一个出现的构造方法
解析：构造方法是一个类特有的方法，它用于创建此类的对象。子类不能继承父类的构造方法。但子类在创建对象为了不单独初始化继承自父类的属性，可以通过关键字super去调用父类的构造方法去初始化。若父类没有无参的构造方法，子类在调用时也必须传入参数，否则将报错。

 

19、

下面哪些为真？
A、接口里可定义变量，并且变量的值不能修改

B、任何情况下，类都不能被private修饰

C、类可以被protected修饰(内部类)

D、接口不能实例化

解析：此题容易选上B。只是受习惯的影响，以为我们没见过的就是不存在的。对于内部类就可以用private去修饰。

 

20．下列哪一种叙述是正确的（ ）
A． abstract修饰符可修饰属性、方法和类
B． 抽象方法的body部分必须用一对大括号{ }
C． 声明抽象方法，大括号可有可无
D．声明抽象方法不可写出大括号

解析：抽象方法的定义：只有方法的声明，没有方法的实现，即没有方法体。

 

21、给定JAVA程序Test.java如下，编译运行，结果是( ).(选择一项)

package com;

public class Test

{

   protected void talk()

   {

      System.out.print("talk");

   }

}

 

给定Test的子类Test2,代码如下:

package com.util;

import com.*;

public class Test2 extends Test

{

    public static void main(String [] args){

      Test tt=new Test();//不能访问

      tt.talk();

    }

}

    A、输出字符串:talk

B、输出字符串:talk talk

C、编译错误:在com.util.Test2中无法访问方法talk()

D、编译错误

解析：此题很容易选A。这是没有很好地理解protected的作用造成的。虽然Test2继承了Test，但只能在main()外部去调用父类的构造方法，在main()中直接调用将产生编译错误，

Talk()将不可视。

22、在JAVA中，要创建一个新目录，要使用（）类的实例。

A、File

B、FileOutputStream

C、PrintWriter

D、Dir

23、给定java代码如下，编译运行结果是（）。

public class Test{

   static int x;

   public int count(){

     return x++;

   }

   public static void main(String[]args){

     System.out.println(count());//不能执行非静态方法。

   }

}

A、 编译错误

B、 运行错误

C、正常运行，输出1

D、正常运行，输出0

解析：易粗心选上D。普通方法只能通过对象.方法的方式调用。

24、给定一个java程序的代码片断如下，运行后，正确的输出结果是（）。

String s="hello,world";

s.replace(","," ");

System.out.println(s);

A、 hello world

B、 hello,world

C、HELLO WORLD

D、HELLO,WORLD

解析：同题13.

 

25、要打印出list储存的内容，以下语句正确的是（）（选择二项）

ArrayList list=new ArrayList();

list.add("a");

list.add("b");

Iterator it=list.iterator();、

 

A、while(it.hasNext())

      System.out.println(it.next());

B、for(int i=0;i<list.size();i++)

      System.out.println(list.get(i));

C、while(list.hasNext())

   System.out.println(list.next());

D、for(int i=0;i<list.size();i++)

   System.out.println(it(i));

 

解析：集合的三种遍历方法都应牢牢掌握。

26、将对象序列化，要实现哪个接口（）

A、 Cloneable   B、Runnable  C、Serializable   D、Comparator

 

解析：通过实现Serializable接口，可以实现对象的快速传输。

27、给定JAVA代码，如下，编译运行后，结果是( ).(选择一项)

public class Test{

   static String s;

   public static void main(String args[])

   {

        int  c=s.length();

        System.out.print(c);

   }

}

A、 编译错误

B、 运行期异常

C、正常运行，输出null

D、正常运行，输出0

 

解析：空指针异常是RuntimeException异常的子类。

28、在JAVA中,集合框架Collection 接口有哪些子接口()

A、Map    B、Collections     C、List    D、Set

 

29、在Java中，下列（）类不能派生出子类。

A、 public class MyClass{}

B、 class MyClass{}

C、abstract class MyClass{}

D、final class MyClass{}

 

30、在java中，已定义两个接口B和C，要定义一个实现这两个接口的类，以下语句正确的是（）。

A、 interface A extends B,C

B、 interface A implements B,C

C、 class A implements B,C

D、class A implements B,implements C

      

 

31、

给定JAVA代码如下，在Test类中实现什么方法编译不会出错（）。

interface  A{int  a();}

interface  B{int  b();}

interface  C extends A,B{int  c();}

public class Test implements  C{

 

  }

A、 c（）

B、 b（）、c()

C、 a（）、c（）

D、 a（）、b（）、c（）

解析：在实现一个接口时要实现其全部抽象方法。

32、对于以下代码，运行结果是：

interface  A{int  i=9;}

public class B implements A{

       B(){

              i=10;//i从接口里来]，是常量

              System.out.println(i);

       }

       public static void main(String[] args){

              new B();

       }

}

A、编译错误

B、运行错误

C、正常运行，并输出10

D、正常运行，并输出9

解析：接口里的变量的默认修饰符是：public static final型的，是一个常量。常量的值一旦定义就不允许改变。

33、Java中，要使用输入输出流，必须导入（）包。

A、java.lang

B、java.stream

C、java.util

D、java.io

 

34、程序读入用户输入的一个值，要求创建一个自定义的异常，如果输入值大于10，使用throw语句显式地引发异常，异常输出信息为“smething’s wrong!”，语句为（）

     a)   if(i>10)

          throw Exception(“smething’s wrong!”);

     b)   if(i>10)

          throw Exception e(“smething’s wrong!”);

     c)   if(i>10)

          throw new Exception(“smething’s wrong!”);

     d)   if(i>10)

          throw new Exception e(“smething’s wrong!”);

 

35、下面继承哪些叙述是正确的()

       a)  在java中只允许单一继承，//接口可以多继承。

       b)   在java中一个类只能实现一个接口

       c)   在java中一个类不能同时继承一个类和实现一个接口

       d)   java的单一继承使代码更可靠

解析：在java中为了避免菱形继承的危险，抛弃了C++中的多重继承，而采用去实现多个接口去弥补这个缺陷。须注意的是接口可以多继承。

36、public class MyExample{

              public static void main(String[] args){

                     System.out.println(args[2]);

              }

}

如果以下列命令行运行：java MyExample Lovo online  代码将输出（）。

a)            MyExample

b)           Lovo

c)           Online

d)           产生异常：“java.lang.ArrayIndexOutOfBoundsException”

 

 

37、在Java语言中，如果你编写一个多线程序，可以使用的方法是（）。

       a)  扩展类Thread

       b)  实现Runnable接口

       c)   扩展类Runnable

   d)    实现接口Thread

 

 

38、在Java中，下列（AB）是合法的声明

       a)     float f=1/3;

       b)     int i=1/3;

   c)      float f=1.01

   d)      double d=999d;

 

解析：两个整形相除，结果仍为int型的。在给float型变量赋值时，应在数值后面在上个f或F。

39、编译下面java程序片断：

       class test{

              int count=9;

              public void a(){

                     int count=10;

                     System.out.println(“count1=”+count);

              }

              public void count(){

                     System.out.println“count2=”+count);

              }

              public static void main(String[] args){

                     test t=new test();

                     t.a();

                     t.count();

              }

}

结果是（）

a)          不能通过编译

b)          输出：

count1=10

count2=9

c)          输出：

count1=9

count2=9

解析：在一个方法内，局部变量与全局变量同名时，根据就近原则，将执行局部变量。局部变量一旦出了作用域将不再起作用，就会执行全局变量。

40、HashMap和Hashtable正确的说法是（）

       a)   都属于Map接口

       b)   Hashtable类不是同步的，HashMap类是同步的，反了

       c)    Hashtable类不允许null键和null值

d)          HashMap类允许null键和null值

解析：此题告诉我们在java学习要注意对相似知识点进行比较。

 

41、java中有关“重载”和“重写”的说法正确的说法是（）

       a)  “重写”是父类与子类之间多态性的一种表现

       b)   “重载”是一个类中多态性的一种表现

c)    “重载”的方法是可以改变返回值的类型

d)     “重载”的方法不能改变返回类型

解析：重载与重写的区别一定要牢牢掌握。

42、下面关于构造方法说法正确的是（）

       a)  构造方法不能被继承

       b)  构造方法不能被重写

       c)   构造方法不能被重载

       d)  构造方法可以重载

 

43、在java多线程中sleep()和wait()方法，下列说法正确的是（）

a)    sleep()方法是使线程停止一段时间的方法

b)    在sleep()时间间隔期满后，线程立即恢复运行//就绪

c)    wait()方法用于线程交互

d)    使用wait()方法后，线程需要被通知唤醒

 

44、在java中，关于捕获错误的语法try-catch-finally的下列描述正确的是（）

       a)     try-catch必须配对使用

       b)     try可以单独使用

       c)           try-finally可以配对使用

       d)           在try-catch后如果定义了finally,则finally肯定会执行

 

45、在java中一个类被声明为final类型，表示的意思是（）

       a)     该类可以被其子类继承

       b)           该类一定是一个子类

       c)          该类不能被继承

       d)          该类是一个顶级类

 

46、Collection和Collections正确的说法是（）

       a)           Collections是个java.util包下的接口

       b)           Collection是个java.util包下的类

       c)           Collections包含有各种有关集合操作的静态方法

       d)           Collection是各种集合结构的父接口

 

47、在J2EE中,要等待客户机请求连接，服务器可以使用以下（）类。

A、Socket

B、ServerSocket

C、Server

D、URL

 

48、下面关于TCP/IP通信正确的描述是（）

A、TCP/IP通信必须要有服务器端和客户端。

B、服务器端通过调用Socket类的构造方法得到一个Socket对象。

C、服务器端调用ServerSocket.accept()方法监听指定的端口。

D、ServerSocket.accept()方法会使线程阻塞。

 

49、以下说法正确的是：

A、 使用TDD开发时，先要有文档，然后根据需求编写代码，最后测试。

B、 JUnit中测试方法必须写在tearDown中

C、 JUnit中测试方法必须以test开头

D、SetUp方法用于销毁，tearDown用于初始化

E、 SetUp方法用于初始化，tearDown用于销毁

 

50、public class Test{

  public static String output="";

    public static void foo(int i){

      try {

         if(i==1){

                  throw new Exception();

          }

         output +="1";

     } catch(Exception e){

           output+="2";

                 return;

     } finally{

         output+="3";

}

 

    output+="4";

  }

 public static void main(String args[]){

 foo(0);

 foo(1);

 System.out.println(output); 

    }

}

以上代码输出结果为

A、 1342

B、 123

C、134234

D、13423

 

 

52、下列说法正确的是：

A)  数组有length()方法

B)  String有length()方法

C)  数组有length属性

D)  String有length属性

 

53、

下面哪个编译没有错误？

interface IFace{}
class CFace implements IFace{}
class Base{}

public class ObRef extends Base{
     public static void main(String argv[]){
         ObRef ob = new ObRef();
         Base b = new Base();
         Object o1 = new Object();
         IFace o2 = new CFace();
    }
}
A、o1=o2;
B、b=ob;
C、ob=b;
D、o1=b;

 

54、请选出程序执行的结果（）

public class Test{

       public static void test(Object obj){

              System.out.println(“One”);

}

 

public static void test(Object[] objs){

              System.out.println(“Two”);

}

 

public static void main(String[] args){

       test(null);

}

}

A)  编译出错

B)  运行时出错

C)  打印出：One

D)  打印出：Two