Java基础测试选择题带答案解析（一）

78 阅读 0 评论 52 点赞

我是靠谱客的博主耍酷花瓣，最近开发中收集的这篇文章主要介绍Java基础测试选择题带答案解析（一），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1、【单选题】
对于代码：
public void test(int[] arr) {
int i, j, note;
for (i = 1; i < arr.length; i++) {
note = arr[i];
j = i - 1;
while (j >= 0 && note < arr[j]) {
arr[j + 1] = arr[j];
j–;
}
arr[j + 1] = note;
}
} 所实现的功能是
A.获取最大值
B.获取最小值
C.升序排序
D.降序排序
E.反转数组
【正确答案】C
【答案解析】如果后面的值比前面的小就把前面的值赋值给后面

2、【单选题】
对于代码: public class Test {
public static void main(String[] args) {
Person p = new Person();
p.name = “Sam”;
p.age = 16;
m§;
System.out.println§;
}
public static Person m(Person p) {
try {
p.name = “Amy”;
p.age = 18;
throw new NullPointerException();
} catch (Exception e) {
p.name = “Tom”;
p.age = 20;
return p;
} finally {
p = new Person();
p.name = “Jack”;
p.age = 22;
}
}
}

class Person {
String name;
int age;
@Override
public String toString() {
return "Person [name = " + name + ", age = " + age + “]”;
}
}的输出结果是
A.Person[name = Sam, age = 16]
B.Person[name = Amy, age = 18]
C.Person[name = Tom, age = 20]
D.Person[name = Jack, age = 22]
【正确答案】C
【答案解析】执行try块里内容抛出异常被catch块捕获此时执行到return语句，检测到有finally块需要把p的地址值进行挂起，执行finally块里内容，这个里内容执行完没有影响原p对象的内容，所以最后返回时还是返回的catch块里的对象以及属性值

3、【单选题】
import java.util.*;

public class test1 {
public static void main(String args[]) {
Set s = new HashSet();
for (Short i = 0; i < 100; i++) {
s.add(i);
s.remove(i - 1);
}
System.out.println(s.size());
}
}
A.1
B.100
C.Throws Exception.
D.None of the Above
【正确答案】B
【答案解析】由于Set集合存储的元素类型时Short类型那么删除的时候也只能根据Short类型进行删除，当执行i-1时会默认变成int类型，所以类型不一致就不能删除

4、【单选题】
下面关于构造函数说法不正确的是
A.构造函数中可以有return语句
B.每个类中都至少含有一个构造函数
C.一个类中可以有多个构造函数
D.一个类中，构造函数的优先级高于构造代码块
【正确答案】D
【答案解析】构造代码块优先于任意形式的构造方法先执行

5、【单选题】
数组的声明错误的是:
A.int[] a=new int[3];
B.int[] a=new int[]{1,2,3};
C.int[] a={1,2,3};
D.int[] a=new int[3]{1,2,3};
【正确答案】D
【答案解析】定义数组直接给定元素值时长度就以及确定了无法再次指定

6、【单选题】
下列的运行结果为( )
public class StaticExam {
public static void main(String[] args) {
System.out.println(SEDemo.i);
System.out.println(new SEDemo().j);
}
}

class SEDemo {
public static int i = 6;
public static SEDemo s = new SEDemo();
public int j;
public SEDemo() {
i–;
j–;
}
}
A.6，0
B.6，-1
C.5，0
D.5，-1
【正确答案】D
【答案解析】当SEDemo.i时，需要加载整个类，类的静态信息也需要加载，静态属性i赋值为6，静态属性s也需要进行赋值就需要创建本类对象一次所以需要去执行构造方法i–为5。当new SEDemo().j时静态信息以及加载完成直接执行属性j初始值为0，再去调用构造方法j–为-1

7、【单选题】
对于代码： public class Test { public static void main(String[] args) { String str = new String(“abc”); twice(str); System.out.println(str); } pubilc static String twice(String str) { return str += new StringBuilder(str).reverse(); } } 的运行结果是：
A.abc
B.abcabc
C.cba
D.abccba
E.cbaabc
【正确答案】A
【答案解析】实参是引用数据类型传递的是地址值的拷贝，所以方法执行完之后不会原结果

8、【单选题】
对于代码：package cn.tedu.test1 ;
public class A{
int age;
}
package cn.tedu.test2 ;
public class C{
public static void main(String[] args) {
B b=new B();
b.clone(); //1
}
}
class B extends A{
int age;
public void test1(){
A a=new B();
a.clone(); //2
B b=new B();
b.clone(); //3
}
}
编译报错的行号是？
A.1,2,3
B.2,3
C.1,2
D.1,3
【正确答案】C
【答案解析】Clone方法被protected修饰在Object类中与ABC三个类不在一个包但是有父子关系，如果想要调用到clone方法需要保证子类对象在子类的本类中使用，1和2都不是

