java 面试

1、下列 java 程序输出结果为______。

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

A、true,false

B、true,true

C、false,true

D、false,false

E、对于不同的环境结果不同

F、程序无法执行

正确答案：B

解析：

i==j ，这个是基本类型与 Integer 的比较， j 会自动拆箱成 int 类型，然后比较的是值。因此返回真。

j.equals(i) ，调用 equals 方法后，这个 i 会自动装箱成 Integer 类型，然后再比较值，所以也返回真。

2、代码片段：

byte b1=1,b2=2,b3,b6; 
final byte b4=4,b5=6; 
b6=b4+b5; 
b3=(b1+b2); 
System.out.println(b3+b6);

关于上面代码片段叙述正确的是（）

A、输出结果：13

B、语句：b6=b4+b5编译出错

C、语句：b3=b1+b2编译出错

D、运行期抛出异常

C.

被final修饰的变量是常量，这里的b6=b4+b5可以看成是b6=10；在编译时就已经变为b6=10了
而b1和b2是byte类型，java中进行计算时候将他们提升为int类型，再进行计算，b1+b2计算后已经是int类型，赋值给b3，b3是byte类型，类型不匹配，编译不会通过，需要进行强制转换。
Java中的byte，short，char进行计算时都会提升为int类型。

3、下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？

A、private

B、无修饰符

C、public

D、protected

B

4、有这么一段程序：

public class Test{ 
    public String name="abc"; 
    public static void main(String[] args){ 
        Test test=new Test(); 
        Test testB=new Test(); 
        System.out.println(test.equals(testB)+","+test.name.equals(testB.name)); 
    } 
}

请问以上程序执行的结果是（）

A、true,true

B、true,false

C、false,true

D、false,false

C

public boolean equals(Object obj) {
        return (this == obj);
    }

Object 中euqals的源码如上。没有重写equals时，是直接用==判断的，而String中重写了equals方法。

5、

以下代码将打印出

 public static void main (String[] args) { 
    String classFile = "com. jd. ". replaceA11(".", "/") + "MyClass.class";
    System.out.println(classFile);
}

A、com. jd

B、com/jd/MyClass.class

C、///////MyClass.class

D、com.jd.MyClass

C

C。由于replaceAll方法的第一个参数是一个正则表达式，而"."在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成"/"。如果想替换的只是"."，那么久要写成"\.".

6、

以下程序运行的结果为（）

public class Example extends Thread{
     @Override
     public void run(){
        try{
             Thread.sleep(1000);
             }catch (InterruptedException e){
             e.printStackTrace();
             }
             System.out.print("run");
     }
     public static void main(String[] args){
             Example example=new Example();
             example.run();
             System.out.print("main");
     }
}

A、run main

B、main run

C、main

D、run

E、不能确定

A

答案：A
这个类虽然继承了Thread类，但是并没有真正创建一个线程。
创建一个线程需要覆盖Thread类的run方法，然后调用Thread类的start()方法启动
这里直接调用run()方法并没有创建线程，跟普通方法调用一样，是顺序执行的

7、

public class Test
{
    public int x;
    public static void main(String args[])
    {
        System. out. println("Value is" + x);
    }
}

对于上面这段代码，以下说法正确的是：

A、程序会打出 "Value is 0"

B、程序会抛出 NullPointerException

C、非静态变量不能够被静态方法引用

D、编译器会抛出 "possible reference before assignment"的错误

C

答案：C
非静态成员只能被类的实例化对象引用，因此这里在静态方法中访问x会造成编译出错

8、关于以下程序段，正确的说法是：（）

String s1="abc"+"def";//1
String s2=new String（s1);//2
if(s1.equals(s2))//3
System.out.println(".equals succeeded");//4
if(s1==s2)//5
System.out.println("==succeeded");//6

A、行4，行6都不执行

B、行6执行，行4不执行

C、行4执行，行6不执行

D、行4，行6都将执行

c 是对的，equals（）比较的是字符串的内容，==比较的是内存地址值
s1存放在常量池中 s2存放在堆区中  内存地址值是不一样的

9、

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

选D，abstract修饰符用来修饰类和成员方法

1：用abstract修饰的类表示抽象类，抽象类位于继承树的抽象层，抽象类不能被实例化。

2：用abstract修饰的方法表示抽象方法,抽象方法没有方法体。抽象方法用来描述系统具有什么功能，但不提供具体的实现。

Abstract是Java中的一个重要关键字，可以用来修饰一个类或者一个方法。 修饰一个方法时，表示该方法只有特征签名（signature），没有具体实现，而是把具体实现留给继承该类的子类。一个类中只要有一个abstract 方法，那么这个类就要被声明为abstract，但是其中可以有非abstract方法。 abstract类可以使得类的设计者能够创建方法的原型，而真正的实现留给使用这个类的人。

10、针对以下代码，哪些说法是正确的：（）

class CompareReference{
   public static void main(String [] args){
   float f=42.0f;
   float f1[]=new float[2];
   float f2[]=new float[2];
   float[] f3=f1;
   long x=42;
   f1[0]=42.0f;
  }
}

A、f1==f2

B、x==f1[0]

C、f1==f3

D、f2==f1[1]

答案：B C

B、C f1、f2、f3是数组，是引用类型，f、x是基本类型。基本类型之间的比较，应该会将低精度类型自动转为高精度类型再比较,B选项是long和float比较，相当于long和long比较，所以B对。