java测试复盘7（2019.9.19）

java测试复盘

1. 下列哪个类的声明是正确的？ D*
   A.abstract final class HI{}
   B.abstract private move(){}
   C.protected private number;
   D.public abstract class Car{}
   解析：选项A错误，abstract与final不能同时出现在类声明中；选项B错误，类不能声明为private，缺少Class关键字；选项C错误，类不能声明为protected和private两种属性，且不以“;”结尾，也缺少Class关键字；选项D正确，声明了一个可以公有继承的抽象类。

2. 执行如下代码后输出结果为（ ） C*

    public class Test {public static void main(String[] args) {System.out.println("return value of getValue(): " + getValue());}public static int getValue() {int i = 1;try {i = 4;} finally{i++;return i;}}}

A.return value of getValue(): 1
B.return value of getValue(): 4
C.return value of getValue(): 5
D.其他几项都不对
解析：c.try只适合处理运行时异常，try+catch适合处理运行时异常+普通异常。也就是说，如果你只用try去处理普通异常却不加以catch处理，编译是通不过的，因为编译器硬性规定，普通异常如果选择捕获，则必须用catch显示声明以便进一步处理。而运行时异常在编译时没有如此规定，所以catch可以省略，

3. 接口不能扩展（继承）多个接口。（ ） B*
   A.正确
   B.错误
   解析：java类是单继承的， java接口可以多继承。

4. 关于依赖注入，下列选项中说法错误的是（）B*
   A.依赖注入能够独立开发各组件，然后根据组件间关系进行组装
   B.依赖注入使组件之间相互依赖，相互制约
   C.依赖注入提供使用接口编程
   D.依赖注入指对象在使用时动态注入
   解析：依赖注入目的是减少组件之间的耦合度，使开发变得简单。

5. 下面关于垃圾收集的说法正确的是 D*
   A.一旦一个对象成为垃圾，就立刻被收集掉。
   B.对象空间被收集掉之后，会执行该对象的finalize方法
   C.finalize方法和C++的析构函数是完全一回事情
   D.一个对象成为垃圾是因为不再有引用指着它，但是线程并非如此
   解析：对象空间被收集前执行finalize（）方法，而不是对象空间被收集之后再执行，如果这样的话执行finalize（）就没有意义了。

6. 下面哪个选项正确创建socket连接？ B*
   A.Socket s = new Socket(8080);
   B.Socket s = new Socket(“192.168.1.1”,8080)
   C.SocketServer s = new Socket(8080);
   D.Socket s = new SocketServer(“192.168.1.1”,8080)
   解析：这题主要是区别号客户端和服务端的创建方法
   客户端对象:Socket s = new Socket(“127.0.0.1”,6666);
   服务端对象:ServerSocket ss = new ServerSocket(6666);
   监听服务器的连接:
   s=ss.accept()

7. 下列代码编译和运行的结果是：（） C*

public class Threads4{public static void main(String[] args){new Threads4().go();}public void go(){Runnable r=new Runnable(){public void run(){System.out.print("foo");}};Thread t=new Thread(r);t.start();}}

A.编译错误
B.抛出运行时异常
C.输出：foo
D.代码正常运行，但是无输出
解析：调用go方法，go方法内实现多线程打印foo。

8. 关于以下程序代码的说明正确的是? D*

 public class HasStatic{private static int x=100;public static void main(String args[]){HasStatic hs1=new HasStatic();hs1.x++;HasStatic  hs2=new HasStatic();hs2.x++;hs1=new HasStatic();hs1.x++;HasStatic.x--;System.out.println("x="+x);}} 

A.程序通过编译，输出结果为：x=103
B.10行不能通过编译，因为x是私有静态变量
C.5行不能通过编译，因为引用了私有静态变量
D.程序通过编译，输出结果为：x=102
解析：首先要了解static的意思。
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
static变量在第一次使用的时候初始化，但只会有一份成员对象。
所以这里不仅可以调用，而且每一次调用都确实修改了x的值，也就是变化情况是这样的：
x=101
x=102
x=103
x=102

9. 假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？ A*

