java 基础面试练习题(易错题)

单选题

2. 下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换：
byte[] src,dst;

A：dst=String.frombytes(src,”GBK”).getbytes(“UTF-8”)
B：dst=new String (src,”GBK”).getbytes(“UTF-8”)
C：dst=new String (”GBK”, src,) getbytes()
D：dst=String.encode(string.decode(src,”GBK”)), “UTF-8”)

参考答案：
B

3.单选
以下关于类和对象的说法，哪一个是错误的（ ）？

A：类是抽象的，对象是具体的

B：类可以产生多个对象，多个对象可以抽象出一个类

C：“人”这个类，可以具体化为学生、工人，因此学生和工人就是对象

D：类可以通过 new 产生对象

参考答案：
C
解析：

工人和学生仍然是一个抽象的概念，因此工人和类仍然是类。

7.单选
关于对象的初始化过程，以下顺序正确的是（ ）？

A：
①将成员变量赋为定义类时设置的初值。
②实例化对象时，成员变量初始化为默认值。
③通过初始化块给成员变量赋值
④调用构造方法时，使用构造方法所带的参数初始化成员变量

B：
①实例化对象时，成员变量初始化为默认值。
②将成员变量赋为定义类时设置的初值。
③通过初始化块给成员变量赋值 。
④调用构造方法时，使用构造方法所带的参数初始化成员变量

C：
①通过初始化块给成员变量赋值
②将成员变量赋为定义类时设置的初值。
③实例化对象时，成员变量初始化为默认值。
④调用构造方法时，使用构造方法所带的参数初始化成员变量

D：
①调用构造方法时，使用构造方法所带的参数初始化成员变量
②将成员变量赋为定义类时设置的初值。
③通过初始化块给成员变量赋值 。
④实例化对象时，成员变量初始化为默认值。

参考答案：
B

解析：
对象的初始化过程遵循的顺序是：

①实例化对象时，成员变量初始化为默认值。
②将成员变量赋为定义类时设置的初值。
③通过初始化块给成员变量赋值
④调用构造方法时，使用构造方法所带的参数初始化成员变量

11. 给出以下代码

public class TestObj{
    public static void main(String[] args){
        Object o=new Object(){
            public boolean equals(Object obj){
                return true;
            }
        };
        System.out.println(o.equals(“Fred”));
    }
}

请给出结果：（）
A：运行时抛出异常
B：true
C：Fred
D：第三行编译错误

参考答案：
B
解析：

实例化的对象重写了equals（）方法，无论输入什么都会输出true。
此题较难，综合了匿名内部类知识和重写的知识，实际上new后面的类并不是Object，而是一个继承Object的类，但它没有名字，是一个匿名的内部类

。

12. 如下代码

 public class Test{
  public int aMethod(){
    static int i=0;
    i++;
    return i;
  }
  public static void main (String args[]){
    Test test=new Test();
    test.aMethod();
    int j=test.aMethod();
    System.out.println(j);
  }
}

输出的结果是什么（）

A：0
B：1
C：2
D：编译失败

参考答案：
D
解析：

非静态方法里不能存在静态的局部变量。

14. 以下程序的执行结果是（）

class Base{
public Base(String s) {
    System.out.print("B");
    }
}
public class Derived extends Base{
    public Derived(String s) {
        System.out.println("D");
    }
}
public static void main(String []args){
    new Derived("C");
}

A：BD
B：DB
C：C
D：编译错误

参考答案：

• [ ]
• D

解析：
实例化子类时会先调用父类的构造器，子类构造器不显示提供调用父类构造器的方法（super()）时，则子类默认调用父类无参的构造器，但是此题中父类提供了有参构造器，编译器不会再默认提供无参构造器，所以编译器会因为找不到构造器而报错。

15.

 Math.floor(-8.5)=( )
A：(float)-8.0
B：(long)-9
C：(long)-8
D：(double)-9.0

参考答案：
D
解析：

Math.floor(x)取得小于等于x的最大值，返回类型是double类

18. 以下对抽象类的描述正确的是（）
A：抽象类没有构造方法
B：抽象类必须提供抽象方法
C：有抽象方法的类一定是抽象类
D：抽象类可以通过new关键字直接实例化

参考答案：
C
解析：

抽象类可以有构造方法；抽象类中可以没有抽象方法；有抽象方法的类一定是抽象类； 抽象类不能被直接实例化。

19. 在类设计中，类的成员变量要求仅仅能够被同一package下的类访问，请问应该使用下列哪个修饰词（）
A：protected
B：public
C：private
D：不需要任何修饰词

参考答案：
D
解析：

而default和protected老有人记不住。 只要记住protected一个特点是只要子类都能访问，不管在不在一个包。

20. 以下代码运行输出是（）

public class Person{
   private String name=”person”;
   int age=0;
}
   pubic class Child extends Person{
 public String grade;
 public static void main(String[] args){
 Person p=new Child();
 System.out.println(p.name);
}
}

A：没有输出
B：编译出错
C：运行出错
D：输出：Person

参考答案：
B
解析：

父类Person的成员变量name是private，不能被子类继承

25. 给出以下代码,请给出结果.

class A{
    Byte x;
}
class B{
    public static void main(String[] args){
        B b=new B();
        b.start();
    }
    void start(){
        A a=new A();
        System.out.print(a.x+””);
        A a2=fix(a);
        System.out.print(a.x+” ” +a2.x);
    }
    A fix(A aa){
        aa.x=42;
        return aa;
    }
}

A：null null 42
B：null 42 42
C：0 0 42
D：0 42 42
E：An exception is thrown at runtime
F：Compilation

参考答案：
B
解析：

