专项练习-04编程语言-03JAVA-05

1.
设有下面两个类的定义：
class  Person {
    
    }
class  Student  extends  Person {
    
    
public int id;     //学号
public int score;  //总分
public String  name;   // 姓名
public int getScore(){
    
    return  score;}
}
类Person和类Student的关系是（）。
A
包含关系
B
继承关系
C
关联关系
D
无关系，上述类定义有语法错误
正确答案：B
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

2.
欲定义类字段或类方法（静态方法），应该使用下列哪一个修饰符修饰（）
A
public
B
static
C
protected
D
synchronized
正确答案：B
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

3.
以下不属于构造方法特征的是（）

A
构造方法名与类名相同
B
构造方法不返回任何值，也没有返回类型
C
构造方法在创建对象时调用，其他地方不能显式地直接调用
D
每一个类只能有一个构造方法
正确答案：D
官方解析：正确答案：D
D 选项描述错误，一个类可以有多个构造方法，形成重载关系。
知识点：C++、Java

4.
能使程序块显示字符串 "good" 的 x 值的范围 是 。
if (x>0)
    System.out.println("excellent");
else if (x>-3)
    System.out.println("good");
else
    System.out.println("normal");
A
x > 0
B
x > -3
C
x <= -3
D
-3 < x <= 0
正确答案：D
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

5.
类声明中，声明抽象类的关键字是 ( )
A
public
B
abstract
C
final
D
class
正确答案：B
参考答案：public 共有类，可以在包外使用，此时，源文件名必须和类名相同。 abstract 抽象类，抽象类位于继承树的抽象层，抽象类不能被实例化。 final 不能被继承，没有子类，final类中的方法默认是final的。 class 只能在包内使用的类
知识点：Java

6.
分析以下代码，说法正确的是（）
 public static void main(String[] args) {
    
    
     System.out.println(val());
 }
  
 public static int val() {
    
    
     int num = 5;
     try {
    
    
     num = num / 0;
 } catch (Exception e) {
    
    
     num = 10;
 } finally {
    
    
     num = 15;
 }
 return num;
 }

A
运行时报错
B
程序正常运行，输出值为5
C
程序正常运行，输出值为10
D
程序正常运行，输出值为15
正确答案：D
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、2019

7.
下面叙述错误的是 ( )

A
一个类可以有多个构造方法
B
最终类不能派生子类，最终方法不能被覆盖
C
如果一个类中没有定义构造方法，则Java在生成这个类的实例时不会调用构造方法。
D
数组一旦创建之后，就不能再改变其长度
正确答案：C
参考答案：本题选C A.一个类可以有多个构造方法，实际上就是方法的重载，正确 B.用final修饰的类不能被继承，方法不能被覆盖，正确 C.如果没有构造方法，编译器会自动添加一个空参构造方法，错误 D.由源码可知，数组内部采用字符数组存储，该字符数组用final修饰，长度一旦确定不可再变，正确 （答题不易，望采纳）
知识点：Java

8.
下列叙述错误的是（ ）

A
在接口中定义的方法除了default和static关键字修饰的方法拥有方法体，其他方法都应是没有方法体的抽象方法（JDK1.8以后）
B
一个java类只能有一个父类,但可以实现多个接口
C
在类声明中,用implements关键字声明该类实现的接口
D
定义接口时使用implements关键字。
正确答案：D
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

9.
Java 中，以下不是修饰符 final 作用的是( )。

A
修饰常量
B
修饰不可被继承的类
C
修饰不可变类
D
修饰不可覆盖的方法
正确答案：C
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

10.
transient 变量和下面哪一项有关？   
A
Cloneable
B
Serializable
C
Runnable
D
Comparable
正确答案：B
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、安卓工程师、测试工程师、2019、测试开发工程师

11.
下面程序的运行结果是：（    ）
public static void main(String args[]) {
    
    
 
    Thread t = new Thread() {
    
    
           public void run() {
    
    
                pong();
           }
     };
 
    t.run();
    System.out.print("ping");
}
 
   static void pong() {
    
    
     System.out.print("pong");
    }
 
    

A
pingpong
B
pongping
C
pingpong和pongping都有可能
D
都不输出
E
pong
F
ping
正确答案：B
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、C++工程师、iOS工程师、安卓工程师、运维工程师、前端工程师、算法工程师、PHP工程师、2017、测试工程师

12.
以下哪项陈述是正确的？
A
垃圾回收线程的优先级很高，以保证不再使用的内存将被及时回收
B
垃圾收集允许程序开发者明确指定释放哪一个对象
C
垃圾回收机制保证了JAVA程序不会出现内存溢出
D
进入”Dead”状态的线程将被垃圾回收器回收
E
以上都不对
正确答案：E
参考答案：答案：E A: 垃圾回收在jvm中优先级相当相当低。 B：垃圾收集器（GC）程序开发者只能推荐JVM进行回收，但何时回收，回收哪些，程序员不能控制。 C：垃圾回收机制只是回收不再使用的JVM内存，如果程序有严重BUG，照样内存溢出。 D：进入DEAD的线程，它还可以恢复，GC不会回收
知识点：Java

13.
Which statement is true for the class java.util.ArrayList?
A
The elements in the collection are ordered.
B
The collection is guaranteed to be immutable.
C
The elements in the collection are guaranteed to be unique.
D
The elements in the collection are accessed using a unique key.
E
The elements in the collections are guaranteed to be synchronized.
正确答案：A
参考答案：A Serializable, Cloneable , Iterable <E>, Collection <E>, List <E>, RandomAccess List接口是有序的，通常允许重复，因此可以确定A对，C错；ArrayList是实现List 接口的大小可变数组，所以B错；D是Map的特性，所以D错；查看手册： Note that this implementation is not synchronized.  ArrayList的实现是不是线程同步的，所以E错。
知识点：Java、数组、链表

14.
list是一个ArrayList的对象，哪个选项的代码填到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？（）
Iterator it = list.iterator();
int index = 0;
while (it.hasNext())
{
    
    
    Object obj = it.next();
    if (needDelete(obj))  //needDelete返回boolean，决定是否要删除
    {
    
    
        //todo delete
    }
    index ++;
}

A
it.remove();
B
list.remove(obj);
C
list.remove(index);
D
list.remove(obj,index);
正确答案：A
参考答案：A Iterator  支持从源集合中安全地删除对象，只需在 Iterator 上调用 remove() 即可。这样做的好处是可以避免 ConcurrentModifiedException ，当打开 Iterator 迭代集合时，同时又在对集合进行修改。有些集合不允许在迭代时删除或添加元素，但是调用 Iterator 的remove() 方法是个安全的做法。
知识点：Java

15.
下面有关SPRING的事务传播特性，说法错误的是？
A
PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行
B
PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就抛出异常
C
PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起
D
PROPAGATION_NESTED：支持当前事务，新增Savepoint点，与当前事务同步提交或回滚
正确答案：B
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Spring

