2019年11月11日 java1

发表于 更新于 分类于 ， ， ， Waline： 本文字数： 4.7k 阅读时长 ≈ 4 分钟

考点1

What will be printed when you execute the following code?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class C {
    C() {
        System.out.print("C");
    }
}
class A {
    C c = new C();
    A() {
        this("A");
        System.out.print("A");
    }
    A(String s) {
        System.out.print(s);
    }
}
class Test extends A {
    Test() {
        super("B");
        System.out.print("B");
    }
    public static void main(String[] args) {
        new Test();
    }
}
  • A BB
  • B CBB
  • C BAB
  • D None of the above

解析

显示答案/隐藏答案正确答案: B

父类和子类的初始化顺序

  1. 父类静态初始化代码，包括静态初始化块，或者静态变量声明。
  2. 子类静态初始化代码，包括静态初始化块，或者静态变量声明。
  3. 父类实例初始化块
  4. 父类构造器
  5. 子类实例初始化块
  6. 子类构造器

考点2

说明输出结果。

1
2
3
4
5
6
7
8
9
10
11
package test;
import java.util.Date;
public class SuperTest extends Date{
    private static final long serialVersionUID = 1L;
    private void test(){
        System.out.println(super.getClass().getName());
    }public static void main(String[]args){
        new SuperTest().test();
    }
}

  • A SuperTest
  • B SuperTest.class
  • C test.SuperTest
  • D test.SuperTest.class

解析

显示答案/隐藏答案正确答案: C
  • Object的getClass方法是final的,所以TestSuper和Date都不能重写getClass方法。
  • 调用的都是Object的getClass方法，而Object的getClass作用是返回的是运行时的类的名字。这个运行时的类就是当前类SuperTest
  • class对象.getName()的返回返回值为:包名+类名

考点3

以下说法中正确的有？

  • A StringBuilder是 线程不安全的
  • B Java类可以同时用 abstract和final声明
  • C HashMap中,使用 get(key)==null可以 判断这个Hasmap是否包含这个key
  • D volatile关键字不保证对变量操作的原子性

解析

显示答案/隐藏答案正确答案: AD
  • abstract修饰的类是抽象类，是可以继承的，而final修饰的类表示不能再被继承，故肯定不能共同使用。故B错。
  • HashMap中提供的get(key)获取的是变量，无法判断是否存在key。所以C是错的
  • volatile关键字是一种轻量级的同步机制，只保证数据的可见性，而不保证数据的原子性。故D对

考点4

Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持,下面关于Java反射的描述，哪些是错误的:( )

  • A Java反射主要涉及的类如Class, Method, Filed,等，他们都在java.lang.reflet包下
  • B 通过反射可以动态的实现一个接口，形成一个新的类，并可以用这个类创建对象，调用对象方法
  • C 通过反射，可以突破Java语言提供的对象成员、类成员的保护机制，访问一般方式不能访问的成员
  • D Java反射机制提供了字节码修改的技术，可以动态的修剪一个类
  • E Java的反射机制会给内存带来额外的开销。例如对永生堆的要求比不通过反射要求的更多
  • F Java反射机制一般会带来效率问题，效率问题主要发生在查找类的方法和字段对象，因此通过缓存需要反射类的字段和方法就能达到与之间调用类的方法和访问类的字段一样的效率

解析

显示答案/隐藏答案正确答案: ADF

反射指的是在运行时能够分析类的能力的程序。
反射机制可以用来：
1.Field、Method、Constructor位于java.lang.reflect包中。Class类在java.lang中。
2.在运行时查看对象。
3.实现通用的数组操作代码。

反射机制的功能：
在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
反射机制常见作用：
动态加载类、动态获取类的信息（属性、方法、构造器）；动态构造对象；动态调用类和对象的任意方法、构造器；动态调用和处理属性；获取泛型信息（新增类型：ParameterizedType,GenericArrayType等）；处理注解（反射API:getAnnotationsdeng等）。
反射机制性能问题：
反射会降低效率。
void setAccessible(boolean flag):是否启用访问安全检查的开关，true屏蔽Java语言的访问检查，使得对象的私有属性也可以被查询和设置。禁止安全检查，可以提高反射的运行速度。
可以考虑使用：cglib/javaassist操作。

考点5

在异常处理中,若try中的代码可能产生多种异常则可以对应多个catch语句，若catch中的参数类型有父类子类关系，此时应该将父类放在后面，子类放在前面。

  • A 正确
  • B 错误

解析