主要的逻辑在该方法中完成 void start(){
A a=new A(); //创建一个A类型的a变量，a里的Byte类型(byte的包装类类型)的成员变量x默认值为null
System.out.print(a.x+””);//输出a的属性x=null
A a2=fix(a); //将对象传入fix方法，局部变量aa和a指向同一个对象，返回的引用也同理
System.out.print(a.x+” ” +a2.x);//a和a2指向同一个引用
}
Byte与byte不同，Byte是一个包装类，所以定义没有初始化的类为null
关键要理解在方法传参中，引用的传递是复制引用而不是复制一个新对象

26. 给出类代码：

public class A  { 
    public static void main(String[] args){ 
     for(int i=0;i<2;i++){ 
      switch(i){ 
         case 0: System.out.print(i);       
         case 1: System.out.print(i);        
         break;       
       }      
     } 
     System.out.println("End");  
   } 
}

运行的结果是：

A：01End
B：0End

C：1End
D：001End

参考答案：
D
解析：

switch-case语句从与case值匹配的地方开始执行，直到遇到break为止；假如没有break，则程序从匹配处走完整个switch-case语句

28. 按照Java的标识符命名规范，下列关于类名的标识符最符合规范的是（）
A：Helloman
B：HelloMan
C：helloman
D：helloMan

参考答案：
B
解析：

java 标识符可以是 字母、数字、$、_(下划线)，但不可用数字开头 不可以是java 的关键字
包名：全部小写（如：multiplicationtable） 类名：每个单词的首字母大写（如：MultiplicationTable）
变量名：第一个字母小写，以后每个单词的首字母大写（如：multiplicationTable）
常量：全部使用大写字母，单词间用下划线隔开（如：MULTIPLICATION_TABLE）

32. DRAM 存储器的中文含义是（ ）
A：动态随机存储器
B：动态只读存储器
C：静态只读存储器
D：静态随机存储器

参考答案：
A
解析：

DRAM即为Dynamic Random Access Memory的缩写

33.

int i=1, j=10 ;
do{
if(i++>--j) continue;
}while(i<5);

以上代码执行结束，i和j的值为？

A：i = 6 and j = 5
B：i = 5 and j = 5
C：i = 6 and j = 4
D：i = 5 and j = 6
E：i = 6 and j = 6

参考答案：
D
解析：

i++是先比较再做自加一运算；–j是先做减一运算再比较大小

34. 在Java语言的控制结构中，break语句是经常用到的语句。下面一段代码中break语句起到（ ）的作用。

int pointer = 0;
while (pointer <= 10) {
    switch (pointer % 3) {
    case 1:
        pointer += 1;
        break;
    case 2:
        pointer += 2;
        break;
    default:
        pointer += 3;
        break;
    }
}

A：结束当次循环，使控制权直接转移到控制循环的条件表达式
B：从嵌套循环内部跳出最里面的循环
C：终止switch语句的语句序列，提高switch-case语句性能

D：退出循环

参考答案：
C
解析：

此处break用于中止switch-case块

35. 想要编译和运行java程序，我们至少需要______
A：jdk
B：jre
C：jdk或者jre
D：jdk和jre

参考答案：
A
解析：

jdk自带jre，既能编译也能运行。

40. 请问以上程序执行的结果是？（）

public class Test{ 
    public String name="abc"; 
    public static void main(String[] args){ 
        Test test=new Test(); 
        Test testB=new Test(); 
        System.out.println(test.equals(testB)+","+test.name.equals(testB.name)); 
    } 
}

A：true,true
B：true,false
C：false,true
D：false,false

参考答案：
C
解析：

equals没重写时候和==一样，比较的是对象的地址，题中new
了两个对象，所以各自地址不一样，使用equals比较两个对象为false。但是String类型中的equals方法Java默认重写了，比较的是
String的值；两个对象指向的同一个String成员变量里的值相同，所以eqauals比较也相同。

43. 下面的代码执行结果是：

Public class TT{
    public static void main(String[]args){
        String a=”A”;
        StringBuffer b=new StringBuffer(“B”);
        StringBuffer c=new StringBuffer(“c”);
        change(a,b,c);
        System.out.println(a+”,”+b+”,”+c);
    } 
    static void change(String s,StringBuffer s1,StringBuffer s2){
        s=s+”1”;
        s1.append(“1”);
        s2=new StringBuffer(“c1”);
    }
}

A：A,B1,c
B：A1,B1,c1
C：A,B,c1
D：A1,B1,c1

参考答案：
A
解析：

change(String s,StringBuffer s1,StringBuffer s2)方法里形参是实参的副本。
s、s1、s2复制的都是引用，对于String
类型的s，在方法内改变引用，对实参无影响，s+"1"并不能改变s的内容，因为s字符串是不可变的，这样做会产生一个新对象和新地址改变s的值对a没有影响；
改变s1所指对象的内容实质上会影响b所指对象的内容； s2的引用都改变了，对c也就没有影响了。

44. 下列哪个选项是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调试器
avaprof.exe：剖析工具

45. 以下代码的输出结果是

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
解析：

开始时JVM加载B.class，对所有的静态成员进行声明，t1 t2被初始化为默认值，为null，又因为t1
t2需要被显式初始化，所以对t1进行显式初始化，初始化代码块→构造函数（没有就是调用默认的构造函数），咦！静态代码块咋不初始化？因为在开始时已经
对static部分进行了初始化，虽然只对static变量进行了初始化，但在初始化t1时也不会再执行static块了，因为JVM认为这是第二次加载
类B了，所以static会在t1初始化时被忽略掉，所以直接初始化非static部分，也就是构造块部分（输出’‘构造块’’）接着构造函数（无输
出）。接着对t2进行初始化过程同t1相同（输出’构造块’），此时就对所有的static变量都完成了初始化，接着就执行static块部分（输出’静
态块’），接着执行，main方法，同样也，new了对象，调用构造函数输出（‘构造块’）