public class Base
{
public void methodOne()
{
System.out.print("A");
methodTwo();
}
public void methodTwo()
{
System.out.print("B");
}
public class Derived extends Base
{
public void methodOne()
{
super.methodOne();
System.out.print("C");
}
public void methodTwo()
{
super.methodTwo();
System.out.print("D");
}
}

A.ABDC
B.AB
C.ABCD
D.ABC
解析：这是一道类多态的向上转型题。
Base b = new Derived();
向上转型：父类只能调用父类方法或者子类覆写后的方法,而子类中的单独方法则是无法调用的。

10. 下列函数定义中，有语法错误的是（） D*
    A.void fun(int x, int y){x = *y;}
    B.int * fun(int *x, int y){return x += y;}
    C.void fun(int *x, int y){*x += y;}
    D.void fun(int x, int y){*x = *y;}
    解析：暂无

11. 下面哪个语句是创建数组的正确语句？( ) ABDE*
    A.float f[][] = new float[6][6];
    B.float []f[] = new float[6][6];
    C.float f[][] = new float[][6];
    D.float [][]f = new float[6][6];
    E.float [][]f = new float[6][];
    解析：数组表示，共6种，等号左边3种，等号右边2种
    

12. 在 java 中 , 一个类（） B*
    A.可以继承多个类
    B.可以实现多个接口
    C.在一个程序中只能有一个子类
    只能实现一个接口
    解析：暂无

13. 有以下程序片段且Interesting不是内部类，下列哪个选项不能插入到行1。（ ） D*

public class Interesting{// 省略代码}

A.import java.awt.*;
B.package mypackage;
C.class OtherClass{ }
D.public class MyClass{ }
解析：在同一个java原文件中，可以有多个class类，但是只有有一个公共的 public class

14. 基本的Java语言函数存储在以下哪个java包中？（） A*
    A.java.lang
    B.java.io
    C.java.net
    D.java.util
    解析：暂无

15. 以下程序的运行结果是？A*
    