显示答案/隐藏答案正确答案: A

如果将父类放在前面的话，异常将被父类完全捕获，子类永远不能捕获异常

考点6

如何跳出Array的forEach循环？( )

  • A break
  • B return true
  • C return false
  • D 以上都不是

解析

显示答案/隐藏答案正确答案: A

foreach循环是for循环的增强版,for循环怎么跳,foreach就怎么跳。
这里让人迷惑分点就是这个Array，不要理解成ArrayList的forEach方法。

考点7

下列哪个选项是Java调试器？如果编译器返回程序代码的错误,可以用它对程序进行调试。

  • A java.exe
  • B javadoc.exe
  • C jdb.exe
  • D javaprof.exe

解析

显示答案/隐藏答案正确答案: C
  • javac.exe是编译.java文件
  • java.exe是执行编译好的.class文件
  • javadoc.exe是生成Java说明文档
  • jdb.exe是Java调试器
  • javaprof.exe是剖析工具

jdb是”java debuger”的简写

考点8

ResultSet中记录行的第一列索引为？

  • A -1
  • B 0
  • C 1
  • D 以上都不是

解析

显示答案/隐藏答案正确答案: C

ResultSet跟普通的数组不同，索引从1开始而不是从0开始

考点9

下列关于final、finally、finalize说法正确的是( )

  • A final可以用来修饰类、方法、变量
  • B finally是java保证重点代码一定要被执行的一种机制
  • C 变量被final修饰后不能再指向其他对象,但可以重写
  • D finalize设计的目的是保证对象在被垃圾收集前完成特定资源的回收

解析

显示答案/隐藏答案正确答案: ABD

finalize()是Object的方法，子类可以覆盖该方法以实现资源清理工作的目的，GC会在回收对象之前调用该方法
final修饰的变量也不能重写(重新赋值)

考点10

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
public class NameList{
    private List names = new ArrayList();
    public synchronized void add(String name){
        names.add(name);
    }
    public synchronized void printAll() {
        for(int i = 0;i < names.size();i++){
            System.out.print(names.get(i) + "");
        }
    }
    public static void main(String[]args){
        final NameList sl = new NameList();
        for(int i = 0;i < 2;i++){
            new Thread(){
                public void run(){
                    sl.add("A");
                    sl.add("B");
                    sl.add("C");
                    sl.printAll();
                }
            }
             .start();
        }
    }
}

Which two statements are true if this class is compiled and run?

  • A An exception may be thrown at runtime.
  • B The code may run with no output, without exiting.
  • C The code may run with no output, exiting normally(正常地).
  • D The code may rum with output “A B A B C C “, then exit.
  • E The code may rum with output “A B C A B C A B C “, then exit.
  • F The code may ruin with output “A A A B C A B C C “, then exit.
  • G The code may ruin with output “A B C A A B C A B C “, then exit.

解析

显示答案/隐藏答案正确答案: EG

首先最主要的是，有两条线程在同时进行。

  • 线程内的是顺序进行，
  • 线程之间的顺序不定，可能是交叉执行，也有可能是先执行了一个线程后执行了另一个线程。

但是无论怎样，两个线程不可能同时执行一个操作，这就说明
执行慢的那个线程s1.println();这行代码将会打印出完整的6个字符的字串（但是两个进程添加顺序不确定，有可能是ABCABC，也有可能最后字串是AABBCC或ABABCC等），这就意味着最后6个字符就是真正的添加顺序。
根据逻辑判断，第一次s1.println()结束时，可能两个线程添加都已经添加完，此时第一次s1.println()输出字符最多6个，第二次s1.println()输出字符个数是6个，也就是最多输出12个。
最少的情况，也就是s1.println()结束时，只有第一个线程进行了add()操作，此时字符输出最少3个，第二次是6个，也就是9个。
也就是输出的字符串个数一定在9~12个之间。所以A、B、C、D排除。
所以看选项E的话，最后字串是ABCABC，那第一次s1.println()操作可能在第一个s1.add(“c”)操作结束到第二个s1.add(“c”)操作之间。比如：(ABC)ABCABC、(ABCA)ABCABC、(ABCAB)ABCABC、(ABCABC)ABCABC。这些都是可能的输出，所以G也正确。所以E、G正确
而选项F。最后6个字符是BCABCC。首先这不可能，因为虽然添加字符顺序是不确定的，但是确定的是第一个添加的字符肯定是A，并且字符串必须由2个A、2个B、2个C组成。

这题烧脑