46. 下面的代码在编译时_____________不会发生错误
A：

int i=0;
if(i) {
      System.out.println(“Hello”);
}

B：

boolean b=true;
  Boolean b2=true;
  if(b==b2) {
           System.out.println(“Hello”);
}

C：

int i=1;
  Int j=2;
if(i==1 || j==2){
   System.out.println(“So true”);
}

D：

int i=1;
int j=2;
if(i==1&| j==2)
   System.out.println(“OK”);

参考答案：
B
解析：

A.if的条件判断语句只能是boolean;
C.Int不是一种数据类型;
D.&|不是正确的运算符 主要考察学生是否细心认真

48. 执行下面代码，下面描述正确的是：

public class Person{
    static int arr[] = new int[10];
    public static void main(String arr[]){
        System.out.println(arr[1]);
    }
}

A：产生编译错误
B：输出null
C：编译正确，运行错误
D：输出0

参考答案：
C
解析：

main（String arr[]）是程序的入口，String[]
arr是main函数的形式参数,可以用来获取命令行用户输入进去的参数;在本程序中，运行程序前没有给主函数任何参数，所以程序中使用arr[1]会出现数组越界异常。

51.
当编译并运行以下程序列会出现什么结果？( )

class A{ 
         public int getNumber(int a){ 
            return a+1; 
         } 
    } 
    class B extends A{ 
         public int getNumber(int a, char c){ 
            return a+2; 
        } 
         public static void main(String[] args){ 
            B b=new B(); 
            System.out.println(b.getNumber(0)); 
         } 
      }

A：编译错误
B：运行错误
C：1
D：2

参考答案：
C
解析：

子类继承了父类getNumber(int a)方法，并与getNumber(int a，char b)构成重载的关系

52. 字符（char）的整数表示范围为
A：0∽32767
B：0∽65535
C：-256∽255
D：-32768∽32767

参考答案：
B
解析：

java中统一字符使用两个字节表示，也就是16位，取值范围是0∽2^16

53. 下列代码执行结果是（）

public class Test {
  public static void main(String[] args) {
    StringBuffer a = new StringBuffer("A");
    StringBuffer b = new StringBuffer("B");
    operate (a,b);
    System.out.println(a+","+b);
  }
  static void operate(StringBuffer x, StringBuffer y) {
    x.append(y);
    y = x;
  }
}

A：显示“A,B”
B：显示“A,A”
C：显示“B,B”
D：显示“AB,B”
E：显示“AB,AB”
F：编译 错误，因为在两个StringBuffer对象之间不能用运算符“+”

参考答案：
D
解析：

此题考点为参数的值传递方式,参数传递时,方法内得到的是实参的一份拷贝.
对于引用类型变量来说,拷贝的意思是新变量和原变量指向统一对象,所以对方法参数调用更新方法对对象做出改变可以影响实参,但是对局部变量重新赋值不会影响实参.
在operate方法中形参变量x和实参变量a指向同一块内存地址，所以对x的操作x.append(y)影响变量a所指向对象的内容（变为AB）；y=x是将x的内存地址赋值给了局部变量y,对b没有影响，所以b的内容还是B;

57.
在提示处插入代码，接收控制台输入的浮点数和字符串，然后原样按相反顺序输出字符串、浮点数和整数：

import java.util.Scanner;
 
public class Test {
 
  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int i = scan.nextInt();
    // 在此处插入你的代码
    System.out.println("String: " + s);
    System.out.println("Double: " + d);
    System.out.println("Int: " + i);
  }
 
}

A：

Double d=scan.nextDouble();
String s=scan.nextLine();
scan.close();

B：

Double d=scan.nextInt();
String s=scan.nextLine();
scan.close();

C：

Double d=scan.nextDouble();
String s=scan.nextLine();

D：

Double d=scan.nextDouble();
scan.nextLine();
String s=scan.nextLine();
scan.close();

参考答案：
D
解析：

A错误，nextDouble()方法之后紧跟着一个nextLine()方法，此时nextLine()返回的是一个空值，因为nextLine()方
法是以换行符为结束标志的，但是缓存内仍有上一个nextDouble()方法遗留的换行符，这就导致nextLine()方法只读取了缓存内遗留的换行
符，而不会让用户按照预期来输入字符串（hello scanner！）~换行符。
B错误，除了有A类型的错误外，Double
d=scan.nextInt();也存着错误，nextInt()只能读取整形的数据。
C错误，除了有AB类型的错误外,也存在着没有关闭输入流的警告。
D. 正确，为了解决nextInt()或nextDouble()方法之后的nextLine()方法失效的问题，需要先吃掉缓存内的换行符，在这里提供一个
方法，例如本题中：在题目代码"String s=scan.nextLine();"之前添加"scan.nextLine();"的方法。

64. 执行代码 int i=6,j=8,k=10,m=7; if(i < j | m > ++k) k++; 后，k的值是多少
A：12
B：11
C：10
D：9

参考答案：
A
解析：

对于逻辑运算，逻辑&&和||存在“短路现象”，而按位&和|则不存在短路现象，运算功能上二者相同。

66. 指出下列程序运行的结果（）

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
解析：

方法的形参传递的是原始对象的副本，当改变对象时，原来对象不受影响；但是改变对象里的内容时，原始对象里的内容也会受影响。
例如题目中change（）方法里Str="test
ok"就不会影响类成员变量str的值；而ch[0]='g’确改变了成员变量ch里ch[0]的值

67. 在Java中，下列关于方法重载的说法中错误的是（ ）
A：方法重载要求方法名称必须相同
B：重载方法的参数列表必须不一致
C：重载方法的返回类型必须一致
D：一个方法在所属的类中可以被重载多次

参考答案：
C
解析：