    A.foobar
    B.barfoo
    C.foobar或者barfoo都有可能
    D.Bar
    E.Foo
    F.程序无法正常运行
    解析：foobar 这道题是考线程的调用情况，线程的启动方式只能通过start这种方式启动才能真正的实现多线程的效果，如果是手动调用run方法和普通方法调用没有区别，所以这个还是按照顺序执行首先执行run方法之后，执行输出语句所以最终得到结果foobar.

16. Given:

//point X
public class Foo {public static void main(String[] args) throws Exception {PrintWriter out = new PrintWriter(new java.io.OutputStreamWriter(System.out), true);out.printIn(“Hello”)；}
}

Which statement at PointX on line I allows this code to compile and run? A*
A.import java.io.PrintWriter;
B.include java.io.PrintWriter;
C.import java.io.OutputStreamWriter;
D.include java.io.OutputStreamWriter;
E.no statement is needed.
解析：java中没有include关键字，导包用import
由于代码中使用了printWriter 类，所以要导入此类Import java.io.PrintWriter;

17. 下列叙述中，错误的是（ ）B*
    A.File类能够存储文件属性
    B.File类能够读写文件
    C.File类能够建立文件
    D.File类能够获取文件目录信息
    解析：文件File是java.io包中的一个重要的非流类，以一种系统无关的方式表示一个文件对象的属性。通过File所提供的方法，可以得到文件或文件夹的描述信息(包括名字、路径、长度、可读、可写等)，也可以生成新文件、文件夹，修改文件和文件夹，查询文件属性，重命名文件或者删除文件。File描述了文件本身的属性，File类中封装了对文件系统进行操作的功能。简单说，File类所关心的是文件在磁盘上的存储，而要对文件进行读写，就是流类所关心的文件内容，应该掌握相关概念以及相关方法

18. 下列在Java语言中关于数据类型和包装类的说法，正确的是（） B*
    A.基本（简单）数据类型是包装类的简写形式，可以用包装类替代基本（简单）数据类型
    B.long和double都占了64位（64bit）的存储空间。
    C.默认的整数数据类型是int，默认的浮点数据类型是float。
    和包装类一样，基本（简单）数据类型声明的变量中也具有静态方法，用来完成进制转化等。
    解析：A，包装和基本类型不是同一个概念
    B，long和double都占了64位（64bit）的存储空间
    C，默认的浮点数据类型是double，如果要指明使用float，则需要在后面加f
    D，基本数据类型是没有静态方法的，但是基本数据类型的包装类却有

19. 以下说法错误的是（） D*
    A.虚拟机中没有泛型，只有普通类和普通方法
    B.所有泛型类的类型参数在编译时都会被擦除
    C.创建泛型对象时请指明类型，让编译器尽早的做参数检查
    D.泛型的类型擦除机制意味着不能在运行时动态获取List中T的实际类型
    解析：1虚拟机中没有泛型，只有普通类和普通方法
    2 所有泛型类的类型参数在编译时都会被擦除
    3.创建泛型对象时请指明类型，让编译器尽早的做参数检查（Effective Java，第23条：请不要在新代码中使用原生态类型）
    4.不要忽略编译器的警告信息，那意味着潜在的ClassCastException等着你。

20. 为 AB 类的一个无形式参数无返回值的方法 method 书写方法头，使得使用类名 AB 作为前缀就可以调用它，该方法头的形式为（ ）。 A*
    A.static void method( )
    B.public void method( )
    C.final void method( )
    D.abstract void method( )
    解析：选A 只有静态方法才能被类名调用。
    B、一般方法，只能被实例对象调用
    C、final修饰方法，只是说明本方法不能被重写。
    D、abstract修饰方法，表示本方法为抽象方法，没有方法体，且抽象方法必须在抽象类中，但是抽象类中可以没有抽象方法。

21. 类中的数据域使用private修饰为私有变量，所以任何方法均不能访问它。 B*
    A.正确
    B.错误
    解析：本类的方法可以访问
    2、反射也可以访问

22. 下列关于构造函数的描述正确的是? C*
    A.构造函数可以声明返回类型
    B.构造函数不可以用private修饰
    C.构造函数必须与类名相同
    D.构造函数不能带参数
    解析：对于A 既然是构造函数 就没有声明返回值的必要
    对于B 构造函数有多种方式 所以是可以用private的 只是在外部这种方法不能给实例化
    对于C 既然要构造这个函数 所以肯定是要保持他和类名一样才能实例化这个类
    对于D 可以是无参数的构造函数

23. 以下关于Integer与int的区别错误的是 D*
    A.int是java提供的8种原始数据类型之一
    B.Integer是java为int提供的封装类
    C.int的默认值为0
    D.Integer的默认值为1
    解析：integer是类名

24. 下面关于静态方法说明正确的是 B*
    A.在静态方法中可用this来调用本类的类方法
    B.在静态方法中调用本类的静态方法时可直接调用
    C.在静态方法中只能调用本类中的静态方法
    D.在静态方法中绝对不能调用实例方法
    解析：A：静态方法没有this。
    C：静态方法中可以调用其他类的静态方法，比如我们经常用的println。
    D：静态方法可以通过创建类的实例来调用实例方法。

25. 针对下面的代码块,哪个equal为true:（） A*