9、【单选题】
对于Set set = new HashSet<>(32);扩容的次数为
A.0
B.1
C.2
D.3
E.4
【正确答案】A
【答案解析】可以指定初始容量，所以没有扩容

10、【单选题】
下列关于File的说法正确的是
A.File file=new File(“D:a.txt”);是在D盘下创建一个a.txt文件
B.可以通过mkdirs()方法创建多个文件
C.当调用getPath()方法的时候，会去计算机中检查该文件是否存在
D.可以通过isFile()方法判断该File对象是否是一个文件对象
【正确答案】D
【答案解析】创建File对象只是指明有一个路径但是不会去检查路径是否存在。mkdirs方法是可以创建多个目录。getPath方法返回的是路径名

11、【单选题】
public class CodeDemo {
public static void main(String[] args) {
new SB();
}
}

class SA {
D d;
static {
System.out.println(“D2”);
}
{
System.out.println(“C3”);
d = new D();
}
public SA() {
System.out.println(“D1”);
}
}

class SB extends SA {
static C c = new C();
static {
System.out.println(“A1”);
}
{
System.out.println(“B2”);
}
public SB() {
System.out.println(“D”);
}
}

class C {
public C() {
System.out.println(“A2”);
}
}

class D extends C {
public D() {
System.out.println(“A3”);
}
}
的输出结果是：
A.A1 C B1 A2 C D A3 B2 B3
B.D2 A2 A1 C3 A2 A3 D1 B2 D
C.D2 A2 A1 C3 D D1 A3 B2 A2
D.D2 A2 A1 C3 A3 A2 D1 B2 D
【正确答案】B
【答案解析】当创建子类对象时，需要先加载父类静态信息、子类静态信息、父类对象级别信息、子类对象级别信息。父类静态信息只有静态代码块所有输出D2，子类静态信息包括静态属性和静态代码块依次加载所以输出A2、A1。子类对象级别信息包括构造代码块和构造方法依次执行（构造代码块要输出C3之后需要再雄黄酒D类对象，还要接着输出A2，A3）C3 A2 A3 D1，之后再执行子类对象级别输出B2 D