方法重载：在同一个类中方法名称相同，方法的参数不同，这些方法就称为方法重载

72. 以下程序执行的结果是：

class X{
    Y y=new Y();
    public X(){
        System.out.print("X");
    }
}
class Y{
    public Y(){
        System.out.print("Y");
    }
}
public class Z extends X{
    Y y=new Y();
    public Z(){
        System.out.print("Z");
    }
    public static void main(String[] args) {
        new Z();
    }
}

A：ZYXX
B：ZYXY
C：YXYZ
D：XYZX

参考答案：
C
解析：

初始化过程：

1. 初始化父类中的静态成员变量和静态代码块 ；

2. 初始化子类中的静态成员变量和静态代码块 ；

3.初始化父类的普通成员变量和代码块，再执行父类的构造方法；

4.初始化子类的普通成员变量和代码块，再执行子类的构造方法；

（1）初始化父类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y

（2）再执行父类的构造方法；输出X

（3） 初始化子类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y

（4）再执行子类的构造方法；输出Z

81. 以下描述错误的有（）
A：abstract 可以修饰类、接口、方法
B：abstract修饰的类主要用于被继承
C：abstract 可以修饰变量
D：abstract修饰的类，其子类也可以是abstract修饰的
E：final可以用来修饰类、方法、变量

参考答案：
C
解析：

abstract 可以用来修饰类、接口、方法，但是不能用来修饰变量

83. 分析下面的代码，正确的选项是（）

class A{ 
    private String name; 
    A(String name){ 
        this.name = name;
    } 
} 
class B extends A{ }

A：编译不成功,因为B中没有代码
B：编译成功
C：编译不成功,因为B没有构造器
D：编译不成功,因为B未显式指定父类构造器

参考答案：
D
解析：

在继承中，子类不显示继承父类的构造器，系统会默认为子类继承父类无参的构造器；
但是本题目的父类只显示的提供了一个有参的构造器，当父类显示提供构造器后，系统不再为其提供默认的无参构造器；
综合上述两个条件，子类B编译不成功，因为它找不到父类的构造器。

85. 代码片段： 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：输出结果：13
B：语句：b6=b4+b5编译出错
C：语句：b3=b1+b2编译出错
D：运行期抛出异常

参考答案：
C
解析：

被final修饰的变量是常量，这里的b6=b4+b5可以看成是b6=10；在编译时就已经变为b6=10了；而b1和b2是byte类型，java中进行计算时候将他们提升为int类型，再进行计算，b1+b2计算后已经是int类型，赋值给b3，b3是byte类型，类型不匹配，编译不会通过，需要进行强制转换。Java中的byte，short，char进行计算时都会提升为int类型。

86. Java中equal和==的区别是什么？

public class Test1{
    public static void main(String args[]){
            String a="1234";
            String b="1234";
            String c = new String("1234");
            System.out.println(a==b);
            System.out.println(a==c);
            System.out.println(a.equals(c));
    }
}

A：true
false
true
B：
true

true

false

C：
true

false

false

D：
true

true

true

参考答案：
A
解析：

String的equals做内容判断，因为String类重写了这个方法
判断两个引用是否指向同一个地址 通过String a = "1234"这种方式产生的字符串,如果在字符串常量池中存在字符串“1234”则会直接引用，因此String b =
"1234"并未创建新对象而是直接引用常量池中的对象。 而String c = new
String(“1234”)，一定会创建新的对象。因此ac因地址不同结果false，由于a和c的值都是"1234"因此a.equals©的结果为true。

88. 一个以”.java”为后缀的源文件
A：只能包含一个类，类名必须与文件名相同
B：
只能包含与文件名相同的类以及其中的内部类

C：只能有一个与文件名相同的类，可以包含其他类
D：可以包含任意命名的类

参考答案：
C
解析：

java文件只能有一个类是与文件名相同，而包含的其他类不能与之相同，还需注意的是一个.java文件最多有一个public修饰的类。这里要与.class文件分开，一个.class文件有且只有一个类编译后.class

92. 给出以下代码，插入哪个选项，可以依次打印出二维数组中的每个元素？

int[][] arr = new int[2][];
arr[0] = new int[3];
arr[1] = new int[2];
for(int i = 0;i<2;i++){
    for(/*插入代码*/){
        System.out.println(arr[i][j]);
    }
}

A：
int j = 0;j < 2;j++

B：
int j = 0;j < arr.length;j++

C：
int j = 0;j < arr.size;j++

D：
int j = 0;j < arr[i].length;j++

参考答案：
D
解析：

本题考察的是如何获得二维数组每个元素（也是数组）的长度，外层循环用于获得每个元素（arr[i]），内层循环要进一步利用每个元素的长度（arr[i].length），因此D为正确答案。

94. 以下程序的输出结果为（）

public class Base {
  public Base(String s) {
    System.out.println("B");
  }
}
public class Derived extends Base {
  public Derived(String s) {
    System.out.println("D");
  }
  public static void main(String[] args) {
    new Derived("C");
  }
}

A：BD
B：DB
C：C
D：编译错误

参考答案：
D
解析：

子类（Derived）在不显示继承父类（Base）构造函数地情况下，子类构造函数第一行会默认调用父类无参构造函数；但是在本题中父类提供了有参构造函数，编译器不会再提供默认的无参构造函数。

100.

String str1="abc";
String str2=new String("abc");
String str3=new String("abc");
下面表达式，返回值为true的是()

A：
str2==str3;

B：
str1.equals(str2);

C：
str1==str3;

D：
str1==str2;

参考答案：
B
解析：

new对象有新地址，==比较地址，equals比较内容

102. 运行下列代码，按要求依次输入：1_换行3_换行“hello scanner！”。程序的执行结果是（）

import java.util.Scanner;
  
public class Test {
  