16.
将下列哪个代码（A、B、C、D）放入程序中标注的【代码】处将导致编译错误？
class A{
    
    
    public float getNum(){
    
    
        return 3.0f;
    }
}
public class B extends A{
    
    
    【代码】
}

A
public float getNum(){
    
    return 4.0f;}
B
public void getNum(){
    
    }
C
public void getNum(double d){
    
    }
D
public double getNum(float d){
    
    return 4.0d;}
正确答案：B
官方解析：
Java重写有如下标准：

参数列表必须与被重写方法的相同。

重写方法不能限制比被重写方法更严格的访问级别

重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常

返回类型必须与被重写方法的返回类型相同。仅当返回值为类类型时，重写的方法才可以修改返回值类型，且必须是父类方法返回值的子类。

本题A选项符合要求，是正确的方法重写。

B选项返回值类型不同，不满足重写要求，B错误。

C、D选项并不是重写，只是一个同名函数。

综上所述答案选择B。

知识点：Java

17.
Integer i = 42;
Long l = 42l;
Double d = 42.0;
下面为true的是
A
(i == l)
B
(i == d)
C
(l == d)
D
i.equals(d)
E
d.equals(l)
F
i.equals(l)
G
l.equals(42L)
正确答案：G
参考答案：包装类的“==”运算在不遇到算术运算的情况下不会自动拆箱 包装类的equals()方法不处理数据转型
知识点：Java

18.
以下代码将打印出
 public static void main (String[] args) {
    
     
    String classFile = "com.jd.". replaceAll(".", "/") + "MyClass.class";
    System.out.println(classFile);
}
A
com. jd
B
com/jd/MyClass.class
C
///MyClass.class
D
com.jd.MyClass
正确答案：C
官方解析：本题有一处陷阱，replaceAll()函数的第一个参数是一个正则表达式，而"."在正则表达式中代表了全部的字符，因此"com.jd."会全部被替换成"/"。之后字符串正常拼接，输出"///MyClass.class"，答案选择C。如想仅仅替换"."，就需要使用转义字符"\\."
知识点：Java、正则表达式

19.
下面有关servlet和cgi的描述，说法错误的是？
A
servlet处于服务器进程中，它通过多线程方式运行其service方法
B
CGI对每个请求都产生新的进程，服务完成后就销毁
C
servlet在易用性上强于cgi，它提供了大量的实用工具例程，例如自动地解析和解码HTML表单数据、读取和设置HTTP头、处理Cookie、跟踪会话状态等
D
cgi在移植性上高于servlet，几乎所有的主流服务器都直接或通过插件支持cgi
正确答案：D
参考答案：选择D，servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。
知识点：Java

20.
以下代码的输出结果是？
public class B
{
    
    
    public static B t1 = new B();
    public static B t2 = new B();
    {
    
    
        System.out.println("构造块");
    }
    static
    {
    
    
        System.out.println("静态块");
    }
    public static void main(String[] args)
    {
    
    
        B t = new B();
    }
}

A
静态块 构造块 构造块 构造块
B
构造块 静态块 构造块 构造块
C
构造块 构造块 静态块 构造块
D
构造块 构造块 构造块 静态块
正确答案：C
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

21.
Test.main()函数执行后的输出是（ ）
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
正确答案：B
官方解析：
本题较为复杂，具体思路如下：

第一个数值

1.  new B()构造B类实例对象，进入B类的构造方法，B类构造方法的第一行代码用super(5)调用了父类带有参数的构造函数，父类的构造函数又调用了setValue()方法，但值得注意的是，子类中的方法覆盖父类的方法以后，由于向上转型，父类调用的方法实际上是子类的。那么这里的setValue(v);调用了B类的setValue()方法，而B类中setValue()方法又使用super关键字调用了父类的setValue()方法，将B实例的value值设置为2 x 5 = 10。那么到这里，B类的构造函数中第一行代码super(5)执行完毕，程序继续向下执行进入setValue(getValue()- 3);代码块。

2.  这里先执行getValue()方法，但因为B类中并没有重写该方法，这里需要调用父类的getValue()方法。进入A类getValue()方法，首先是value++，那么此时B的成员变量value值由 10变为11，程序继续向下执行，将11作为返回值，但此处要注意的一点是，在Try catch finally体系当中，在return之前始终会执行finally里面的代码，如果finally里面有return，则数据跟随finally改变。如果没有return，则原数据不跟随finally里改变的数据改变。那么进入finally代码块，由于此时正在初始化的是B类的一个对象（运行时多态），因此调用B类的setValue()方法。B类的setValue()方法中使用super关键字调用了父类的setValue()方法，将原有的value*2，即11 x 2 = 22，继续向下进行System.out.println(value);输出第一个数值22。随后，A类的getValue()方法将之前暂存的value=11返回。

第二个数值

1.  拿到getValue()方法返回值之后程序继续运行，此处代码变为setValue(11- 3);根据和之前相同的流程，B类成员变量value的值变为16。程序运行到此处，new B()执行完毕。

2.  回到main函数中，实例化的B类对象调用getValue()方法，B类中并没有重写该方法，需要调用父类的getValue()方法。getValue()方法第一行代码value++将B的成员变量value值变为17，此时执行到return代码，将value=17暂存，等待finally代码块运行完毕后返回。

3.  此处finally代码块执行流程和之前相同，这里不再赘述。那么执行完this.setValue(value);后，value值变为2 x 17 = 34。继续向下进行System.out.println(value);输出第二个数值34，return刚刚暂存的value=17。

第三个数值

回到main函数，将刚刚返回的值输出，就得到了第三个数值17。

综上所述，本题正确答案为B。

知识点：Java

22.
java中下面哪些是Object类的方法（）
A
notify()
B
notifyAll()
C
sleep()
D
wait()
正确答案：ABD
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

23.
下列关于final、finally、finalize说法正确的是（ ）
A
final可以用来修饰类、方法、变量
B
finally是java保证重点代码一定要被执行的一种机制
C
变量被final修饰后不能再指向其他对象，但可以重写
D
finalize设计的目的是保证对象在被垃圾收集前完成特定资源的回收
正确答案：ABD
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、安卓工程师、前端工程师、2019

24.
java运行时内存分为“线程共享”和“线程私有”两部分，以下哪些属于“线程共享”部分
A
程序计算器
B
方法区
C
java虚拟机栈
D
java堆
正确答案：BD
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、安卓工程师、测试工程师、2019、测试开发工程师

25.
在java中重写方法应遵循规则的包括（）
A
访问修饰符的限制一定要大于被重写方法的访问修饰符
B
可以有不同的访问修饰符
C
参数列表必须完全与被重写的方法相同
D
必须具有不同的参数列表
正确答案：BC
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、2018

