面试题答案总结

字数统计: 2.3k   |   阅读时长≈ 9 分钟

如有错误欢迎指正

1.下面哪个函数是public void aMethod( ){…}的重载函数？

1
2
3
D

方法名称相同，参数列表不同，和返回类型无关

2.请问如何强制垃圾回收期立即回收一个对象？

1
2
3
4
5
6
7
8
D

垃圾（你家门口的垃圾）
虚拟机（环卫工人）
虚拟机（环卫工人）--- 会随即清除垃圾 
你调用System.gc() = 告诉虚拟机（环卫工人）我这里有垃圾；
结果 他可能会马上过来 也可能会等他有空的时候再来 （不存在强制）
所以 调用System.gc() 等于告诉他  我这里有垃圾  仅此而已。

3.Java接口的修饰符可以为：

  • A. private
  • B. protected
  • C.final
  • D.abstract
1
2
3
4
5
6
7
8
9
10
D

在定义接口时，只要记住三点：
1.接口必须为public abstract，因为接口是高度抽象的类，它的存在就是被其他类实现。
2.接口中声明的变量必须为 public static final。
3.接口中定义的方法必须为public abstract，且没有方法体。当然java8新增“default”与static方法，可以方法实现
链接：https://www.nowcoder.com/questionTerminal/45910275c36f4b3fb9abdd00078d136e
来源：牛客网

接口 只能用 public 和 abstract 修饰。only public & abstract are permitted 。

4.以下所发正确的是()

  • A：Integer 继承 Number

  • B：Integer 是基本数据类型

  • C： Long a = new Long(30000)

    Long b = 30000

    ​ a == b

    ​ 返回true

  • D：String类可以被继承

1
2
3
4
5
6
7
8
A

B Integer不是基本数据类型
C Long a = new Long(3000);
  Long b = 30000l;
  a= b;
D 不可以，因为String类有final修饰符，而final修饰的类是不能被继承的，实现细节不允许改变。
public final class String implements java.io.Serializable, Comparable<String>, CharSequence

5.以下说法哪个是正确的()

1
2
3
4
5
6
7
8
9
B C

A volatile不能保证线程安全而synchronized可以保证线程安全。

volatile只能保证被其修饰变量的内存可见性，但如果对该变量执行的是非原子操作线程依旧是不安全的。

而synchronized既可以保证其修饰范围内存可见性和操作的原子性，所以synchronized是线程安全的

D CopyOnWriteArrayList适合读多写少的情况

6.关于sleep()和wait()，以下描述错误的一项是（）

1
D 获得锁之后进入就绪状态而不是运行状态

一. 线程状态类型

1. 新建状态（New）：新创建了一个线程对象

2. 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权

3. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码

4. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中

（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中