       public static void main(String[] args) {
              Scanner scan = new Scanner(System.in);
        int i = scan.nextInt();
        Double d=scan.nextDouble();
        String s=scan.nextLine();
        System.out.println("String: " + s);
        System.out.println("Double: " + d);
        System.out.println("Int: " + i);
       }
  
}

A：
String：hello scanner！
Double：3
Int：1
B：
String：hello scanner！
Double：3.0
Int：1
C：“hello scanner！”无法输入。同时输出结果为：

String：
Double：3
Int：1
D：“hello scanner！”无法输入。同时输出结果为：
String：
Double：3.0
Int：1

参考答案：
D
解析：

nextInt()或nextDouble()方法之后紧跟着一个nextLine()方法，此时nextLine()返回的是一
个空值，因为nextLine()方法是以换行符为结束标志的，但是缓存内仍有上一个nextInt()或nextDouble()方法遗留的换行符，这
就导致nextLine()方法只读取了缓存内遗留的换行符，而没有让用户按照预期来输入字符串（hello scanner！）~换行符。

106. 分析如下的Java代码，编译运行的输出结果是（ ）。

 public class Test {   
  public static void main(String[] args) {       
   String s;   
        System.out.println("s=" + s); 
      }
    }

A：编译通过，并且输出：s=
B：编译通过，并且输出：s=null
C：编译通过，无任何输出
D：编译报错，s未初始化

参考答案：
D

107. 关于String，StringBuilder以及StringBuffer，描述错误的是（）
A：对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象
B：StringBuffer是线程安全
C：StringBuilder是线程安全
D：可以修改StringBuilder和StringBuffer的内容

参考答案：
C
解析：

String：字符串常量，字符串长度不可变。Java中String是immutable（不可变）的；StringBuffer：字符串变量
（Synchronized，即线程安全）；StringBuilder：字符串变量（非线程安全）。在内部，StringBuilder对象被当作是一
个包含字符序列的变长数组。

108. 分析下面的代码，哪个选项能编译成功（）

1.  interface Animal { 
2.      void soundOff(); 
3.  } 
4. 
5.  class Elephant implements Animal { 
6.      public void soundOff() { 
7.          System.out.println("Trumpet"); 
8.      } 
9.  } 
10. 
11.    class Lion implements Animal { 
12.              public void soundOff() { 
13.                  System.out.println("Roar"); 
14.              } 
15.    } 
16. 
17.    class Alpha1 { 
18.              static Animal get( String choice ) { 
19.                if ( choice.equalsIgnoreCase( "meat eater" )) { 
20.                  return new Lion(); 
21.                } else { 
22.                  return new Elephant(); 
23.               } 
24.         } 
25.    }

A：new Animal().soundOff();
B：Elephant e = new Alpha1();
C：Lion 1 = Alpha1.get(“meat eater”);
D：Alpha1.get(“veggie”).soundOff();

参考答案：
D
解析：

工厂模式： 屏蔽对象的产生，统一以接口形式获得实例

112.
如下代码执行的结果为：

 int a = 0;
 
  while (a < 5) {
 
   switch (a) {
 
       case 0:
 
       case 3:
 
           a = a + 2;
 
       case 1:
 
       case 2:
 
            a = a + 3;
 
       default:
 
            a = a + 5;
 
   }
 
  }
 
  System.out.print ( a )  ;

A：5
B：0
C：3
D：10

参考答案：
D
解析：

switch结构执行时，分支中如果没有break语句，则执行下一分支语句。 所以，结构中 a = a + 2; a = a + 3; a
= a + 5;都会执行。

113.

class A{ 
    private String name;
} 
class B extends A{ 
    void f(){ 
        System.out.println(super.name);
    }
}

关于上述代码，叙述正确的是（）

A：编译成功
B：编译失败
C：运行成功
D：f方法输出为null

参考答案：
B
解析：

私有属性name不能在类的外部被访问

118. 以下的变量定义语句中，合法的是（）
A：byte=128
B：boolean=null
C：long a=123L
D：double=0.9239d

参考答案：
C
解析：

变量类型 变量名=值，ABD都没有变量名 即使A有变量名，它的取值范围也错了，byte：-128~127

119. 关于方法的描述，正确的是
A：java程序的入口是main方法，main方法的语法形式为：public static void main(String xc []){}
B：有返回值的方法被调用时，在主调方法中必须接收这个返回值
C：一个方法只能去调用另一个方法，而不能调用它自身
D：方法的形参列表和实参列表在参数的类型、个数、顺序、名称上必须保持完全一致

参考答案：
A
解析：

方法是可以调用其自身的，这种方法我们称为递归方法。方法的形参列表和实参列表在参数的类型、个数、顺序上必须保持完全一致，至于参数名称，相同或不同并没有影响。

122. 在下列java代码中输出的结果是:

class TestMain {
 public static void main(String[] args) {
  int [][]i = {1,2},{3,4},{5,6};
  System.out.println(i[1][1]);
 }
}：

A：3
B：2
C：1
D：4

参考答案：
D
解析：

数组下标从0 开始，所以数组中[1][1]下标的元素为4

123. 下列哪种叙述是正确的 （）
A：abstract修饰符可以修饰字段、方法和类
B：抽象方法的body部分必须用一对大括号包住
C：声明抽象方法，大括号可有可无
D：声明抽象方法不可写出大括号

参考答案：
D
解析：

abstract（抽象）修饰符，可以修饰类和方法，不能用来修饰字段；由abstract的方法没用方法体

124. 下面说法正确的是：
A：变量由字母、下划线、数字、$符号随意组成；
B：变量不能以数字作为开头；
C：A和a在java中是同一个变量；
D：不同类型的变量，可以起相同的名字；

参考答案：
B
解析：