26.
关于下面这段Java程序，哪些描述是正确的：（ ）
public class ThreadTest extends Thread {
    
    
    public void run() {
    
    
        System.out.println("In run");
        yield();
        System.out.println("Leaving run");
    }
    public static void main(String []argv) {
    
    
        (new ThreadTest()).start();
    }
}

A
程序运行输出只有In run
B
程序运行输出只有Leaving run
C
程序运行输出先有In run后有Leaving run
D
程序运行输出先有Leaving run后有In run
E
程序没有任何输出就退出了
F
程序将被挂起，只能强制退出
正确答案：C
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、2018

27.
关于Java中的ClassLoader下面的哪些描述是错误的：(    )
A
默认情况下，Java应用启动过程涉及三个ClassLoader: Boostrap, Extension, System
B
一般的情况不同ClassLoader装载的类是不相同的，但接口类例外，对于同一接口所有类装载器装载所获得的类是相同的
C
类装载器需要保证类装载过程的线程安全
D
ClassLoader的loadClass在装载一个类时，如果该类不存在它将返回null
E
ClassLoader的父子结构中，默认装载采用了父优先
F
所有ClassLoader装载的类都来自CLASSPATH环境指定的路径
正确答案：BDF
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、C++工程师、iOS工程师、安卓工程师、前端工程师、算法工程师、2017、测试工程师

28.
下面哪些赋值语句是正确的（）

A
long test=012
B
float f=-412
C
int other =(int)true
D
double d=0x12345678
E
byte b=128
正确答案：ABD
参考答案：选ABD A和B中long和float，正常定义需要加l和f，但是long和float属于基本类型，会进行转化，所以不会报出异常。AB正确 boolean类型不能和任何类型进行转换，会报出类型异常错误。所以C错。 D选项可以这样定义，D正确。 E选项中，byte的取值范围是-128—127。报出异常： cannot convert from int to byte.所以E选项错误。
知识点：Java

29.
以下哪些jvm的垃圾回收方式采用的是复制算法回收
A
新生代串行收集器
B
老年代串行收集器
C
并行收集器
D
新生代并行回收收集器
E
老年代并行回收收集器
F
cms收集器
正确答案：AD
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、C++工程师、运维工程师、前端工程师、算法工程师、PHP工程师、2016

30.
final、finally和finalize的区别中，下述说法正确的有？
A
final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
B
finally是异常处理语句结构的一部分，表示总是执行。
C
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源的回收，例如关闭文件等。
D
引用变量被final修饰之后，不能再指向其他对象，它指向的对象的内容也是不可变的。
正确答案：ABC
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

1.
有以下代码片段：
String str1="hello";
 
String str2="he"+ new String("llo");
 
System.out.println(str1==str2);
请问输出的结果是：
A
true
B
都不对
C
null
D
false
正确答案：D
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

2.
java语言中的数组元素下标总是从0开始，下标可以是非负整数。（）

A
正确
B
错误
正确答案：A
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

3.
以下关于Object类的说法正确的是（）

A
Java中所有的类都直接或间接继承自Object，无论是否明确的指明，无论其是否是抽象类。
B
Java中的接口(interface)也继承了Object类
C
利用“==”比较两个对象时，Java调用继承自Object的equals方法，判断是否相等。
D
如果类的定义中没有重新定义toString()方法，则该类创建的对象无法使用toStrig()方法。
正确答案：A
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

4.
下列关于Java语言中String和char的说法，正确的是（）

A
String是Java定义的一种基本数据类型。
B
String是以“\0”结尾的char类型的数组char[]。
C
使用equals()方法比较两个String是否内容一样（即字符串中的各个字符都一样）。
D
Char类型在Java语言里面存储的是ASCII码。
正确答案：C
官方解析：
 A选项：Java基本数据类型共有八大类，这八大数据类型又可分为四小类，分别是整数类型（byte/short/int/long）、浮点类型（float、double）、字符类型（char）和布尔类型（boolean），其中并不包括String。

B选项中是C语言当中的String，Java的String虽然也是char类型的数组char[]实现的，但并不以“\0”结尾。

C选项正确，String类重写了Object类的equals()方法，使用equals()方法可以用于比较两个String是否内容一样。

D选项， char 类型的编码是Unicode 编码。

知识点：Java

5.
以下定义一维数组的语句中，正确的是：（）
A
int a [10];
B
int a []=new [10];
C
int a []=new int [5]{
    
    1,2,3,4,5};
D
int a []={
    
    1,2,3,4,5};
正确答案：D
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

6.
有程序片段如下，以下表达式结果为 true 的是（ ）

Float  s=new  Float(0.1f);

Float  t=new  Float(0.1f);

Double  u=new  Double(0.1);

A
s==t
B
s.equals(t)
C
u.equals(s)
D
t.equals(u)
正确答案：B
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

7.
下面程序的运行结果：()
public static void main(String args[]) {
    
    
        Thread t=new Thread(){
    
    
        public void  run(){
    
    
            dianping();
             
        }
    };
    t.start();
    System.out.print("dazhong");
    }
    static void dianping(){
    
    
        System.out.print("dianping");
}
A
dazhongdianping
B
dianpingdazhong
C
a和b都有可能
D
dianping循环输出，dazhong夹杂在中间
正确答案：B
官方解析： 本题中，线程t并没有启动，只是调用了run()方法，程序中运行的线程依然只有一个，那么程序会按照顺序执行，即先运行run(),run()方法调用dianping()方法输出"dianping"，程序继续向下执行输出"dazhong"。如果本题中t线程调用start()方法，就会出现C选项的情况。综上所述，正确答案为B。
知识点：Java、Java工程师

8.
以下代码将打印出
public static void main(String args[]) {
    
    
      List  Listlist1 = new ArrayList();
      Listlist1.add(0);
      List Listlist2 = Listlist1;
      System.out.println(Listlist1.get(0) instanceof Integer);
      System.out.println(Listlist2.get(0) instanceof Integer);
}
A
编译错误
B
true true
C
true false
D
false false
正确答案：B
官方解析：
    JDK5之后提供的自动拆箱和自动装箱实现了将基本数据类型存入collection类型的集合（ArrayList,LinkedList）。例如题目中向ArrayList存入了基本类型0，int类型会自动装箱变为Integer类型存入集合中，使编译正常通过。

    将list1的引用赋值给了list2，那么list1和list2都将指向同一个堆内存空间。instanceof关键字在Java中用于判断一个对象是否属于某个特定类的实例，并且返回boolean类型的返回值。显然，list1.get(0)和list2.get(0)都属于Integer的实例。答案选择B。

知识点：Java