(三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态

5. 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期

线程状态图

img

7.下面能让线程停止执行的有（）

1
2
3
4
5
B

Thread.yield()方法：

使当前线程从执行状态（运行状态）变为可执行态（就绪状态）。

8.关于异常(Exception)，下列描述正确的是()

1
2
3
A,B,C

Error继承自Throwable类

9.关于类加载器，以下说法正确的是：（）

1
2
3
4
5
6
7
C

A 类的加载是由类加载器完成的，类加载器包括：根加载器（ BootStrap ）、扩展加载器（ Extension ）、系统加载器（ System ）和用户自定义类加载器（ java.lang.ClassLoader 的子类）。

B 不能

D 开发人员可以通过继承java.lang.ClassLoader类的方式实现自己的类加载器

10.In Spring Framework, What is the constructor mode of autowiring: （）

1
看不懂

11.What is the purpose of limit method of stream api in java 8: ()

  • A. Iterate each element of the stream
  • B. Map each element to its corresponding result
  • C. Eliminate elements based on a criteia
  • D. Reduce the size of the stream
1
D 返回 Stream 的前面 n 个元素

12.请写出下面程序输出结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// begin
public class Obparm {

    public static void main(String[] args) {

        Obparm o = new Obparm();
        o.amethod();

    }

    public void amethod() {
        int i = 99;
        ValHold v = new ValHold();
        v.i = 30;
        another(v,i);
    }

    public void another(ValHold v,int i) {
        i=0;
        v.i = 20;
        ValHold vh = new ValHold();
        v = vh;
        System.out.println(v.i + " " + i);
    }
}
class ValHold{
    public int i = 10;
}
// end
1
10 0

13.请写出下面程序的运行结果：

1
2
3
4
5
6
7
String str1 = "hello";
String str2 = "he" + new String("llo");
System.out.println(str1 == str2);
System.out.println(str1.equals(str2));
System.out.println(str1 == str2 ? "" : "1");
String str3 = new String("hello").intern();
System.out.println(str1 == str3);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
false
true
1
true

1）String类是final类，也即意味着String类不能被继承，并且它的成员方法都默认为final方法。在Java中，被final修饰的类是不允许被继承的，并且该类中的成员方法都默认为final方法。

2）String类底层是char数组来保存字符串的。

对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象

String str1 = "hello";

这里的str1指的是方法区中的字符串常量池中的“hello”，编译时期就知道的； 

这里的str2必须在运行时才知道str2是什么，所以它是指向的是堆里定义的字符串“hello”，所以这两个引用是不一样的。

如果用str1.equal(str2)，那么返回的是true；因为String类重写了equals()方法。

编译器没那么智能,它不知道"he" + new String("llo")的内容是什么,所以才不敢贸然把"hello"这个对象的引用赋给str2.

new String("zz")实际上创建了2个String对象，就是使用“zz”通过双引号创建的（在字符串常量池），另一个是通过new创建的（在堆里）。只不过他们的创建的时期不同，一个是编译期，一个是运行期。

String s = "a"+"b"+"c";

语句中，“a”,"b", "c"都是常量，编译时就直接存储他们的字面值，而不是他们的引用，在编译时就直接将它们连接的结果提取出来变成"abc"了。


String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；

14.请写出下面程序当执行 new B(“s”)时的输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class A {

    String s;

    public A() {
        System.out.println(1);
    }

    public A(String s) {
        System.out.println(2);
        this.s = s;
    }

}

public class B extends A{

    B b;

    public B(String s) {
        System.out.println(3);
        this.s = s;
        b = new B();
    }

    public B() {
        System.out.println(4);
    }

}
1
2
3
4
1
3
1
4

15.请写出下面程序输出结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class A {

    static A test = new A();
    static int a;
    static int b = 0;

    static {
        System.out.println(A.a + " " + A.b );
    }

    public A() {
        a++;
        b++;
    }

    public static void main(String[] args) {
        System.out.println(A.a + " " + A.b);
    }

}
1
2
3
运行结果：
1 0
1 0

16.If the method below is being concurrently invoked(There are n other methods),is there any potential danger of the code? If so,please simply describe this danger.

1
2
3
4
5
6
7
8
public void aMetod(A a1, A a2) {
    synchronized (a1) {
        doSth();
        synchronized (a2) {
            doSth2();
        }
    }
}

dead lock

死锁

17.参考一下程序代码，回答问题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class A {

    public synchronized static void m1() {}
    public synchronized static void m2() {}
    public synchronized void m3() {}
    public synchronized void m4() {}

    public void start() {
        
        final A a  = new A();
        final A a2 = new A();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                A.m1();
                a.m3();
            }
        },"T1").start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                A.m1();
                A.m2();
                a.m3();
                a.m4();
                a2.m3();
            }
        },"T2").start();
        
    }
}

start方法中启动的两个线程T1,T2,以下选项正确的是（）

  • A. T1, T2能同时并发访问A.m1()方法
  • B. T1访问A.m1()方法，T2访问A.m2()方法，这样能并发访问
  • C. T1,T2能同时并发访问a.m3()方法
  • D. T1访问a.m3()方法，T2访问a.m4()方法，这样能并发访问
  • E. T1访问a.m3()方法，T2访问a2.m3()方法，这样能并发访问
1
2
3
4
5
E

1. 对于实例同步方法，锁是当前实例对象。
2. 对于静态同步方法，锁是当前对象的Class对象。
3. 对于同步方法块，锁是Synchronized括号里配置的对象。

参考文章

探讨Java中static synchronized和synchronized

打赏
  • 版权声明： 本博客所有文章除特别声明外，著作权归作者所有。转载请注明出处！
  • Copyrights © 2015-2023 高行行
  • 访问人数: | 浏览次数:

请我喝杯咖啡吧~

支付宝
微信