变量命名规则：变量由字母、下划线、数字、$符号组成，数字不能作为开头，大小写敏感

131. 给定如下Java代码，编译运行后，输出的结果将是（ ）

public class Test {
    public static void main(String args[]) {
        String s1 = new String("Test");
        String s2 = new String("Test");
        if (s1 == s2)
            System.out.println("Same");
        if (s1.equals(s2))
            System.out.println("Equals");
    }
}

A：Same
B：Equals
C：SameEquals
D：什么都不输出

参考答案：
B
解析：

1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；如果作用于引用类型的变量，则比较的是所指向的对象的地址
2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量
　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

133. 下面代码的执行结果是（）

public class Main { 
  public static void main(String[] args) { 
    int[][] arr = new int[10][]; 
    System.out.println(arr[0][0]); 
  } 
}

A：0
B：null
C：抛出NullPointerException
D：没有输出

参考答案：
C
解析：

数组在使用之前一定要先定义好长度或者用new
int[10][]{{1,2,3,4,5,6,7,8,9,10}，,……}的形式直接赋值，new int[10][];
只指定了第一维的长度。

138.

int i=1,j=10;
do{
    if(i++>--j) 
        continue;
}while(i<5);
After execution, what are the values for i and j?

A：i=6 and j=5
B：i=5 and j=5
C：i=6 and j=6
D：i=5 and j=6

参考答案：
D
解析：

本题考察++在前和在后的区别，以及continue的理解，仔细分析即可

141. 执行代码 int i=6,j=8,k=10,m=7; if(i < j || m > ++k) k++; 后，k的值是多少

A：12
B：11
C：10
D：9

参考答案：
B
解析：

此题考的是“逻辑运算符”中的“短路现象”。对于表达式i < j || m > ++k，由于i < j为真且整个表达式是一个逻辑或运算，所以m

++k部分将会被短路掉而不会执行。

143. 下面关于数组的说法，错误的是（ ） 。

A：数组是最简单的复合数据类型，是一系列数据的集合
B： 声明数组时，必须分配内存
C： 数组的元素可以是值（基本数据类型） 、对象或其他数组
D： 一个数组中的所有值都必须是相同的类型

参考答案：
B
解析：

数组可以先声明，使用时再分配内存。如： int[] arr = null;
此时只是在栈中声明了一个 arr 数组，但并未对其分配空间 所以B项错误

146. 如下代码的 输出结果是什么？

public class Test {
  public int aMethod() {
    static int i = 0;
    i++;
    return i;
  }
  public static void main (String args[]) {
      Test test = new Test();
      test.aMethod();
      int j = test.aMethod();
      System.out.println(j);  
  }
}

A：0
B：1
C：2
D：编译失败

参考答案：
D
解析：

静态变量只能在类主体中定义，不能在方法中定义；同时静态方法中也不可以定义静态变量。

150.
下面____不是java的关键字？
A：true
B：sizeof
C：const
D：super

参考答案：
B
解析：

const保留关键字没有具体含义； sizeof:Java中没有该关键字

152.

 abstract class AbstractIt{
 abstract float getFloat();
 }
 public class AbstractTest extends AbstractIt{
 private float f1 = 1.0f;
 private float getFloat(){return f1;}
 }

A：Compilation is successful
B：An error on line 6 causes a runtime failure
C：An error at line 6 causes compilation to fail
D：An error at line 2 causes compilation to fail

参考答案：
C
解析：

子类重写父类的方法，访问控制修饰符的范围不能比父类的小

153.

public class IfElse{
    public static void main(String args[]){
        if(odd(5)) 
            System.out.println(“odd”);
        else
            System.out.println(“Even”);
    }
    public static int odd(int x){return x%2;}
}
  

What is the result?

A：
The output is odd

B：
The output is even
C：
An error on line 3 causes compilation to fail

D：
An error on line 8 causes compilation to fail

参考答案：
C
解析：

第三行if括号里只能为true或false，不能为int类型的1或0

154. for循环的一般形式为：
for(表达式1;表达式2;表达式3)
表达式4以下对于for循环描述错误的是
A：表达式1和表达式3是赋值语句，表达式2是判断语句
B：表达式4可以是块语句，也可以是简单语句
C：表达式1、表达式2、表达式3都可省，此时的循环是死循环
D：表达式1只执行一次，表达式2、表达式3至少会执行一次

参考答案：
D
解析：

for循环中，表达式1最先执行且只执行一次，然后执行表达式2，表达式2结果为真，则执行表达式4，反之循环结束。 表达式3有可能不会被执行

158. 命令行工具中,期望在系统的任意目录下都能执行java或javac命令,需要配置哪个环境变量?
A：JAVA_HOME
B：PATH
C：CLASSPATH
D：NULL

参考答案：
B
解析：

当你在命令提示符窗口输入某个可执行程序时,操作系统会在当前目录和PATH变量目录里查找相应的应用程序,
并且执行，将jdk的bin目录加入PATH变量可以保证在任何目录下都可以运行java和javac命令

159. instanceof运算符能够用来判断一个对象是否为:

A：一个类的实例
B：其他答案全部正确
C：一个实现指定接口的类的实例
D：一个子类的实例

参考答案：
B
解析：

instanceof用于判断前面的对象是否为后面的类，或者其子类、实现类的实例。如果是，则返回true，否则返回false。

163.
假定a和b为int型变量,则执行下述语句组后,b的值为 （）

a=1; 
 b=10; 
 do 
 { 
 b-=a; 
 a++; 
 } while (b--<0);

A：9
B：-2
C：-1
D：8

参考答案：
D
解析：

注意循环条件是（b–<0）;该循环只执行一次，变量b变为9，执行循环条件判断是变量b自减1变为8，循环条件不满足，结束循环

164.