9.
下面论述正确的是（）？
A
如果两个对象的hashcode相同，那么它们作为同一个HashMap的key时，必然返回同样的值
B
如果a,b的hashcode相同，那么a.equals(b)必须返回true
C
对于一个类，其所有对象的hashcode必须不同
D
如果a.equals(b)返回true，那么a,b两个对象的hashcode必须相同
正确答案：D
官方解析：
hashCode方法本质就是一个哈希函数，这是Object类的作者说明的。Object类的作者在注释的最后一段的括号中写道：将对象的地址值映射为integer类型的哈希值。但hashCode()并不完全可靠的，有时候不同的对象他们生成的hashcode也会一样，因此hashCode()只能说是大部分时候可靠。

因此我们也需要重写equals()方法，但因为重写的equals()比较全面比较复杂，会造成程序效率低下，而利用hashCode()进行对比，则只要生成一个hash值进行比较就可以了，效率很高。因此，正常的操作流程是先用hashCode()去对比两个对象，如果hashCode()不一样，则表示这两个对象肯定不相等，直接返回false,如果hashCode()相同，再对比他们的equals()。

综上所述：

equals()相等的两个对象hashCode()一定相等。

hashCode()相等的两个对象equal()不一定相等。

因此选项D正确。

知识点：Java

10.
对于Java中异常的描述正确的是（ ）

A
用throws定义了方法可能抛出的异常，那么调用此方法时一定会抛出此异常。
B
如果try块中没有抛出异常，finally块中的语句将不会被执行。
C
抛出异常意味着程序发生运行时错误，需要调试修改
D
Java中的非检测（unchecked）异常可能来自RuntimeException类或其子类。
正确答案：D
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