12、【单选题】
对于代码： public class Test {
public static void main(String[] args) {
int[] a = { 12, 20, 5, 16, 15, 1, 30, 45, 23, 9 };
int start = 0;
int end = a.length - 1;
sort(a, start, end);
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
public static void sort(int[] a, int low, int high) {
int start = low;
int end = high;
int key = a[low];
while (end > start) {
while (end > start && a[end] >= key)
end–;
if (a[end] <= key) {
int temp = a[end];
a[end] = a[start];
a[start] = temp;
}
while (end > start && a[start] <= key)
start++;
if (a[start] >= key) {
int temp = a[start];
a[start] = a[end];
a[end] = temp;
}
}
if (start > low)
sort(a, low, start - 1);
if (end < high)
sort(a, end + 1, high);
}
}实现的效果是
A.获取数组的最大值
B.获取数组的最小值
C.将数组降序排序
D.将数组升序排序
E.将数组扩为两倍
【正确答案】D
【答案解析】如果数组后面小于前面的就交换，前面大于了后面的也交换，最后就是按照升序进行排序

13、【单选题】
public class TestLlan {
static int test() {
int x = 1;
try {
return x;
} finally {
++x;
}
}
public static void main(String[] args) throws FileNotFoundException {
System.out.println(TestLlan.test());
}
}
A.0
B.1
C.运行异常
D.编译异常
【正确答案】B
【答案解析】代码从上往下编译与执行,执行到x— return 1;代码执行到return语句时检测到了finally的存在就一定要执行会对return这个语句进行挂起（return 1 把值和返回的状态一起挂起）去执行finally，执行i+±–i=3，finally执行完毕把原来挂起的return语句再次执行

14、【单选题】
关于以下程序代码的说明正确的是（） class HasStatic { private static int x = 100; public static void main(String[] args) { HasStatic hs1 = new HasStatic(); hs1.x++;//第5行 HasStatic hs2 = new HasStatic(); hs2.x++; hs1 = new HasStatic(); hs1.x++; HasStatic.x–;//第10行 System.out.println(“x=” + x); } }
A.5行不能通过编译，因为引用了私有静态变量
B.10行不能通过编译，因为x是私有静态变量
C.程序通过编译，输出结果为：x=103
D.程序通过编译，输出结果为：x=102
【正确答案】D
【答案解析】在同类中可以使用私有静态变量。静态变量对所有对象共享，所以相当于加3减1，最后结果为102

15、【单选题】
子类A继承了父类B，A a=new A();则①父类B静态代码块②父类B非静态代码块③父类B构造函数④子类A静态代码 ⑤子类A非静态代码块⑥子类A的构造函数的执行顺序是
A.①②③④⑤⑥
B.①④②③⑤⑥
C.①②④⑤③⑥
D.④⑤①②③⑥
E.④⑤⑥①②③
【正确答案】B
【答案解析】先执行父类静态信息再执行子类静态信息，接着执行父类对象级别信息再执行子类对象级别信息

16、【单选题】
以下运行结果正确的是
public class Demo1{ 　　
public static void main(String[] args){ 　
　　　 double total = 2.0; 　　　　
double used = 1.1; 　　　　
double result = total - used;
　　　 System.out.println("result : " + result);
A.0.8999999999999999
B.0
C.Null
D.编译异常
【正确答案】A
【答案解析】大部分小数底层二进制补码形式都是无限位数但是double数据类型的存储范围是一定的，所以小数在进行运算时会有无法精确运算小数位的情况

17、【单选题】
下列程序运行的结果是（）。interface InterfaceA {
int MAX = 10;
}

class ClassA implements InterfaceA {
int a = 1;
}

class ClassB extends ClassA {
int b = 2;
}

public class E {
public static void main(String[] args) {
ClassB b = new ClassB();
System.out.print(b.MAX);
System.out.print(" " + ClassB.MAX);
System.out.print(" " + ClassA.MAX);
System.out.print(" " + InterfaceA.MAX);
}
}
A.编译错误：MAX在类ClassB没有定义
B.编译错误：MAX不能通过对象名b来访问
C.编译错误：MAX不能通过接口名InterfaceA来访问
D.10 10 10 10
【正确答案】D
【答案解析】接口中的属性默认是被public、static、final共同修饰，而且A是接口实现类，B是A的子类，所以A类或者B类都可以直接类名点调用接口属性
　
　18、【单选题】
关于下列代码说法正确的是？
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.运行期抛出异常
B.输出结果：13
C.语句：b6=b4+b5编译出错
D.语句：b3=b1+b2编译出错
【正确答案】D
【答案解析】b4和b5都是最终值，值一直都是byte类型值所以求和之后仍然还是byte类型值所以可以直接赋值给b6

19、【单选题】
下列程序运行的结果是（）。interface B {
void f();
}

class C implements B {
public void f() {
System.out.print("good ");
}
public void g(B b) {
b.f();
}
}

class A implements B {
public void f() {
System.out.print("bad ");
}
public void g(B b) {
b.f();
}
public static void main(String[] args) {
B b1 = new A();
B b2 = new C();
b1.f();
b2.f();
}
}
A.编译错误
B.执行错误
C.good bad
D.bad good
【正确答案】D
【答案解析】b1和b2对象都是向上造型创建的对象，所以方法的执行看子类，故执行都是子类的重写方法

20、【单选题】
给出以下代码运行结果Collection c = new ArrayList<>();
c.add(“ac”);
c.add(“bdc”);
c.add(“cac”);
c.add(“dad”);
Stream s = c.stream();
s.filter(str -> str.matches(".a.")).filter(str -> str.endsWith(“c”)).forEach(str -> {
c.remove(str);
System.out.println(str);
System.out.println©;
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
});
A.ac [bdc,cac,dad] cac [bdc,dad] NullPointerException
B.ac dbc cac [dbc]
C.ac [bdc,cac,dad] cac [bdc,dad]
D.NullPointerException
【正确答案】A
【答案解析】把包含a的元素进行筛选出来再根据以c结尾来进行过滤，剩下了ac和cac，根据ac和cac进行删除接着输出删除内容再输出新的剩下的元素，要删除2个所以要输出2次最后结果是ac [bdc,cac,dad] cac [bdc,dad]，最后又执行了一次删除但是此时没有元素了c的对象就是null再调用remove方法就出来空指针异常

21、【单选题】
下列Java代码输出的结果是 public class T14 {
public static void main(String[] args) {
int[] ary1 = { 3, 4, 5 };
int[] ary2 = { 3, 4 };
int[] ary3 = f(ary1, ary2);
System.out.println(Arrays.toString(ary3));
}
public static int[] f(int[] ary1, int[] ary2) {
int[] ary = Arrays.copyOf(ary1, ary1.length + ary2.length);
System.arraycopy(ary2, 0, ary, ary1.length, ary2.length);
return ary;
}
}
A.[3, 4, 5]
B.[3, 4, 5, 0, 0]
C.[3, 4, 5, 3, 4]
D.[3, 4, 3, 4, 5]
【正确答案】C
【答案解析】第一次数组扩容是让ary指向前面数值是ary1的值长度为5的新数组。第二次扩容是把ary2里的值从ary1值后继续赋值

22、【单选题】
分析如下Java代码，如果想在控制台上输出"B类的test()方法"，则在1处应填入（）。
class A {
public void test() {
System.out.println(“A类的test()方法”);
}
}
class B extends A {
public void test() {
System.out.println(“B类的test()方法”);
}
public static void main(String args[]) {
// 1
}
}
A.A a = new B(); a.test();
B.A a = new A(); a.test();
C.B b = new A(); b.test();
D.B.test();
【正确答案】A
【答案解析】向上造型对象调用方法的执行看子类执行子类重写方法

23、【单选题】
下面的方法将返回？
public static int func() {
int i = 2;
try {
return i++;
} catch (Exception e) {
return i++;
} finally {
i++;
}
}
A.1
B.2
C.3
D.编译错误
【正确答案】B
【答案解析】try块里在执行return 2时发现有finally就会把值和状态都要挂起，所以执行完finally接着执行挂起的内容所以最后返回2

24、【单选题】
编译运行以下程序后，关于输出结果的说明正确的是（） public class Text04 { public static void main(String args[]) { int x = 4; System.out.println(“value is” + ((x > 4) ? 99.9 : 9)); } }
A.输出结果为：value is 99.9
B.输出结果为：value is 9
C.value is 9.0
D.编译错误
【正确答案】C
【答案解析】执行三目运算符表达式值为false执行:后面的值，如果是基本类型之间可以类型提升java会默认保证:前后类型一致

25、【单选题】
以下代码的运行结果正确的是（） public static void main(String[] args) {
byte a;
int b, c, d;
a = 5;
b = a += a -= a *= a++;
c = b *= b += b += --b;
d = c + 2;
System.out.println(d > b ? a : c);
}
A.-15
B.15
C.100
D.35
【正确答案】A
【答案解析】进行连等赋值时需要进行展开先把最右边值计算才能传值给左边，a++的值是5和左边的5进行相乘为25，再和左边的5进行求差为-20，再和左边的5进行求和最后b的值为-15。同理可得–b为-16和左边的-15进行求和为-31，再和左边的-15进行求和为-46再和左边的-15进行相乘最后c的值为690再加上2为d的值。d比b大最后三目返回的是a的值为-15

26、【单选题】
指出下列程序运行的结果（）interface InterfaceA {
int MAX = 10;
}

class ClassA implements InterfaceA {
int a = 1;
}

class ClassB extends ClassA {
int b = 2;
}

public class E {
public static void main(String[] args) {
ClassB b = new ClassB();
System.out.print(b.MAX);
System.out.print(" " + ClassB.MAX);
System.out.print(" " + ClassA.MAX);
System.out.print(" " + InterfaceA.MAX);
}
}
A.good and abc
B.good and gbc
C.test ok and abc
D.test ok and gbc
【正确答案】B
【答案解析】字符串本身就是对象所以str传值过去就被地址值覆盖了，所以没有改变原值。字符数组把地址值传递过去改变了原数组中第一个元素值为g

27、【单选题】
关于final关键字，下面说法正确的是？
A.final关键字如果用于修饰成员变量，那么该成员变量必须初始化
B.final关键字修饰的类只能被继承一次
C.final关键字修饰的方法可以被重写
D.final关键字如果用于修饰方法，该方法所在的类不能被继承
【正确答案】A
【答案解析】final修饰的方法不能被重写不会影响所在的类。修饰类时不能被继承

28、【单选题】
关于以下程序的说明，正确的是（） 1． class StaticStuff 2． { 3． static int x=10； 4． static { x+=5；} 5． public static void main（String args[ ]） 6． { 7． System.out.println(“x=” + x); 8． } 9． static { x/=3;} 10. }
A.4行与9行不能通过编译，因为缺少方法名和返回类型
B.9行不能通过编译，因为只能有一个静态初始化器
C.编译通过，执行结果为：x=5
D.编译通过，执行结果为：x=3
【正确答案】C
【答案解析】按照静态信息出现先后顺序依次进行加载执行，先加载静态属性为10，在执行静态代码块加5为15，最后再执行一个静态代码块进行除3最后结果为5
　
　29、【单选题】
下面代码的运行结果为：（） 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
【答案解析】字符串对象需要进行初始化才能操作

30、【单选题】
下列语句的输出结果是:（）。 System.out.println(5+7+‘I’+“tarena”+5+7);
A.84tarena57
B.57tarena12
C.57tarena57
D.85tarena57
【正确答案】D
【答案解析】代码从右往左依次执行，5和7进行求和，遇见字符需要把字符转成对应的编码值进行求和最后的结果是85，再和字符串直接量以及后面的所有内容进行拼接

31、【单选题】
以下运行结果正确的是
public static int func (){
try{ return 1;
}catch (Exception e){
return 2;
}finally{
return 3;
}
}
A.1
B.2
C.3
D.编译报错
【正确答案】C
【答案解析】无论try块或者catch块里是否执行，finally一定执行，就会执行到return语句返回3

32、【单选题】
package test;

import java.math.BigInteger;

public class Test5 {
public static void main(String[] args) {
BigInteger sum = new BigInteger(“0”);
BigInteger one = new BigInteger(“1”);
BigInteger two = new BigInteger(“2”);
sum.add(one);
sum.add(two);
System.out.println(sum + sum.toString());
}
}
A.33
B.00
C.6
D.0
【正确答案】B
【答案解析】BigInteger类里的add方法执行完之后返回新的Big Integer对象，此时没有影响原sum对象的值，所有还是0，最后拼接之后的结果就是00

33、【单选题】
以下程序的输出结果为：为：
public static void main(String args[]) {
int a = 10;
int b = 20;
boolean flag = a++ > b-- && b++ > a–;
System.out.println(flag + “,a=” + a + “,b=” + b);
}
A.false,a=11,b=19
B.false,a=10,b=20
C.true,a=11,b=19
D.true,a=10,b=20
【正确答案】A
【答案解析】a++为10，b–为20，比较结果为false出现短路右边不执行，所以a自加了依次，b自减了一次

34、【单选题】
给出以下代码运行结果Collection c = new ArrayList<>();
c.add(“ac”);
c.add(“bdc”);
c.add(“cac”);
c.add(“dad”);
Stream s = c.stream();
s.filter(str -> str.matches(".a.")).filter(str -> str.endsWith(“c”)).forEach(str -> {
c.remove(str);
System.out.println(str);
System.out.println©;
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
});
A.ac [bdc,cac,dad] cac [bdc,dad] NullPointerException
B.ac dbc cac [dbc]
C.ac [bdc,cac,dad] cac [bdc,dad]
D.NullPointerException
【正确答案】A
【答案解析】把包含a的元素进行筛选出来再根据以c结尾来进行过滤，剩下了ac和cac，根据ac和cac进行删除接着输出删除内容再输出新的剩下的元素，要删除2个所以要输出2次最后结果是ac [bdc,cac,dad] cac [bdc,dad]，最后又执行了一次删除但是此时没有元素了c的对象就是null再调用remove方法就出来空指针异常

35、【单选题】
下列代码的运行结果正确的是 public class Test_Syk_2 { public static void main(String[] as){ new Son(); } } class Father{ int num; Father() { System.out.println(“S”+(++this.num)); } { System.out.println(“G”+num); } static{ System.out.println(“H”); } } class Son extends Father{ private int num=7; Son() { System.out.println(“A”+(–super.num)); } { System.out.println(“D”+num); } static{ System.out.println(“F”); } }
A.H F G0 S1 D6 A1
B.H F G0 S0 D7 A1
C.H F G1 S0 D7 A1
D.H F G0 S1 D7 A0
【正确答案】D
【答案解析】当创建子类对象时整个程序的执行过程是先加载父类静态信息以及子类静态信息，再执行父类对象级别信息以及子类对象级别信息。父类静态信息只有静态代码块输出H，子类静态信息只有静态代码块输出F。执行父类对象级别信息先执行父类构造代码块输出G0，再执行构造方法输出S1。执行子类对象级别信息先执行构造代码块输出D7，执行构造代码块输出A0

36、【单选题】
下列各项中，说法正确的是：
A.Reader r = new FileReader(); 能够正确的编译运行
B.转换流使用的默认编码是GBK编码
C.序列化流可以将一个ArrayList对象序列化到硬盘上
D.OuputStreamWriter是一个字节流
E.加载一个视频文件需要用字节输入流
【正确答案】E
【答案解析】创建IO对象需要指定路径。转换流编码要看当前是字符转字节还是字节转字符。持久化才是存储到硬盘中。D选项是字符流

37、【单选题】
以下表达式值为true的是
A.“123”equals(123)

B.new Integer(123)==123

C.new Integer(3250)==new Integer(3250)

D.new String(“abc”)==“abc“
【正确答案】B
【答案解析】B选项有共享区域，在区域内就是共享结果为true，不在就返回false。B在范围之内，C出范围

38、【单选题】
ArrayList list = new ArrayList(20);中的list扩充几次？
A.0
B.1
C.2
D.3
【正确答案】A
【答案解析】可以指定Arraylist初始容量，所以没有扩容

39、【单选题】
下列标识符定义不正确的是
A.HelloWord
B.main
C.char
D._123
【正确答案】C
【答案解析】标识符不能是关键字

40、【单选题】
public class test{ public static void main (String args[]){ int i＝0×FFFFFFF1; int j＝~i; } } 当程序运行到第五行的时候i和j分别是多少
A.i为-15 j为14
B.i为-14 j为15
C.编译异常
D.运行异常
【正确答案】A
【答案解析】0xfffffff1是十六进制的补码形式，每个f转变成二进制都是4个1，所以转成二进制的形式就是前面28位都是1中间3位是0最后1位是1，想要得到i的值需要把补码转成原码，最后就是-15。j按位取反就是前28位都是0中间3位是1最后一位是0最后结果就是14

1、【多选题】
对于代码： class A { private static void m(){} } public class B extends A {// 1 } 下列各项中添加到// 1处不会出错的是：
A.public static int m(){return 0;}
B.private void m() throws Exception {}
C.void m(){}
D.public final double m(double i){return i *= 3;}
E.public abstract void m();
【正确答案】A,B,C,D
【答案解析】父类私有方法对子类不可见，所以子类可以定义任意方法只要符合语法即可，因为B类不是抽象类所以不能定义抽象方法

2、【多选题】
下列各项中，能够正确编译（不考虑运行）的是
A.Integer i = new Integer(“0x123”)
B.Double d = new Double(5)
C.Boolean b = new Boolean(“tRue”)
D.Boolean b = new Boolean(“abc”)
【正确答案】A,B,C,D
【答案解析】编译都不会报错都是通过字符串去构建包装类对象

3、【多选题】
在下列代码的//insert code here 处，加上下列哪行代码运行时会抛出java.lang.ClassCastException? interface foo {
}

class Alpha implements foo {
}

class Beta extends Alpha {
}
pulic class Delta extends Beta {
public static void main(String[] args){
Beta x = new Beta();
//insert code here
}
}
A.Alpha a = x;
B.foo f = (Delta) x;
C.foo f = (Alpha) x
D.Beta b = (Beta)(Alpha)x;
E.Delta d = (Delta)(Alpha)x;
【正确答案】B,E
【答案解析】如果进行和接口进行值的转换只要对象类型和接口不是实现类关系就会报错。如果要和类进行值的转换先要保证两个对象之间有继承关系这个能保证编译没错，再保证两个对象的实际创建类不是同一个运行就会报错。

4、【多选题】
下列关于集合的说法正确的是
A.集合的顶级接口是Collections
B.List中存储的元素的内存空间一定是连续的
C.Set中的元素是不可重复的
D.可以利用Iterable对集合进行迭代遍历
【正确答案】C
【答案解析】

5、【多选题】
如果当前路径在C:UserTest下，则下列各项命令中，能够直接跳转到根目录下的是：
A.cd C://
B.cd .
C.cd …
D.cd ~
E.cd /
【正确答案】A,E
【答案解析】BCD三个选项都是跳转到其他目录不一定是根目录

6、【多选题】
下列程序中不会出现编译错误的是
A.short s1 = 3; short s2 = 5; s1 += s2;
B.short s1 = 3; short s2 = 5; s1 = s1+s2;
C.short s1 = 3; short s2 = 5; s1 = s1 * s2;
D.short s1 = 3; short s2 = 5; s1 *= s2 ;
【正确答案】A,D
【答案解析】扩展赋值运算默认底层有强制类型转换不会出现编译错误

7、【多选题】
下面哪些是合法的标志符
A.2variable
B.String2
C.what$
D.3
【正确答案】B,C,D
【答案解析】不能以数字开头

8、【多选题】
下列各项中能正确编译运行的是
A.byte b=120+8;
B.char c=’d’;c++;
C.byte b=3;b*=2;
D.short s=’a’;s=s+5;
E.short s1=3,s2=6;short s=s1+s2;
【正确答案】B,C
【答案解析】扩展赋值运算符默认含有强制类型转换，BC两个选项都是

9、【多选题】
下列关于Lambda表达式说法正确的是
A.当一个接口中有多个抽象方法的时候，可以通过Lambda表达式来重写其中的方法
B.可以通过::来传递Arrays.sort()
C.由于Lambda表达式是表示重写某个抽象方法，因此参数列表不可省略
D.当Lambda表达式的函数体只有一句的时候，可以省略return不写
【正确答案】B,D
【答案解析】接口中只有一个抽象方法时才能使用Lambda表达式。::可以传递静态方法。只有一个参数而且全局只操作这一个参数时可以省略。只有一句时可以省略

10、【多选题】
下列说法正确的是
A.使用transient修饰的变量不会被序列化
B.使用PrintWriter可以将对象进行传输
C.使用FileOutputStream可以将对象进行传输
D.对象序列化的所属类需要实现Serializable接口
【正确答案】A,D
【答案解析】PrintWriter和FileOutPutStream都不能传输对象

11、【多选题】
下列各项可能会出现空指针异常的是
A.s != null & !s.equals(“”);
B.s != null && !s.equals(“”);
C.s != null | !s.equals(“”);
D.s != null || !s.equals(“”);
E.s == null || s.equals(“”)
【正确答案】A,C,D
【答案解析】只要逻辑运算符的左边是false而且能执行右边内容就会出现空指针异常

12、【多选题】
（内部类）Java 中的内部类包括
A.成员内部类
B.静态内部类
C.公开内部类
D.抽象内部类
E.局部内部类
【正确答案】A,B,E
【答案解析】内部类包括：局部内部类、成员内部类、静态内部类、匿名内部类

13、【多选题】
下列各项中可以正确编译运行的是:
A.byte b = 3 + 5；
B.char c = 98; c++;
C.float f = ‘a’;
D.double d = 123456789012;
E.byte b = ‘a’;
【正确答案】A,B,C,E
【答案解析】A选项是只有直接量计算会进行编译优化直接计算结果进行赋值。B选项++会默认进行强制类型转换。D选项的值超过了int范围

14、【多选题】
下列选项中，哪个可以使下列代码成功编译？
package cn.tedu.a; class Super{
private int a; //第2行
Super(){} // 第3行
protected Super(int a){
this.a = a;
}
}
pakcage cn.tedu.b;
import cn.tedu.a.Super;
public class Sub extends Super{
public Sub(int a){
super(a);
}
public Sub() {
this.a = 5;//第8行
}
}
A.将第2行改成public int a;
B.将第8行改成super(6);
C.将第2行改成int a;
D.将第3行改成protected Super(){};
E.将第8行改成this(5);
【正确答案】B,E
【答案解析】此题的错误出在第8行，一是不能调用到父类私有属性，二是子类构造方法不能默认调用到父类无参构造

15、【多选题】
下面关于jdk8的新特性说法正确的是
A.jdk8开始，接口中允许定义实体方法。
B.jdk8开始，switch 语句可以用字符串
C.jdk8开始，支持Lambda表达式
D.Lambda表达式中，当方法体只有一句话时，可以省略return语句。
【正确答案】A,C,D
【答案解析】从jdk1.7开始switch表达式支持String类型

16、【多选题】
给出以下代码，请问该程序的运行结果是什么？
class A{
private int x=0;
static int y=1;
protected int z=2;
}
class B extends A{
void method(){
System.out.println(x);
System.out.println(y);
System.out.println(z);
}
} 下列说法正确的是（）
A.程序编译错误，因为类B不能访问变量x
B.程序编译成功，打印输出012。
C.程序编译错误，如果移走System.out.println(x)这条语句，可使编译程序通过。
D.程序编译错误,因为变量x未在类B中定义。
【正确答案】A,C,D
【答案解析】Private在父类中是私有属性子类访问不到

17、【多选题】
对于代码 public class Test { public double add(int a, double b){ return a + b; } // 1 } 下列各项中添加在// 1处编译不会出错的是：
A.pubic void add(double i ,double j){return i + j;}
B.public static double add(int i, double j){return i + j;}
C.public final double adds(int a, double b){return a + b;}
D.public double add(double b, int a){return a + b;}
E.public abstract double add(double a,double b);
【正确答案】C,D
【答案解析】

18、【多选题】
下列选项中，哪个可以使下列代码成功编译（） class Super{ private int a; //第2行 protected Super(int a) { this.a=a; } } public class Sub extends Super{ public Sub(int a) { super(a); } public Sub() { this.a=5; //第7行 } }
A.将第2行改为public int a
B.将第7行改为super(a)
C.将第2行改为int a
D.将第7行改为super(5)
E.将第7行改为this(5);
【正确答案】D,E
【答案解析】每个子类构造方法中都要默认调用父类的构造方法，此时父类只有有参构造，所以只有DE符合要求

19、【多选题】
下列关于静态方法中说法正确的是
A.静态方法中不能直接调用非静态方法
B.静态方法不能通过实例调用
C.静态方法能够用类名直接调用
D.可以在不产生任何一个对象的情况下调用静态方法
E.静态方法里可以使用 this
【正确答案】A,C,D
【答案解析】静态方法可以被对象调用。静态方法里不能使用this，级别不一致

20、【多选题】
下列关于Java中的类和对象的说法正确的是
A.类和对象一样，只是说法不一样
B.对象是具有属性和行为的实体
C.类规定类对象所拥有的特征和行为
D.类是对一类对象的概括
【正确答案】B,C,D
【答案解析】类和对象不一样，类是一段描述，对象是具体表现

21、【多选题】
下列各项中对于正确赋值的是
A.byte b =‘a’;
B.short s = 2 << 5;
C.float f = -5;
D.float f = 3.2f / 1;
【正确答案】A,B,C,D
【答案解析】上述四种赋值都是正确赋值

22、【多选题】
下列说法正确的是
A.HashMap的实现不是线程同步的，不是线程安全的
B.HashMap中的key-value都是存放在Entry中的
C.HashMap有两个参数影响其对象的性能：“初始容量”、“加载因子
D.Hashmap保证元素的顺序恒久不变
【正确答案】A,B,C
【答案解析】HashMap底层的键是根据链式栈结构来进行存储的，扩容之后就会重新计算所有结果，所有无法保证顺序不变
　
23、【多选题】
关于代码public class Demo {
int value;
public static void main(String[] args) {
Animal a = new Dog(); // 1
}
}

interface tiger {
}

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal{}}}可以填在1处编译没错运行有错的选项是？
A.Dog d=(Dog)a;
B.Cat c=(Cat)a;
C.Animal e=(Animal)a;
D.tiger t=(tiger)a;
【正确答案】B,C,D
【答案解析】给类传值时要求运行有错就是检测实际创建类不是一个。给接口传值运行报错不是实现类就行

24、【多选题】
下列关于java中的方法描述正确的是
A.Java中定义方法的格式是，修饰符返回值类型方法名(参数列表){方法体}
B.Java中的方法，如果有返回值，方法中必须有return语句
C.Java中定义方法，参数列表中必须有形参变量
D.Java中的方法，可以无限的被反复调用
【正确答案】A,B,D
【答案解析】方法可以没有参数

25、【多选题】
在Java中关于abstract关键字，以下说法正确的是
A.abstract类中可以没有抽象方法
B.abstract类的子类也可以是抽象类
C.abstract方法可以有方法体
D.abstract类可以创建对象
E.abstract类可以有构造方法
【正确答案】A,B,E
【答案解析】抽象方法不能有方法体且抽象类不能创建对象

26、【多选题】
下列关于Java中文件输入输出的说法错误的是
A.在Java中，可以通过流来实现文件的读写操作
B.要向文件中写入数据，可以用一个输入流对象
C.字符流在汉字的处理方面比字节流更加的高效
D.可以通过Reader reader = new Reader(“C:a.txt”);来创建一个流对象
E.字符流底层也是通过字节流来实现的，因此通过字符流来操作的一定可以通过字节流来操作
【正确答案】B,D
【答案解析】写入数据是需要一个输出流对象。Reader是抽象类没有对象

27、【多选题】
在使用super和this关键字是，以下描述错误的是
A.在子类构造方法中使用super( )显式调用父类的构造方法，super( )必须写在子类构造方法的第一行，否则编译不通过
B.super( )和this( )不一定要放在构造方法内第一行
C.this( )和super( )可以同时出现在一个构造函数中
D.this( )和super( )可以在static环境中使用，包括static方法和static语句块
【正确答案】B,C,D
【答案解析】super语句和this语句均需放在构造方法首行，所以不能同时出现。两个语句都是对象级别的不能在静态信息里使用

28、【多选题】
下列各项中可以正确编译运行的是
A.Integer i = new Integer(“017”);
B.Long l = 35;
C.Byte b = new Byte(127);
D.Float f = ‘a’;
E.Boolean b = new Boolean(null);
【正确答案】A,E
【答案解析】BD选项是属于自动封箱，在进行自动封箱时需要保证基本类型数据只能直接封箱为对应类型包装类。C是属于封箱但是也是范围不一致

29、【多选题】
两段if执行完之后，各自C的输出值正确的是 int a = 1,b = 2,c = 3; 　　if(a > b && c++ > b) 　　int a = 1,b = 2,c = 3; 　　if(a > b & c++ > b)
A.3，4
B.3，3
C.4，4
D.编译异常
【正确答案】A
【答案解析】&&左边的值为false会出现短路右边默认不执行，&无论左边是什么布尔值右边都要执行
JavaWeb测试题答案解析请看：https://blog.csdn.net/acsdds/article/details/109193902