if(x>4){
System.out.println(“Test 1”);}
else if (x>9){
System.out.println(“Test 2”);}
else {
System.out.println(“Test 3”);}
Which range of value x would produce of output “Test 2”?

A：x<4
B：x>4
C：x>9
D：None

参考答案：
D
解析：

大于等于4的数不可能大于9，所以第二个分支不可能执行

165.软件设计的主要任务是设计软件的结构、过程、模块，其中软件结构设计的主要任务是要确定（ ）

A.模块间的组成关系
B.模块的具体功能
C.模块间的操作细节
D.模块间的相似性

参考答案：
A

解析：

软件设计：包括软件的结构设计、数据设计、接口设计和过程设计。
结构设计 ：定义软件系统各主要部件之间的关系；
数据设计 ：将模型转换成数据结构的定义；
接口设计 ：软件内部，软件和操作系统间及软件和人之间如何通信；
过程设计 ：系统结构部件转换成软件的过程描述。

167、(2分) [单选题]
given the following
String d=”bookkeeper”；
d.substring(2,9);
d = “u”+d;
System.out.println(d);
What is the result （）

A.ubookkeepertoo
B.An exception is thrown at runtime
C.uookkeewoo
D.ubookkeeper

参考答案：
A

解析：

String类使用final修饰，不可对String对象进行修改，因此d.substring(2,9); 并未对字符串d做任何修改

168、(2分) [单选题]
关于String，StringBuilder以及StringBuffer，描述错误的是（ ）

A.StringBuilder是线程安全
B.对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象
C.可以修改StringBuilder和StringBuffer的内容
D.StringBuffer是线程安全

参考答案：
A
解析：

StringBuffer是线程安全的，StringBuilder不是线程安全的

169.以下描述错误的有（ ）

A.abstract修饰的类主要用于被继承
B.abstract 可以修饰类、接口、方法
C.abstract修饰的类，其子类也可以是abstract修饰的
D. abstract 可以修饰变量

参考答案：
D
解析：

abstract可以修饰类，接口，方法，但是不能修饰属性。

170.有以下代码：

1. interface C {
2.   String name = "";
3.   void f();
4.   abstract void g();
5.   void h(){};
6. }

A.第5行编译错误
B.没有错误,正确
C.第2行编译错误
D.第4行编译错误

参考答案：
A
解析：

接口只能有抽象的方法

171.以下关于break的说法正确的是（）。

A.借助于标号，可以实现任何外层循环中断
B.break只能用于循环结构中
C.只中断最内层的循环
D.只中断最外层的循环

参考答案：
D
解析：

break会中断其所在最近的循环，如果 break后跟标号，则可中断标号之后的所有循环。

172.构造函数何时被调用( )

A.创建对象时
B.类定义时
C.使用对象的变量时
D.调用对象方法时

参考答案：
A
解析：

顾名思义，构造函数在创建对象时调用。

173.下列程序的运行结果是（ ）。

class Parent{
int i=20;
int j=30;
void f(){
System.out.print(" "+i);
}
}
class Child extends Parent {
int i=30;
int k=40;
void f(){
System.out.print(" "+i);
}
void g(){
System.out.print(" "+k);
}
public static void main(String args[]){
Parent x=new Child();
System.out.print(x.i);
x.f();
Child x1=(Child)x;
System.out.print(" "+x1.i);
x1.f();
}
}

A.20 30 30 30
B.都不对
C.30 30 30 30
D.20 20 20 20

参考答案：
A
解析：

成员变量不具有多态性，不可以被覆盖

174.在使用super 和this关键字时，以下描述正确的是（）

A.this（）和super（）可以同时出现在一个构造函数中
B.this（）和super（）可以在static环境中使用，包括static方法和static语句块
C.在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写 在子类构造方法的第一行，否则编译不通过
D.super（）和this（）不一定要放在构造方法内第一行

参考答案：
C
解析：

super()代表父类构造函数，this()代表当前类的构造函数，使用super()或者this()方法是必须放在构造函数的第一行；由于this函数指向的构造函数默认有super()方法，所以规定this()和super()不能同时出现在一个构造函数中；因为static方法或者语句块没有实例时可以使用，而此时还未构造实例，所以不能用this()和super()

175.以下程序的输出结果为（）

public class Base {
  public Base(String s) {
       System.out.println("B");
  }
}
public class Derived extends Base {
  public Derived(String s) {
      System.out.println("D");
  }
  public static void main(String[] args) {
    new Derived("C");
  }
}

A.编译错误
B.C
C.DB
D.BD

参考答案：
A
解析：

子类（Derived）在不显示继承父类（Base）构造函数地情况下，子类构造函数第一行会默认调用父类无参构造函数；但是在本题中父类提供了有参构造函数，编译器不会再提供默认的无参构造函数。

176.如下代码：

class Base {
    Base() {
        System.out.print("Base");
    }
}
public class Alpha extends Base {
    public static void main(String[] args) {
        new Alpha();
        new Base();
    }
}

结果是什么？（）

A.编译失败.
B.运行时抛出异常
C.Base
D.代码运行但没有输出.
E.BaseBase

参考答案：
E
解析：

类的继承与构造方法的调用。

177.下列修饰符中与访问控制无关的是（）

A.final
B.protected
C.public
D.private

参考答案：
A
解析：

final不属于访问权限修饰符

178.下面代码运行结果是（）

public class Demo {
    public int add(int a, int b) {
        try {
            return a + b;
        } catch (Exception e) {
            System.out.println("catch 语句块");
        } finally {
            System.out.println("finally 语句块");
        }
        return 0;
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        System.out.println("和是：" + demo.add(9,34));
    }
}

A.和是：43 finally 语句块
B.finally 语句块 和是：43
C.编译异常
D.catch语句块 和是：43

参考答案：
B
解析：