11.
try括号里有return语句， finally执行顺序
A
不执行finally代码
B
return前执行
C
return后执行
正确答案：B
你的答案：C
参考答案：下面的关键内容来自: https://www.ibm.com/developerworks/cn/java/j-lo-finally/ 是关于 try  return  finally  的详细解释文档,很有说服力。 清单 5. public class Test {
    
     public static void main(String[] args) {
    
     System.out.println("return value of getValue(): " + getValue()); } public static int getValue() {
    
     try {
    
     return 0; } finally {
    
     return 1; } } } 清单 5 的执行结果： return value of getValue(): 1 清单 6. 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 {
    
     return i; } finally {
    
     i++; } } } 清单 6 的执行结果： return value of getValue(): 1 利用我们上面分析得出的结论：finally 语句块是在 try 或者 catch 中的 return 语句之前执行的。 由此，可以轻松的理解清单 5 的执行结果是 1。因为 finally 中的 return 1；语句要在 try 中的 return 0；语句之前执行，那么 finally 中的 return 1；语句执行后，把程序的控制权转交给了它的调用者 main（）函数，并且返回值为 1。那为什么清单 6 的返回值不是 2，而是 1 呢？按照清单 5 的分析逻辑，finally 中的 i++；语句应该在 try 中的 return i；之前执行啊？ i 的初始值为 1，那么执行 i++；之后为 2，再执行 return i；那不就应该是 2 吗？怎么变成 1 了呢？ 关于 Java 虚拟机是如何编译 finally 语句块的问题，有兴趣的读者可以参考《 The JavaTM Virtual Machine Specification, Second Edition 》中 7.13 节 Compiling finally。那里详细介绍了 Java 虚拟机是如何编译 finally 语句块。实际上，Java 虚拟机会把 finally 语句块作为 subroutine（对于这个 subroutine 不知该如何翻译为好，干脆就不翻译了，免得产生歧义和误解。）直接插入到 try 语句块或者 catch 语句块的控制转移语句之前。但是，还有另外一个不可忽视的因素，那就是在执行 subroutine（也就是 finally 语句块）之前，try 或者 catch 语句块会保留其返回值到本地变量表（Local Variable Table）中。待 subroutine 执行完毕之后，再恢复保留的返回值到操作数栈中，然后通过 return 或者 throw 语句将其返回给该方法的调用者（invoker）。请注意，前文中我们曾经提到过 return、throw 和 break、continue 的区别，对于这条规则（保留返回值），只适用于 return 和 throw 语句，不适用于 break 和 continue 语句，因为它们根本就没有返回值。 是不是不太好理解，那我们就用具体的例子来做形象的说明吧！ 为了能够解释清单 6 的执行结果，我们来分析一下清单 6 的字节码（byte-code）： Compiled from "Test.java" public class Test extends java.lang.Object{
    
     public Test(); Code: 0: aload_0 1:invokespecial#1; //Method java/lang/Object."<init>":()V 4: return LineNumberTable: line 1: 0 public static void main(java.lang.String[]); Code: 0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream; 3: new #3; //class java/lang/StringBuilder 6: dup 7: invokespecial #4; //Method java/lang/StringBuilder."<init>":()V 10: ldc #5; //String return value of getValue(): 12: invokevirtual #6; //Method java/lang/StringBuilder.append:( Ljava/lang/String;)Ljava/lang/StringBuilder; 15: invokestatic #7; //Method getValue:()I 18: invokevirtual #8; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder; 21: invokevirtual #9; //Method java/lang/StringBuilder.toString:()Ljava/lang/String; 24: invokevirtual #10; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 27: return public static int getValue(); Code: 0: iconst_1 1: istore_0 2: iload_0 3: istore_1 4: iinc 0, 1 7: iload_1 8: ireturn 9: astore_2 10: iinc 0, 1 13: aload_2 14: athrow Exception table: from to target type 2 4 9 any 9 10 9 any } 对于 Test（）构造方法与 main（）方法，在这里，我们不做过多解释。让我们来分析一下 getValue（）方法的执行。在这之前，先让我把 getValue（）中用到的虚拟机指令解释一下，以便读者能够正确的理解该函数的执行。 1. iconst_ Description: Push the int constant (-1, 0, 1, 2, 3, 4 or 5) onto the operand stack. Forms: iconst_m1 = 2 (0x2) iconst_0 = 3 (0x3) iconst_1 = 4 (0x4) iconst_2 = 5 (0x5) iconst_3 = 6 (0x6) iconst_4 = 7 (0x7) iconst_5 = 8 (0x8) 2. istore_ Description: Store int into local variable. The must be an index into the local variable array of the current frame. Forms: istore_0 = 59 (0x3b) istore_1 = 60 (0x3c) istore_2 = 61 (0x3d) istore_3 = 62 (0x3e) 3. iload_ Description: Load int from local variable. The must be an index into the local variable array of the current frame. Forms: iload_0 = 26 (0x1a) iload_1 = 27 (0x1b) iload_2 = 28 (0x1c) iload_3 = 29 (0x1d) 4. iinc index, const Description: Increment local variable by constant. The index is an unsigned byte that must be an index into the local variable array of the current frame. The const is an immediate signed byte. The local variable at index must contain an int. The value const is first sign-extended to an int, and then the local variable at index is incremented by that amount. Forms: iinc = 132 (0x84) Format: iinc index const 5. ireturn Description: Return int from method. Forms: ireturn = 172 (0xac) 6. astore_ Description: Store reference into local variable. The must be an index into the local variable array of the current frame. Forms: astore_0 = 75 (0x4b) astore_1 = 76 (0x4c) astore_2 =77 (0x4d) astore_3 =78 (0x4e) 7. aload_ Description: Load reference from local variable. The must be an index into the local variable array of the current frame. Forms: aload_0 = 42 (0x2a) aload_1 = 43 (0x2b) aload_2 = 44 (0x2c) aload_3 = 45 (0x2d) 8. athrow Description: Throw exception or error. Forms: athrow = 191 (0xbf) 有了以上的 Java 虚拟机指令，我们来分析一下其执行顺序：分为正常执行（没有 exception）和异常执行（有 exception）两种情况。我们先来看一下正常执行的情况，如图 1 所示： 图 1. getValue（）函数正常执行的情况 由上图，我们可以清晰的看出，在 finally 语句块（iinc 0, 1）执行之前，getValue（）方法保存了其返回值（1）到本地表量表中 1 的位置，完成这个任务的指令是 istore_1；然后执行 finally 语句块（iinc 0, 1），finally 语句块把位于 0 这个位置的本地变量表中的值加 1，变成 2；待 finally 语句块执行完毕之后，把本地表量表中 1 的位置上值恢复到操作数栈（iload_1），最后执行 ireturn 指令把当前操作数栈中的值（1）返回给其调用者（main）。这就是为什么清单 6 的执行结果是 1，而不是 2 的原因。 再让我们来看看异常执行的情况。是不是有人会问，你的清单 6 中都没有 catch 语句，哪来的异常处理呢？我觉得这是一个好问题，其实，即使没有 catch 语句，Java 编译器编译出的字节码中还是有默认的异常处理的，别忘了，除了需要捕获的异常，还可能有不需捕获的异常（如：RunTimeException 和 Error）。 从 getValue（）方法的字节码中，我们可以看到它的异常处理表（exception table）， 如下： Exception table: from to target type 2 4 9 any 它的意思是说：如果从 2 到 4 这段指令出现异常，则由从 9 开始的指令来处理。 图 2. getValue（）函数异常执行的情况 先说明一点，上图中的 exception 其实应该是 exception 对象的引用，为了方便说明，我直接把它写成 exception 了。 由上图（图 2）可知，当从 2 到 4 这段指令出现异常时，将会产生一个 exception 对象，并且把它压入当前操作数栈的栈顶。接下来是 astore_2 这条指令，它负责把 exception 对象保存到本地变量表中 2 的位置，然后执行 finally 语句块，待 finally 语句块执行完毕后，再由 aload_2 这条指令把预先存储的 exception 对象恢复到操作数栈中，最后由 athrow 指令将其返回给该方法的调用者（main）。 通过以上的分析，大家应该已经清楚 try-catch-finally 语句块的执行流程了吧！ 上面的内容来自复制粘贴,解释很有说服力,特粘贴给大家。 try  return  finally  的详细解释文档: https://www.ibm.com/developerworks/cn/java/j-lo-finally/
知识点：Java

12.
根据以下接口和类的定义，要使代码没有语法错误，则类Hero中应该定义方法(    )。

interface Action{
    
      
    void fly();  
}
class Hero implements Action{
    
      //……  }

A
private void fly(){
    
    }
B
void fly(){
    
    }
C
protected void fly(){
    
    }
D
public void fly(){
    
    }
正确答案：D
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

13.
关于Java语言中的final关键字的使用，下列说法正确的是（）

A
在使用final关键字定义的方法里面必须使用final关键字定义变量。
B
使用final关键字定义变量，必须在变量定义的同时给定变量的具体数值，完成变量初始化。
C
final关键字可以用来修饰方法，表明此方法不可以被子类重写。
D
使用final关键字定义变量，必须同时使用static关键字。
正确答案：C
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

14.以下程序的运行结果是？

A
foobar
B
barfoo
C
foobar或者barfoo都有可能
D
Bar
E
Foo
F
程序无法正常运行
正确答案：A
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

15.
若有下列定义，下列哪个表达式返回false？
String s = "hello";
String t = "hello";
char c[] = {
    
    'h', 'e', 'l', 'l', 'o'} ;


A
s.equals(t);
B
t.equals(c);
C
s==t;
D
t.equals(new String("hello"));
正确答案：B
官方解析：s和t两个String类型变量都是常量池中的字符串，只有变量名不同是可以用双等号判断是否相等的，内存都是常量池中的字符串。

因此A，C正确，String类型重写了equals方法，用于判断字符串内容是否相等，t和new出来的"hello"内容显然是相等的，D正确。

String底层源码的equals()方法处有判断这个参数是不是String类的实例，如果不是则不执行判断直接返回false。B错误。
知识点：Java

16.
关于访问权限说法正确 的是 ？ ( )


A
外部类前面可以修饰public,protected和private
B
成员内部类前面可以修饰public,protected和private
C
局部内部类前面可以修饰public,protected和private
D
以上说法都不正确
正确答案：B
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

17.
一个容器类数据结构，读写平均，使用锁机制保证线程安全。如果要综合提高该数据结构的访问性能，最好的办法是______。
A
只对写操作加锁，不对读操作加锁
B
读操作不加锁，采用copyOnWrite的方式实现写操作
C
分区段加锁
D
无法做到
正确答案：C
参考答案：答案：C A，只对写操作加锁，不对读操作加锁，会造成读到脏数据 B，CopyOnWrite的核心思想是利用高并发往往是读多写少的特性，对读操作不加锁，对写操作，先复制一份新的集合，在新的集合上面修改，然后将新集合赋值给旧的引用。这里读写平均，不适用 C，分段加锁，只在影响读写的地方加锁，锁可以用读写锁，可以提高效率
知识点：Java

18.
表达式(short)10/10.2*2运算后结果类型是（）
A
short
B
int
C
double
D
float
正确答案：C
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：C++、Java、Java工程师、2019、C语言

19.
（）运算符把其操作数中所有值为0和所有值为1的位分别在结果的相应中设置1和0
A
&
B
|
C
！
D
~
正确答案：D
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、C++工程师、C语言

20.
下面代码的运行结果为：（）
import java.io.*;
import java.util.*;
public class foo{
    
    
    public static void main (String[] args){
    
    
        String s;
        System.out.println("s=" + s);
    }
}

A
代码得到编译，并输出“s=”
B
代码得到编译，并输出“s=null”
C
由于String s没有初始化，代码不能编译通过
D
代码得到编译，但捕获到 NullPointException异常
正确答案：C
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、2018

21.以下代码执行的结果显示是多少（）？

A
num * count = 505000
B
num * count = 0
C
运行时错误
D
num * count = 5050
正确答案：B
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

22.
给定includel.isp文件代码片段，如下：
  <% pageContext.setAttribute(“User”,”HAHA”);%>
______ // 此处填写代码
  给定include2.jsp文件代码片段如下：
  <%=pageContext.getAttribute(“User”)%>
  要求运行include1.jsp时，浏览器上输出：HAHA
A
<jsp:include page=”include2.jsp” flash=”true”>
B
<%@include file=”include2.jsp”%>
C
<jsp:forward page=”include2.jsp”>
D
<% response.sendRedirect(“include2.jsp”); %>
正确答案：B
参考答案：答案：B B选项是静态包含，相当于不include2.jsp页面内容拷贝到此处，因此可以输出User属性值 D选项是转发重定向，转发的时候pageContent内的属性值不能被传递，因此得不到User属性值
知识点：Java

23.
String与StringBuffer的区别是？
A
String是不可变的对象，StringBuffer是可以再编辑的
B
字符串是常量，StringBuffer是变量
C
String是可变的对象，StringBuffer是不可以再编辑的
D
以上说法都不正确
正确答案：AB
官方解析：
 String类是不可变类，一旦一个String对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。

StringBuffer对象则代表一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toString()方法将其转换为一个String对象。

因此选项A、B正确。

知识点：Java

24.
java中Hashtable, Vector, TreeSet, LinkedList哪些线程是安全的？
A
Hashtable
B
Vector
C
TreeSet
D
LinkedList
正确答案：AB
官方解析：HashTable是线程安全的
Vector是线程安全的ArrayList
TreeSet和LinkedList都不是线程安全的
知识点：Java

25.
在java中重写方法应遵循规则的包括（）
A
访问修饰符的限制一定要大于被重写方法的访问修饰符
B
可以有不同的访问修饰符
C
参数列表必须完全与被重写的方法相同
D
必须具有不同的参数列表
正确答案：BC
官方解析：
总结来说为：
方法名相同，参数类型相同
子类返回类型等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。

详细的说明为：
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。 即外壳不变，核心重写！
重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常IOException，但是在重写这个方法的时候不能抛出Exception异常，因为Exception是IOException的父类，只能抛出IOException的子类异常。

方法的重写规则
1）参数列表必须完全与被重写方法的相同；
2）返回类型必须完全与被重写方法的返回类型相同；
3）访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
4）父类的成员方法只能被它的子类重写。
5）声明为final的方法不能被重写。
6）声明为static的方法不能被重写，但是能够被再次声明。
7）子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
8）子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
9）重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
10）构造方法不能被重写。
11）如果不能继承一个方法，则不能重写这个方法。
来自:http://www.runoob.com/java/java-override-overload.html
知识点：Java

26.
关于多线程和多进程，下面描述正确的是（）：
A
多进程里，子进程可获得父进程的所有堆和栈的数据；而线程会与同进程的其他线程共享数据，拥有自己的栈空间。
B
线程因为有自己的独立栈空间且共享数据，所有执行的开销相对较大，同时不利于资源管理和保护。
C
线程的通信速度更快，切换更快，因为他们在同一地址空间内。
D
一个线程可以属于多个进程。
正确答案：AC
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、2018

27.
A,B,C,D 中哪些是 setvar的重载？
public class methodover
{
    
    
    public void setVar(int a, int b, float c) {
    
    }
}

A
private void setVar(int a， float c， int b){
    
    }
B
protected void setVar(int a， int b， float c){
    
    }
C
public int setVar(int a， float c， int b){
    
    return a;}
D
public int setVar(int a， float c){
    
    return a;}
正确答案：ACD
参考答案：ACD 重载是在同一个类中，有多个方法名相同，参数列表不同(参数个数不同，参数类型不同),与方法的返回值无关，与权限修饰符无关，B中的参数列表和题目的方法完全一样了。
知识点：Java

28.
以下哪些方法是Object类中的方法
A
clone()
B
toString()
C
wait()
D
finalize()
正确答案：ABCD
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、2018

29.
以下哪些方法可以取到http请求中的cookie值（）?
A
request.getAttribute
B
request.getHeader
C
request.getParameter
D
request.getCookies
正确答案：BD
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

30.
关于volatile关键字，下列描述不正确的是？
A
用volatile修饰的变量，每次更新对其他线程都是立即可见的。
B
对volatile变量的操作是原子性的。
C
对volatile变量的操作不会造成阻塞。
D
不依赖其他锁机制，多线程环境下的计数器可用volatile实现。
正确答案：BD
参考答案：一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义： 1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。 2）禁止进行指令重排序。 volatile只提供了保证访问该变量时，每次都是从内存中读取最新值，并不会使用寄存器缓存该值——每次都会从内存中读取。 而对该变量的修改，volatile并不提供原子性的保证。 由于及时更新，很可能导致另一线程访问最新变量值，无法跳出循环的情况 多线程下计数器必须使用锁保护。
知识点：Java、Java工程师、C++工程师、运维工程师、算法工程师、2016

1.
以下二维数组声明合法的是（ ）
A
char[2][3] ch = new char[][];
B
char[2][] ch = new char[][3];
C
char[][] ch = new char[2][3];
D
char[][] ch = new [2]char[3];
正确答案：C
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

2.
在某个类A中存在一个方法：void set(int x),以下不能作为这个方法的重载的声明的是（）

A
void set(int y)
B
int set(int x，double y)
C
double set(int x,int y)
D
void set(int x,int y)
正确答案：A
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：C++、Java、C语言

3.
以下哪个接口的定义是正确的？（ ）
A
interface B {
    
     void print() {
    
     } ;}
B
interface B {
    
     static void print() ;}
C
abstract interface B extends A1, A2 //A1、A2为已定义的接口 { abstract void print(){ };}
D
interface B {
    
     void print();}
正确答案：D
官方解析：
A选项：接口中方法默认被public abstract修饰，抽象方法不可以有方法体。A错误。

B选项：JDK8中，接口中的方法可以被default和static修饰，但被修饰的方法必须有方法体。B错误。

C选项：接口的确是可以继承的，但C选项错误的原因和继承没关系。它错在抽象方法不可以有方法体。

D选项正确。

知识点：Java

4.
javac的作用是（    ）。
A
将源程序编译成字节码
B
将字节码编译成源程序
C
解释执行Java字节码
D
调试Java代码
正确答案：A
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

5.
程序文件名必须与公共外部类的名称完全一致（包括大小写）.
A
正确
B
错误
正确答案：A
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、2017

6.
一个类可以有多个不同名的构造函数 （不考虑内部类的情况）。（ ）

A
正确
B
错误
正确答案：B
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：C++、Java

7.
ArrayList和LinkList的描述，下面说法错误的是？
A
LinkedeList和ArrayList都实现了List接口
B
ArrayList是可改变大小的数组，而LinkedList是双向链接串列
C
LinkedList不支持高效的随机元素访问
D
在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在ArrayList的中间插入或删除一个元素的开销是固定的
正确答案：D
参考答案：答案：D 这个说法说反了 Arraylist的内存结构是数组，当超出数组大小时创建一个新的数组，吧原数组中元素拷贝过去。其本质是顺序存储的线性表，插入和删除操作会引发后续元素移动，效率低，但是随机访问效率高 LinkedList的内存结构是用双向链表存储的，链式存储结构插入和删除效率高，不需要移动。但是随机访问效率低，需要从头开始向后依次访问
知识点：Java、链表

8.
内部类（也叫成员内部类）可以有4种访问权限。（  ）

A
正确
B
错误
正确答案：A
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

9.
下面的方法，当输入为2的时候返回值是多少？
public static int getValue(int i) {
    
    
    int result = 0;
    switch (i) {
    
    
        case 1:
            result = result + i;
        case 2:
            result = result + i * 2;
        case 3:
            result = result + i * 3;
        }
    return result;
}


A
0
B
2
C
4
D
10
正确答案：D
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、2018

10.
检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。
public class Example {
    
     
  String str = new String("good"); 
  char[] ch = {
    
    'a','b','c'}; 
  public static void main(String[] args) {
    
     
     Example ex = new Example(); 
     ex.change(ex.str, ex.ch); 
     System.out.print(ex.str +"and"); 
     System.out.print(ex.ch);  
  } 
    
  public void change(String str, char ch[]){
    
     
     str= "test ok"; 
     ch[0]= 'g'; 
  } 
} 
A
test okandabc
B
test okandgbc
C
goodandabc
D
goodandgbc
正确答案：D
参考答案：java 中String是 immutable的，也就是不可变，一旦初始化，其引用指向的内容是不可变的。 也就是说，String str = “aa”；str=“bb”；第二句不是改变“aa”所存储地址的内容，而是另外开辟了一个空间用来存储“bb”；同时由str指向 原来的“aa”，现在已经不可达，GC时会自动回收。 因此String作为参数传进来时候，str= "test ok"; 实际给副本引用str指向了新分配的地址，该地址存储“test ok”。 因此，原先的str仍然指向“good”
知识点：2015、Java

11.
下列程序执行后输出结果为（      ）
class BaseClass {
    
    
    public BaseClass() {
    
    }
 
    {
    
    
        System.out.println("I’m BaseClass class");
    }
 
     static {
    
    
         System.out.println("static BaseClass");
     }
 }
 
 public class Base extends BaseClass {
    
    
     public Base() {
    
    }
 
     {
    
    
         System.out.println("I’m Base class");
     }
 
     static {
    
    
         System.out.println("static Base");
     }
 
     public static void main(String[] args) {
    
    
         new Base();
     }
 }

A
static BaseClass
I’m BaseClass class
static Base
I’m Base class
B
I’m BaseClass class
I’m Base class
static BaseClass
static Base
C
I’m BaseClass class
static BaseClass
I’m Base class
static Base
D
static BaseClass
static Base
I’m BaseClass class
I’m Base class
正确答案：D
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、2019

12.
指出下列程序运行的结果（）
public class Example{
    
    
    String str = new String("good");
    char[ ] ch = {
    
     'a' , 'b' , 'c' };
    public static void main(String args[]){
    
    
        Example ex = new Example();
        ex.change(ex.str,ex.ch);
        System.out.print(ex.str + " and ");
        System.out.print(ex.ch);
    }
    public void change(String str,char ch[ ]){
    
    
        str = "test ok";
        ch[0] = 'g';
    }
}

A
good and abc
B
good and gbc
C
test ok and abc
D
test ok and gbc
正确答案：B
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

13.
下列代码编译和运行的结果是：（）
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
代码正常运行，但是无输出
正确答案：C
你的答案：B
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、2019

14.
下列语句哪一个是不正确的（）
A
Log4j支持按分钟为间隔生成新的日志文件
B
Log4j是一个打印日志用的组件
C
Log4j支持按年为间隔生成新的日志文件
D
Log4j的日志打印级别可以在运行时重新设置
正确答案：D
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

15.
如果一个list初始化为{
    
    5，3，1}，执行以下代码后，其结果为（）？
1
2
3
nums.add(6);
nums.add(0,4);
nums.remove(1);
A
[5, 3, 1, 6]
B
[4, 3, 1, 6]
C
[4, 3, 6]
D
[5, 3, 6]
正确答案：B
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、安卓工程师、2018

16.
运行下面代码，输出的结果是（）
class A {
    
    
    public A() {
    
    
        System.out.println("class A");
    }
    {
    
     System.out.println("I'm A class"); } 
    static {
    
     System.out.println("class A static"); }
}
public class B extends A {
    
    
    public B() {
    
    
        System.out.println("class B");
    }
    {
    
     System.out.println("I'm B class"); }
    static {
    
     System.out.println("class B static"); }
     
    public static void main(String[] args) {
    
     
 new B(); 
}
}

A
class A static
class B static
I'm A class
class A
I'm B class
class B
B
class A static
I'm A class
class A
class B static
I'm B class
class B
C
class A static
class B static
class A
I'm A class
class B
I'm B class
D
class A static
class A
I'm A class
class B static
class B
I'm B class
正确答案：A
官方解析：
关于Java程序初始化顺序：

父类的静态代码块

子类的静态代码块

父类的普通代码块

父类的构造方法

子类的普通代码块

子类的构造方法

按照这个顺序，答案选择A

知识点：Java、Java工程师、C++工程师、测试工程师、2018

17.
下面有关java实例变量,局部变量,类变量和final变量的说法，错误的是？
A
实例变量指的是类中定义的变量，即成员变量，如果没有初始化，会有默认值。
B
局部变量指的是在方法中定义的变量，如果没有初始化，会有默认值
C
类变量指的是用static修饰的属性
D
final变量指的是用final 修饰的变量
正确答案：B
参考答案：B，局部变量必须有初始值。
知识点：Java

18.
Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少 (  ).
A
11 ,-11
B
11 ,-12
C
12 ,-11
D
12 ,-12
正确答案：C
参考答案：floor ： 意为地板，指向下取整，返回不大于它的最大整数 ceil ： 意为天花板，指向上取整，返回不小于它的最小整数 round ： 意为大约，表示“四舍五入”，而四舍五入是往大数方向入。Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11而不是-12。
知识点：Java

19.
多重继承的概念在Java中实现是通过如下哪些？（）
I. 扩展两个或多个类
II. 扩展一个类并实现一个或多个接口。
III. 实现两个或更多接口。

A
只有I &II
B
只有II & III
C
只有III
D
都是
正确答案：B
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、2020

20.
语句：char foo='中'，是否正确？（假设源文件以GB2312编码存储，并且以javac – encoding GB2312命令编译）
A
正确
B
错误
正确答案：A
参考答案：Java语言中，中文字符所占的字节数取决于字符的编码方式，一般情况下，采用ISO8859-1编码方式时，一个中文字符与一个英文字符一样只占1个字节；采用GB2312或GBK编码方式时，一个中文字符占2个字节；而采用UTF-8编码方式时，一个中文字符会占3个字节。 在C++中 在C++中，char是基础数据类型，8位，1个字节。byte不是基础数据类型，一般是typedef unsigned char byte;这样子的，也就是说，byte其实是unsigned char类型，那么也是8位，1个字节。不同的是，char可以表示的范围是-128-127，而byte可以表示的范围是0-255。 在Java中 在java中，char和byte都是基础数据类型，其中的byte和C++中的char类型是一样的，8位，1个字节，-128-127。但是，char类型，是16位，2个字节， '\u0000'-'\uFFFF'。 为什么java里的char是2个字节？ 因为java内部都是用unicode的，所以java其实是支持中文变量名的，比如string 世界 = "我的世界";这样的语句是可以通过的。 综上，java中采用GB2312或GBK编码方式时，一个中文字符占2个字节，而char是2个字节，所以是对的
知识点：Java

21.
关于以下程序代码的说明正确的
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
5行不能通过编译，因为引用了私有静态变量
B
10行不能通过编译，因为x是私有静态变量
C
程序通过编译，输出结果为：x=103
D
程序通过编译，输出结果为：x=102
正确答案：D
参考答案：答案选D 因为x的 修饰符为 static 所以x为类变量，即对于所有的实例来说，他们访问的x为同一个x，类变量存储在方法区，不属于每个实例的私有， 刚开始x=100 调用hs1.x++   x为101; 调用hs2.x++   x为102; 调用hs1.x++   x为103 (此时hs1指向了一个新的HasStatic实例，但是依然访问的是同一个X) 调用HasStatic.x--  x为102 所以结果为D
知识点：Java

22.
关于中间件特点的描述.不正确的是（）
A
中间件运行于客户机/服务器的操作系统内核中，提高内核运行效率
B
中间件应支持标准的协议和接口
C
中间件可运行于多种硬件和操作系统平台上
D
跨越网络,硬件，操作系统平台的应用或服务可通过中间件透明交互
正确答案：A
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

23.
Which lines of the following will produce an error?
byte a1 = 2, a2 = 4, a3;
short s = 16;
a2 = s;
a3 = a1 * a2;

A
Line 3 and Line 4
B
Line 1 only
C
Line 3 only
D
Line 4 only
正确答案：A
参考答案：答案:A short类型转为byte类型出错 a1*a2结果为int类型，转为byte类型出错
知识点：Java

24.
在java中，下列对继承的说法，正确的是（ ）

A
子类能继承父类的所有成员
B
子类继承父类的非私有方法和状态
C
子类只能继承父类的public方法和状态
D
子类只能继承父类的方法
正确答案：A
官方解析：
Constructors, static initializers, and instance initializers are not members and
therefore are not inherited.(构造器、静态初始化块、实例初始化块不继承）

知识点：Java

25.
有以下程序段， 则下面正确的选项是（）
public class MyThead extends Thread{
    
    
    public static void main(String[] args) {
    
    
        MyThead t=new MyThead();
        MyThead s=new MyThead();
        t.start();
        System.out.println("one.");
        s.start();
        System.out.println("two.");
    }
    public void run() {
    
    
        System.out.println("Thread");
    }
}

A
编译失败
B
程序运行可能结果为： one. Thread two. Thread
C
程序运行可能结果是： one. two. Thread Thread
D
程序运行结果不稳定
正确答案：BCD
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、2017

26.
下列哪个选项是合法的标识符？（）
A
123
B
_name
C
class
D
first
正确答案：BD
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

27.
下面有关servlet的层级结构和常用的类，说法正确的有?
A
GenericServlet类：抽象类，定义一个通用的、独立于底层协议的Servlet。
B
大多数Servlet通过从GenericServlet或HttpServlet类进行扩展来实现
C
ServletConfig接口定义了在Servlet初始化的过程中由Servlet容器传递给Servlet得配置信息对象
D
HttpServletRequest接口扩展ServletRequest接口，为HTTP Servlet提供HTTP请求信息
正确答案：ABCD
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

28.
下面关于volatile的功能说法正确的是哪个
A
原子性
B
有序性
C
可见性
D
持久性
正确答案：BC
官方解析：
 本题易错点是A选项，volatile关键字对任意单个volatile变量的的读写操作可以保证原子性，但类似于volatile++这种复合操作就无法保证原子性了。如果需要对这种复合操作保证原子性，最好用synchronized关键字。即synchronized保证三大性，原子性，有序性，可见性，volatile保证有序性，可见性，不能保证原子性。

B选项，为了实现volatile的内存语义，编译器在生成字节码时会在指令序列中插入内存屏障来禁止特定类型的处理器重排序，以此来保证有序性。

C选项，可见性是指当多个线程并发访问共享变量时，一个线程对共享变量的修改，其它线程能够立即看到。对于一个volatile变量的读，总是能看到对这个volatile变量最后的写入，保证了可见性。

D选项为干扰选项。

知识点：Java、Java工程师、安卓工程师、测试工程师、2019、测试开发工程师

29.
下面有关forward和redirect的描述，正确的是() ？
A
forward是服务器将控制权转交给另外一个内部服务器对象，由新的对象来全权负责响应用户的请求
B
执行forward时，浏览器不知道服务器发送的内容是从何处来，浏览器地址栏中还是原来的地址
C
执行redirect时，服务器端告诉浏览器重新去请求地址
D
forward是内部重定向，redirect是外部重定向
E
redirect默认将产生301 Permanently moved的HTTP响应
正确答案：BCD
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java

30.
下面哪些描述是正确的：（  ）
public class Test {
    
    
    public static class A {
    
    
        private B ref;
        public void setB(B b) {
    
    
            ref = b;
        }
    }
    public static Class B {
    
    
        private A ref;
        public void setA(A a) {
    
    
            ref = a;
        }
    }
    public static void main(String args[]) {
    
    
    …
        start();
    ….
    }
    public static void start() {
    
     A a = new A();
        B b = new B();
        a.setB(b);
        b = null; //
        a = null;
    …
    }
}
 
    

A
b = null执行后b可以被垃圾回收
B
a = null执行后b可以被垃圾回收
C
a = null执行后a可以被垃圾回收
D
a,b必须在整个程序结束后才能被垃圾回收
E
类A和类B在设计上有循环引用，会导致内存泄露
F
a, b 必须在start方法执行完毕才能被垃圾回收
正确答案：BC
官方解析：暂无官方题目解析，去讨论区看看吧！
知识点：Java、Java工程师、2018