  String s1 = "xiaopeng" ;String s2 = "xiaopeng" ;String s3 =new String (s);

A.s1 == s2
B.s1 = s2
C.s2 == s3
D.都不正确
解析：string是final修饰的，会将创建的变量放入字符串常量池，当再创建同样的字符串时，发现常量池中有则直接使用

26. 关于继承和实现说法正确的 是 ( ) A*
    A.类可以实现多个接口，接口可以继承（或扩展）多个接口
    B.类可以实现多个接口，接口不能继承（或扩展）多个接口
    C.类和接口都可以实现多个接口
    D.类和接口都不可以实现多个接口
    解析：.类与类之间的关系为继承，只能单继承，但可以多层继承。 2.类与接口之间的关系为实现，既可以单实现，也可以多实现。 3.接口与接口之间的关系为继承，既可以单继承，也可以多继承。

27. 以下程序的输出结果是 A*

public class Print{static boolean out(char c){System.out.println(c);return true;}public static void main(String[] argv){int i = 0;for(out('A');out('B') && (i<2);out('C')){i++;out('D');}}
}

A.ABDCBDCB
B.BCDABCD
C.编译错误
D.运行错误
解析：for循环执行开始 首先执行out(‘A’) 输出A； 然后执行out(‘B’)&&(i<2)此时输出B，i=0，判断条件为真，执行for循环的循环体； 执行i++，out(‘D’)，输出D i=1； 执行out(‘C’),输出C 然后执行out(‘B’)&&(i<2) 此时输出B，i=1 判断条件为真 ，执行for循环的循环体； 执行i++，out(‘D’)，输出D i=2； 执行out(‘C’),输出C 然后执行out(‘B’)&&(i<2) 此时输出B，i=2，不满足i<2 判断条件为假 ，跳出循环；

28. 以下程序会输出什么 C*

int a =100,b=50,c=a---b,d=a---b;System.out.println(a);System.out.println(b);System.out.println(c);System.out.println(d);

A.100 48 48 49
B.100 49 48 52
C.98 50 50 49
D.98 50 50 48
解析：a两次自减得98，b没有变化，c=a没有变化前减去b，d=a自减一次后减去b。

static String str0="0123456789";
static String str1="0123456789";
String str2=str1.substring(5);
String str3=new String(str2);
String str4=new String(str3.toCharArray());
str0=null;

假定str0,…,str4后序代码都是只读引用。
Java 7中，以上述代码为基础，在发生过一次FullGC后，上述代码在Heap空间（不包括PermGen）保留的字符数为（） C*
A.5
B.10
C.15
D.20
解析：java的垃圾回收机制garbage collection，简称GC。java语言不需要程序员直接控制垃圾回收，程序的内存分配和回收都是由JRE在后台自动进行的，JRE会回收哪些不再使用的内存，这种机制被称为垃圾回收。
垃圾回收主要针对的是堆区的回收，因为栈区的内存是随着线程而释放的。堆区分为三个区：年轻代（Young Generation）、年老代（Old Generation）、永久代（Permanent Generation，也就是方法区）。
年轻代：对象被创建时（new）的对象通常被放在Young（除了一些占据内存比较大的对象）,经过一定的Minor GC（针对年轻代的内存回收）还活着的对象会被移动到年老代（一些具体的移动细节省略）。
年老代：就是上述年轻代移动过来的和一些比较大的对象。Minor GC(FullGC)是针对年老代的回收
永久代：存储的是final常量，static变量，常量池。
substring实际是new，5字符；str3和4也都是new，每个5字符；分别都会创建新的对象；常量池是PermGen的；因此应该是一共15字符。

30. 下列不属于Java语言性特点的是 D*
    A.Java致力于检查程序在编译和运行时的错误
    B.Java能运行虚拟机实现跨平台
    C.Java自己操纵内存减少了内存出错的可能性
    D.Java还实现了真数组，避免了覆盖数据类型的可能
    解析：Java致力于检查程序在编译和运行时的错误。
    Java虚拟机实现了跨平台接口
    类型检查帮助检查出许多开发早期出现的错误。
    Java自己操纵内存减少了内存出错的可能性。
    Java还实现了真数组，避免了覆盖数据的可能。
    注意，是避免数据覆盖的可能，而不是数据覆盖类型

31. Test.main()函数执行后的输出是（ ） B*

class Test {public static void main(String[] args) {System.out.println(new B().getValue());}static class A {protected int value;public A (int v) {setValue(v);}public void setValue(int value) {this.value= value;}public int getValue() {try {value ++;return value;} finally {this.setValue(value);System.out.println(value);}}}static class B extends A {public B () {super(5);setValue(getValue()- 3);}public void setValue(int value) {super.setValue(2 * value);}}
}

A.6 7 7
B.22 34 17
C.22 74 74
D.11 17 34
解析：首先，super()函数指的是调用父类的构造方法
①
new B()
执行B的构造函数，第一行是super(5);
此时执行的是A的构造函数，A的构造函数调用的是setValue()方法，由于B重写了A的这个方法，
所以！！！执行的是B的 setValue()方法。
即传入的参数是25=10
此时，因为super，所以调用的是父类的 setValue()方法，即value=10
第一行执行完毕。
第二行是 setValue(getValue()-3);
B没有getValue()方法，故执行父类的此方法，
try返回的是value=10+1=11，保存在临时栈中
finally中调用this的方法，这个this指的是B的对象，又重写，故就是B的 setValue()方法
value=211=22，第一个打印到屏幕上的数字
接下来参数 getValue()-3=11-3=8
传入B的 setValue()方法
此时value=28=16
至此，new B()执行结束
②
new B(). getValue()
B没有 getValue()，故执行A的 getValue()
try返回16+1=17，保存到临时栈中
finally调用B的 setValue()方法
value=172=34，第二个打印到屏幕上面的数字
最后主函数打印返回值，也就是try保存到临时栈的17
1
答案就是：22,34,17

32. 下面有关struts1和struts2的区别，描述错误的是？ B*
    A.Struts1要求Action类继承一个抽象基类。Struts 2 Action类可以实现一个Action接口
    C.Struts1 Action对象为每一个请求产生一个实例。Struts2 Action是单例模式并且必须是线程安全的
    C.Struts1 Action 依赖于Servlet API，Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试
    D.Struts1 整合了JSTL，Struts2可以使用JSTL，但是也支持OGNL
    解析：从action类上分析:
    1Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。
    2.Struts 2 Action类可以实现一个Action接口，也可实现其他接口，使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现常用的接口。Action接口不是必须的，任何有execute标识的POJO对象都可以用作Struts2的Action对象。
    从Servlet 依赖分析:
    3 Struts1 Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
    4Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和response。但是，其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。
    从action线程模式分析:
    5 Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
    6Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）

33. (多选)下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：() AE*
    A.java.util.ConcurrentHashMap
    B.java.util.Map
    C.java.util.TreeMap
    D.java.util.SortMap
    E.java.util.Hashtable
    F.java.util.HashMap
    解析：Hashtable的方法都是synchrnized修饰的线程安全，ConcurrentHashMap并发容器，JDK7采用分段锁，JDK8采用CAS算法，线程安全，建议使用，Connections工具类提供了一个方法synchrnizedMap可以把Map同步，本质就是给每一个方法加上synchrnized关键字进行同步

34. （多选）关于虚函数，下面哪些描述是正确的 （ ） DF*
    A.虚函数是实现方法重载的工具
    B.Java中所有的函数都是虚函数
    C.通过虚函数，类体系获得了多态性支持
    D.虚函数必须在子类中实现
    E.虚函数不能够被子类继承
    F.在C++中，基类的析构函数建议为虚析构函数
    解析：暂无

35. 假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？ A*

public class Base
{
public void methodOne()
{
System.out.print("A");
methodTwo();
}public void methodTwo()
{
System.out.print("B");
}
}
public class Derived extends Base
{
public void methodOne()
{
super.methodOne();
System.out.print("C");
}public void methodTwo()
{
super.methodTwo();
System.out.print("D");
}
}

A.ABDC
B.AB
C.ABCD
D.ABC
解析：这是一道类多态的向上转型题。
Base b = new Derived();
向上转型：父类只能调用父类方法或者子类覆写后的方法,而子类中的单独方法则是无法调用的

36. (多选)
    对Collection和Collections描述正确的是 BD*
    A.Collection是java.util下的类，它包含有各种有关集合操作的静态方法
    B.Collection是java.util下的接口，它是各种集合结构的父接口
    C.Collections是java.util下的接口，它是各种集合结构的父接口
    D.Collections是java.util下的类，它包含有各种有关集合操作的静态方法
    解析：java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。
    java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

37. (多选)
    JDK提供的用于并发编程的同步器有哪些？ ABC*
    A.Semaphore
    B.CyclicBarrier
    C.CountDownLatch
    D.Counter
    解析：A，Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。
    B，CyclicBarrier 主要的方法就是一个：await()。await() 方法没被调用一次，计数便会减少1，并阻塞住当前线程。当计数减至0时，阻塞解除，所有在此 CyclicBarrier 上面阻塞的线程开始运行。
    C，直译过来就是倒计数(CountDown)门闩(Latch)。倒计数不用说，门闩的意思顾名思义就是阻止前进。在这里就是指 CountDownLatch.await() 方法在倒计数为0之前会阻塞当前线程。
    D，Counter不是并发编程的同步器

38. 关于java中的数组，下面的一些描述，哪些描述是准确的：（） ACE*
    A.数组是一个对象，不同类型的数组具有不同的类
    B.数组长度是可以动态调整的
    C.数组是一个连续的存储结构
    D.一个固定长度的数组可类似这样定义：int array[100]
    E.两个数组用equals方法比较时，会逐个便利其中的元素，对每个元素进行比较
    F.可以二维数组，且可以有多维数组，都是在java中合法的。
    解析：数组的长度是固定的，int[] array =new array[100]就对了，所以BD错。java中只有一维数组吧，二维数组是一维数组对一维数组的引用。F错。