try里面有return语句，先执行finally的再执行try的。

多选题

1.
针对以下代码，哪些说法是正确的？（选出正确的两项）

class CompareReference{
   public static void main(String [] args){
       float f=42.0f;
       float f1[]=new float[2];
       float f2[]=new float[2];
       float[] f3=f1;
       long x=42;
       f1[0]=42.0f;
  }
}

A：f1f2为true
B：xf1[0]为true
C：f1f3为true
D：f2f1[1]为true

参考答案：
BC
解析：

byte , short , int , long , fload , double作比较的时候会自动向上转型，
向下转型的时候则需要强转，x和f1[0]都是基本数据类型，做运算时转换成float类型在比较；f1和f3指向同一个对象，所以f1f3的结
果为true。D选项中f2为地址，不能与f1[1]比较

2. 下列说法错误的有？（选出正确的两项）
A：在类方法中可用this来调用本类的类方法
B：在类方法中调用本类的类方法时可直接调用
C：在类方法中只能调用本类中的类方法
D：在类方法中绝对不能调用实例方法

参考答案：
CD
解析：

C是明显的错误，类方法可以调用外部其他类的方法。至于D选项中，也是有问题的，只要实力化对象，也是可以调用实例方法的。所有这里要选CD。

8. 关于抽象类和接口的说法，错误的有？（选出正确的三项）
A：抽象类中可以不存在任何抽象方法
B：抽象类和接口都可以有变量
C：如果一个非抽象类从抽象类中派生，不一定要通过覆盖来实现继承的抽象成员
D：抽象类和接口允许被声明
E：接口可以继承多个接口
F：抽象类和接口都可以有构造方法

参考答案：
BCF
解析：

B.抽象类中可以有普通的变量，但接口中只能有由public static final
修饰的常量；C.一个非抽象类从抽象类中派生，一定要通过覆盖来实现继承的抽象成员F.抽象类中可以有构造方法，但是接口中不能有构造方法

9. 关于构造函数的说法不正确的是？（选出正确的三项）
A：一个类只能有一个构造函数
B：一个类可以不显示提供构造函数
C：构造函数与类同名
D：一个类可以有多个不同名的构造函数
E：构造函数不声明返回值类型
F：无参构造方法在任何情况下都默认存在

参考答案：
ADF
解析：

一个类可以有多个构造函数；构造函数的函数名与类名相同，并且该函数没有返回值；当不显示提供构造函数时，系统默认提供一个无参的构造函数；当显示提供构造函数时，系统不提供无参的构造函数；

13. 下面（）是java多态的实现？（选出正确的两项）
A：继承
B：覆盖
C：重载
D：封装

参考答案：
BC
解析：

所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定。重载通过传入的参数决定执行的具体方法从而实现多态，重写通过父类的对象指向子类的引用来实现多态。

15. 下面标识符正确的是?(请选出三项)
A：IDoLikeTheLongNameClass
B：$byte
C：const
D：_ok
E：3_case

参考答案：
ABD
解析：

java 标识符可以是字母、数字、$、_(下划线),不能以数字开头； 关键字不能用作标识符。

20. 哪些是Java关键字？

A：goto
B：null
C：FALSE
D：native
E：const

参考答案：
ABDE
解析：

C不是关键字，关键字都是小写的；goto和const是保留关键字

22. 关于for循环的说法正确的是？（选出正确的三项）
A：for循环必然先执行初始化
B：for循环判断后必然执行循环体
C：执行完变化必然执行判断
D：for循环最后一步执行的是变化

参考答案：
ACD
解析：

for循环的执行顺序：先执行初始化，再执行条件判断，判断为true则执行循环体（判断为false则结束循环），执行判断条件变量的改变，再执行判断

25. 下面哪些不是java的关键字？（选出正确的两项）
A：TRUE
B：sizeof
C：const
D：super
E：void

参考答案：
AB
解析：

const 是Java保留关键字，和goto一样

27. 在Java中下面Class的声明哪些是错误的？（选出正确的三项）
A：

public abstract final class Test {
    abstract void method();
}

B：

public abstract class Test {
    abstract final void method();
}

C：

public abstract class Test {
    abstract void method() {
    }
}

D：

public class Test {
    final void method() {
    }
}

参考答案：
ABC
解析：

A.抽象类不能由final修饰（final修饰的类不能被继承，抽象类存在的意义就是用来被继承的）

B.抽象方法不能由final修饰（final修饰的方法不能被重写，抽象方法存在的意义就是被用来重写的）

C.抽象方法不能写方法体{}

不能用来修饰interface的有？（选出正确的三项）
A：private
B：public
C：protected
D：static

参考答案：
ACD
解析：

接口存在的意义是为了让其他类来继承，被private修饰后只能是本类才能用，被static修饰不能被重写，更谈不上继承。

如果你用protect去修饰它。protected权限范围是当前包内，和继承该类的包外对象。仔细想想，protected 和public
是不是就不一样了

31. 指出正确的表达式？（选出正确的两项）
A：byte i=128
B：boolean i=null
C：long i=0xfffL
D：double i=0.9239d

参考答案：
CD
解析：

A byte ，1字节，值域-128至127；B boolean并非包装对象Boolean，不能赋值为null

32. 关于下列代码（省略类和main方法声明），说法正确的是？（选出正确的两项）

String[] arr = new String[3];
System.out.println(arr[1]);
System.out.println(arr[1].length());

A：编译错误
B：第二行在运行时抛出空指针异常
C：第二行输出：null
D：第三行在运行时抛出运行时异常

参考答案：
CD
解析：

字符串数组在实例化后，元素的初始值为null，null变量的输出为null，C正确。引用一个为null的变量，访问其方法，将得到一个空指针异常，因为null不指向任何对象，D正确。