Java每日一题

1、(单选题)
What will be printed when you execute the following code?

class C {
　　C() {
　　　　System.out.print("C");
　　}
}
class A {
　　C c = new C();
　　A() {
　　　　this("A");
　　　　System.out.print("A");
　　}
　　A(String s) {
　　　　System.out.print(s);
　　}
}
class Test extends A {
　　Test() {
　　　　super("B");
　　　　System.out.print("B");
　　}
　　public static void main(String[] args) {
　　　　new Test();
　　}
}

A、BB B、CBB C、BAB D、None of the above
正确答案是：B
解析：
初始化过程是这样的：
1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
3.其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法；
4.最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法；

（1）初始化父类的普通成员变量和代码块，执行 C c = new C(); 输出C
（2）super("B"); 表示调用父类的构造方法，不调用父类的无参构造函数，输出B
（3） System.out.print("B");
所以输出CBB
2、(单选题)
以下程序执行的结果是：

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
所以输出YXYZ
3、(不定项选择题) 以下关于final关键字说法错误的是
A、 final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性
B、 final修饰的类肯定不能被继承
C 、final修饰的方法不能被重载
D、 final修饰的变量不允许被再次赋值
正确答案是AC
解析：
final修饰类、方法、属性！不能修饰抽象类，因为抽象类一般都是需要被继承的，final修饰后就不能继承了。
final修饰的方法不能被重写而不是重载！
final修饰属性，此属性就是一个常量，不能被再次赋值！

(单选题)4、下列对继承的说法，正确的是（）
A 子类能继承父类的所有方法和状态
B 子类继承父类的非私有方法和状态
C 子类只能继承父类的public方法和状态
D 子类只能继承父类的方法
答案是：B
解析：子类不能继承父类的所有方法和属性 ，只能继承父类所有的非 private（私有）的属性和方法，而private成员是不能被继承的。

(单选题)5、以下的变量定义语句中，合法的是（）
A byte=128
B boolean=null
C long a=123L
D double=0.9239d
答案是：C
解析：Abyte能表示的范围[-128,127] B boolean的取值只能是true或false C 对的 D少了变量名

(单选题)6、abstract和final可以同时作为一个类的修饰符。（ ）
A 正确
B 错误
答案是：B
解析：abstract修饰一个类，这个类肯定可以被继承，但是final类是不能继承的，所以有矛盾，肯定不能同时用
(单选题)
7、A派生出子类B，B派生出子类C，并且在java源代码中有如下声明：
1
2
3
1.A a0=new A();
2.A a1=new B();
3.A a2=new C();
以下哪个说法是正确的？
1/1
A 第1行,第2行和第3行的声明都是正确的
B 第1,2,3行都能通过编译，但第2,3行运行时出错
C 第1,2行能通过编译，但第3行编译出错
D 只有第1行能通过编译
答案是：A
解析：继承具有多态性，可以是本类的引用指向本类对象，也可以是本类的引用指向子类对象
(单选题) 8、检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。

packagealgorithms.com.guan.javajicu;
public class Inc {
    public staticvoid main(String[] args) {
        Incinc = newInc();
        inti = 0;
        inc.fermin(i);
        i=i ++;
        System.out.println(i);

    }
    void fermin(inti){
        i++;
    }
}    

A 0 B 1 C 2 D 3
答案是：A
解析：关于第一个陷阱：为何方法没有对i做出改变。因为java传参是值传递，而且i是一个基本类型变量。java复制了一个i的值给方法，方法自始自终只是在操作这个副本，对原本的i没有影响。 第二个陷阱：为何后缀的自增长也没有改变i的值。因为i=i++；是先把i本身的值（0）赋给等式左边那个i，然后再加一。
(不定项选择题) 9、面向对象的三个基本元素是什么？1/1
A 封装B 继承C 重载D 多态
答案是：ABD
解析：
三个基本元素：封装，继承，多态。
五个基本原则：单一职责原则，开放封闭原则，里氏替换原则，依赖倒置原则，接口隔离原则
(填空题)
10、在 Java 程序中定义的类有两部分组成，分别是： (1) 、 (2)
答案是：（1）属性（2） 方法

(单选题)
11、覆盖与重载的关系是（ ）
A 覆盖只有发生在父类与子类之间，而重载可以发生在同一个类中
B 覆盖方法和重载方法都可以不同名，也可以同名
C final修饰的方法可以被覆盖，但不能被重载
D 覆盖与重载是同一回事
正确答案是：A
解析：方法的重载是指在一个类中存在这样的一些方法（包含从父类继承而来的方法），方法名称一样，但是参数的个数不同，或者参数个数相同，但对应的参数类型不同，这些同名的方法为重载； 而覆盖是指一个子类对其父类中的某个可见方法进行了重新的定义，即重新定义的方法满足名称相同，参数相同以及对应的参数相同的条件。这样，调用时将会调用子类中的方法，而不会调用父类中被覆盖的方法。
(单选题)
12、this代表了()的对象引用,super表示的是当前对象的()对象?
A 当前类当前类
B 当前类的父类当前类
C 当前类当前类的父类
D 以上都不正确
正确答案是：C
解析：this代表当前对象，也就是当前类的对象的引用
super代表其父类对象
(单选题)
13、Java中equal和==的区别是什么？

publicclassTest1{
    public static void main(String args[]){
        String a="1234";
        String b="1234";
        String c = newString("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 a="1234"时，会在常量池中创建一个常量1234,String b=1234时，常量池中已经有了该常量，所以直接取，a和b的地址一样，所以地址值相等；String c = newString("1234")重新new了对象，在堆内存中开辟了新的空间，所以地址值不想等，而equals方法比较的是值是否相等
(单选题) 14、cnt的值是

publicclassTest{
    static int cnt = 6;
    static{
        cnt+= 9;
    }
    public  static void main(String[] args）{
        System.out.println（“cnt =” + cnt);
    }
    static{
        cnt /=3;
    };
}            

A cnt=5
B cnt=2
C cnt=3
D cnt=6
正确答案是：A
解析：
在JVM调用mian方法之前先用进行静态内容的初始化。顺序为：父类的静态变量， 父类的静态代码块 ，子类的静态变量，子类的静态代码块。
(单选题)
15、下列 java 程序输出结果为______。

int i=0;
Integer j = newInteger(0);
System.out.println(i==j);
System.out.println(j.equals(i));

A true,false
B true,true
C false,true
D false,false
E 对于不同的环境结果不同
F 程序无法执行
正确答案是：B
解析：
①无论如何，Integer与new Integer不会相等。不会经历拆箱过程.
②两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false
java在编译Integer i2 = 128的时候,被翻译成-> Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存
③两个都是new出来的,都为false
④int和Integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比

 (单选题) 16、对于上面这段代码，以下说法正确的是：

publicclassTest{
    public int x;
    public static void main(String []args){
        System.out. println("Value is"+ x);
    }
}

A 程序会打出 "Value is 0"
B 程序会抛出 NullPointerException
C 非静态变量不能够被静态方法引用
D 编译器会抛出 "possible reference before assignment"的错误
正确答案是：C
解析：非静态成员只能被类的实例化对象引用，因此这里在静态方法中访问x会造成编译出错
(单选题) 17、下面有关java基本类型的默认值和取值范围，说法错误的是？
A 字节型的类型默认值是0，取值范围是-2^7—2^7-1
B boolean类型默认值是false，取值范围是true\false
C 字符型类型默认是0，取值范围是-2^15 —2^15-1
D long类型默认是0，取值范围是-2^63—2^63-1
正确答案是：C
解析：
java中，char占16bit、byte占8bit、short占16bit、int占32bit、long占64bit、float占32bit、double占64bit。
只有char是无符号类型的。
字符型类型占用的是16位，2字节，但是字符型类型是无符号类型的，所以其取值范围是0 ~ 2^16-1 而不是 -2^15 ~ 2^15-1。
(单选题) 18、What will happen when you attempt to compile and run the 
following code?

public class Test{
    static{
        int x=5;
    }
    static int x,y;
    public static void main(String args[]){
        x--;
        myMethod( );
        System.out.println(x+y+ ++x);
    }
    public static void myMethod( ){
        y=x++ + ++x;
    }
}

A compiletime error
B prints:1
C prints:2
D prints:3
E prints:7
F prints:8
正确答案是：D
解析：
1.静态语句块中x为局部变量，不影响静态变量x的值
2.x和y为静态变量，默认初始值为0，属于当前类，其值得改变会影响整个类运行。
3.java中自增操作非原子性的 
main方法中：执行x--后 x=-1 调用myMethod方法，x执行x++结果为-1(后++)，但x=0，++x结果1，x=1 ，则y=0
x+y+ ++x,先执行x+y，结果为1，执行++x结果为2，得到最终结果为3
(不定项选择题) 19、java中下面哪些是Object类的方法（）
A notify()
B notifyAll()
C sleep
D wait()
正确答案是：ABD
解析：在根类Object中包含以下方法：  
clone();
equals();
finalize();
getClass();[align=left][/align]
notify(),notifyAll();
hashCode();
toString();
wait();

 (单选题) 、Please write the output result 。

public class Test{
     public static void changeStr(String str){
         str= "welcome";
     }
     public static void main(String[] args){
         Stringstr = "1234";
         changeStr(str);
         System.out.println(str);
     }
}

A 1234
B welcome
C 空
D 不确定
正确答案是：A
解析：
此处应该考察Java方法参数传递特性。Java方法调用中，只存在值传递调用。
此处，实参str是引用变量，由于java方法调用是值传递，所以形参str得到的是实参str的一个拷贝。此时形参str和实参str均指向字符串"1234"。
然后，在changeStr方法中，形参str指向了一个新的字符串"welcom"，而后方法结束，形参str被销毁。而实参str仍然指向字符串"1234"。
(单选题)21、关于以下程序代码的说明正确的是()

public class HasStatic {//
    private static intx = 100;//
    public static void main(String args[]) {//
        HasStatich sl = newHasStatic();//
        hsl.x++;//
        HasStatich s2 = newHasStatic();//
        hs2.x++;//
        hsl= newHasStatic();//
        hsl.x++;//
        HasStatic.x--;//
        System.out.println("x="+ x);//
    }
}

A 程序通过编译，输出结果为:x=102
B 程序通过编译，输出结果为:x=103
C 10行不能通过编译.因为x星私有静态变量
D 5行不能通过编译.因为引用了私有静态变量
正确答案是：A
解析：首先要明确，静态(static)是在程序加载的时候就一起写入内存，相当于是一直跟随着它自己这个类，这就可以理解为什么可以用 类名.变量名 来直接调用；接着是实例化对象(也就是new出来的对象)，实例化是必须new了之后才会存在在该类中，也就是说若不是静态方法，你就必须先new，是new这个对象有该类的访问权限，因此new出来的对象名也可以调用静态产量了；最后这就是因为静态变量一开始就加载到内存中，因此++和--都是对同一变量值，所以最终通过编译，值为102
(单选题) 22、HashMap中是用哪些方法来解决哈希冲突的？
A 开放地址法
B 二次哈希法
C 链地址法
D 建立一个公共溢出区
正确答案是：AC
解析：
解决哈希冲突常用的两种方法是：开放定址法和链地址法   开放定址法：当冲突发生时，使用某种探查(亦称探测)技术在散列表中形成一个探查(测)序列。沿此序列逐个单元地查找，直到找到给定 的关键字，或者碰到一个开放的地址(即该地址单元为空)为止（若要插入，在探查到开放的地址，则可将待插入的新结点存人该地址单元）。查找时探查到开放的 地址则表明表中无待查的关键字，即查找失败。    链地址法：将所有关键字为同义词的结点链接在同一个单链表中。若选定的散列表长度为m，则可将散列表定义为一个由m个头指针组成的指针数 组T[0..m-1]。凡是散列地址为i的结点，均插入到以T[i]为头指针的单链表中。T中各分量的初值均应为空指针。
(填空题) 23、若x = 5，y = 10，则x < y和x >= y的逻辑值分别为 (1) 和 (2) 。
正确答案是：(1)true (2)false  

(单选题) 24、有如下一段代码，请选择其运行结果（）

public class StringDemo{
    private static final String MESSAGE="taobao";
    public static void main(String [] args) {
        String a ="tao"+"bao";
        String b="tao";
        String c="bao";
        System.out.println(a==MESSAGE);
        System.out.println((b+c)==MESSAGE);
    }
}    

A true true
B false false
C true false
D false true
正确答案：C
解析：
本题主要考察的是String声明变量在jvm中的存储方法
String a="tao";
String b="bao";
String c="taobao";
a,b,c,都是存在字符串常量池中的
String d="tao" +"bao";也是存在常量池中，d的构造过程是现在常量池中先找是否有“taobao”这个字符长 若有则直接引用改字符串 若没有则在字符长常量池中构造一个“taobao”
类似 String e="tao"+"ba"+"o"; 现在字符串常量池中查找“taoba” 若有则直接引用 若没有则构造一个放在该池中，然后在判断是否有“taobao”过程和前面一样
至于String f=a+b;实际等效于 String f=new String("taobao");存在在堆内存中 所以不相等

(单选题)25、Java 源程序文件的扩展名为（）
A .java
B .class
C .exe
D .jar
正确答案是：A
解析：
.class 编译后的Java文件
.java是未编译的程序
.jsp是页面程序
.xml配置程序
.jar是.calss的集合

(单选题)26、关于私有访问控制符 private 修饰的成员变量，以下说法正确的是（）
A 可以三种类所引用：该类自身、与它在同一包中的其他类，在其他包中的该类的子类
B 可以被两种类访问和引用：该类本身、该类的所有子类
C 只能被该类自身所访问和修改
D 只能被同一个包中的类访问
正确答案是：C
解析：私有变量只能被该类自身调用，类的对象不能使用
(不定项选择题)27、A,B,C,D 中哪些是 setvar的重载？
public class methodover{
　　publicvoid 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
解题要点：
1、重载：
（1）作用范围：同一个类的内部；
（2）定义：方法名相同，但是参数不同（参数的个数不同，参数的类型不同），参数的变量名不同没有影响；
（3）特别注意：重载的方法返回类型以及访问权限以及抛出的异常类型可以相同也可以不同，方法的重载和这些没有关系。
2、重写：
（1）作用范围：继承关系（子类重写父类方法）；实现关系（类重写接口定义的方法）；
（2）定义：方法名和参数、返回类型必须相同，方法的实现不同；被重写的方法是非private类型的；
（3）特别注意：重写的方法访问权限必须大于或等于被重写的方法的访问权限，如果被重写的方法的访问权限为protected，则重写方法的访问权限可以为protected或者public；重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常，可以抛出非检查异常，如果被重写的方法抛出IOException，则重写方法可以抛出RuntimeException或者IOException的子类，不能抛出其他检查异常，如SQLException.
重载和重写的区别：
（1）作用范围不同
重载发生在同一个类内部，重写发生在不同类之间或者类与接口之间；
（2）目的不同
重载的目的是定义不同的方法，重写的目的是对同一个方法有不同的实现；
（3）判别标准不同
方法名相同参数不同的为重载；
方法名相同参数相同返回类型相同的为重写；
（4）注意点不同
重载不许关心返回类型、抛出的异常；
重写需要注意返回类型、抛出的异常；
(不定项选择题) 28、在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修饰的类为最终类，不能被继承，而类前面如果有abstract修饰，则为抽象类，抽象类是需要被继承才有意义，因此abstract和final矛盾，选项错误。
B.被final修饰的方法为最终方法，不能被继承，而方法前面如果有abstract修饰，则为抽象方法，抽象方法是需要被继承才有意义，因此abstract和final矛盾，选项错误。
C.抽象类中的抽象方法不能有具体的实现，而选项中的 abstract void method() {}中{}代表有具体的实现，因此此处应该为abstract void method（）；
注意： abstract 不能与private、static、final或native并列修饰同一个方法。

(不定项选择题) 29、Java7特性中,abstractclass和interface有什么区别。
A 抽象类可以有构造方法，接口中不能有构造方法
B 抽象类中可以有普通成员变量，接口中没有普通成员变量
C 抽象类中不可以包含静态方法，接口中可以包含静态方法
D 一个类可以实现多个接口，但只能继承一个抽象类。
正确答案是:ABD
解析：
抽象类
特点:
抽象类中可以构造方法
抽象类中可以存在普通属性，方法，静态属性和方法。
抽象类中可以存在抽象方法。
如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。
抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。
接口
特点:
在接口中只有方法的声明，没有方法体。
在接口中只有常量，因为定义的变量，在编译的时候都会默认加上
public static final
在接口中的方法，永远都被public来修饰。
接口中没有构造方法，也不能实例化接口的对象。
接口可以实现多继承
接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法
则实现类定义为抽象类。

(单选题)30、如果一个接口Cup有个方法use()，有个类SmallCup实现接口Cup，则在类SmallCup中正确的是？  ( )

A void use() { …}

B protected void use() { …}

C public void use() { …}

D 以上语句都可以用在类SmallCup中

正确答案是：C

解析：

接口，比抽象类还要抽象的类。

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract （只能是 public abstract，其他修饰符都会报错）。

接口中可以含有变量，但是接口中的变量会被隐式的指定为  public static final   变量（并且只能是 public，用 private 修饰会报编译错误。）

接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

注：

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。

接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。

接口中的方法都是公有的。public

(不定项选择题) 31、int，String，*point，union哪些不是 Java 的数据类型？

A int

B String

C *point

D union

正确答案是：CD

题目是说数据类型，并没有说基本数据类型，所有包括了引用数据类型，String为字符串类，属于引用数据类型

(单选题) 32、子类A继承父类B, A a = new A(); 则父类B构造函数、父类B静态代码块、父类B非静态代码块、子类A构造函数、子类A静态代码块、子类A非静态代码块执行的先后顺序是？

A 父类Ｂ静态代码块->父类Ｂ构造函数->子类Ａ静态代码块->父类Ｂ非静态代码块->子类Ａ构造函数->子类Ａ非静态代码块

B 父类Ｂ静态代码块->父类Ｂ构造函数->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块

C 父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数

D 父类Ｂ构造函数->父类Ｂ静态代码块->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块

正确答案是：C

解析：

按照先后顺序：

1，静态先于非静态代码库执行（静态代码块随着类的加载而加载，初始化只执行一次）

2，父类先于子类

3，非静态代码块优于构造函数执行

(单选题) 33、java中，用（）关键字定义常量？

A final

B #define

C float

D const

正确答案是：A

解析：

Java中final关键字表示最终的意思，该关键字可以修饰类，方法，成员变量

被final修饰的类不能被继承

被fianl修饰的方法不能被重写（但可以重载）

被fianl修饰的成员变量是常量

const是C和C++中的常量关键字

(单选题)34、A是抽象父类或接口， B ， C 派生自 A ，或实现 A ，现在 Java 源代码中有如下声明：

1. A a0=new  A();

2. A  a1=new  B();

3. A a2=new  C();

问以下哪个说法是正确的？（）

A 只有第1行不能通过编译

B 第1、2行能通过编译，但第3行编译出错

C 第1、2、3行能通过编译，但第2、3行运行时出错

D 第1行、第2行和第3行的声明都是正确的

正确答案是：A

(单选题) 35、欲定义类字段或类方法（静态方法），应该使用下列哪一个修饰符修饰（）
A public
B static
C protected
D synchronized
正确答案是:B
解析：
public 共有的，以 public 修饰符指定，对所有类可见 static 用来声明独立于对象的静态方法
protected 受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见
synchronized 给对象和方法或者代码块加锁
(单选题) 36、类 ABC 定义如下：
1 ． public class ABC{
2 ． 　　public double max( double a, double b) { }
3 ．
4 ． }
将以下哪个方法插入行 3 是不合法的。（）
A public float max(floata, float b, float c){ }
B public double max(double c, double d){ }
C public float max(floata, float b){ }
D private int max(int a,int b, int c){ }
正确答案是:B
解析：重载要求方法的参数列表需要不一样（个数，或者参数类型），修改参数名或者修改返回值以及访问权限并没有用
(单选题)37、关于抽象类和接口叙述正确的是？ ( )
A 抽象类和接口都能实例化的
B 抽象类不能实现接口
C 抽象类方法的访问权限默认都是public
D 接口方法的访问权限默认都是public
正确答案是：D
解析：
1.抽象类 不能被实例化 ( 因为不具体，实例化没作用 )， 注意 接口不是类， 不能实例化[ new] ，只能 new 它的 实现类
2.抽象类可以实现接口
3.抽象类是用abstract修饰的
4. 接口 默认访问权限为 public，而且只能使用 public
(单选题) 38、关于异常处理机制的叙述正确的是（）
A catch部分捕捉到异常情况时，才会执行finally部分
B 当try区段的程序发生异常时，才会执行finally部分
C 当try区段不论程序是否发生错误及捕捉到异常情况，都会执行finally部分
D 以上都是
正确答案是：C
解析：
在Java语言的异常处理中，finally块的作用就是为了保证无论出现什么情况，finally块里的代码一定会执行。
由于程序执行return就意味着结束了对当前函数的调用并跳出这个函数体，因此任何语句执行都要放在return前执行（除非碰到exit函数），因此finally块里面的函数也是在return前执行的。
如果try-finally或者catch-finally中都有return语句，那么finally中的return语句会覆盖别处的，最终返回到调用者那里的是finally中的return值。
(单选题) 5、以下代码返回值是什么？

publicboolean returnTest(){
    try{
        return true;
    }catch (Exception e){

    }finally{
        return false;
    }
}

A true
B false
正确答案是:B
解析：
无论有没有抛出异常，finally语句都会执行，先执行try，return true；然后执行finally，return false，最后结果是false。
(不定项选择题) 39、下列描述错误的是?
A 类只能继承一个父类，但是可以实现多个接口
B 抽象类自身可以定义成员而接口不可以
C 抽象类和接口都不能被实例化(忽略匿名内部类)
D 一个类可以有多个基类和多个基接口
正确答案：B
解析：
A、D：Java只允许为类的扩展做单一继承，但是允许使用接口做多重扩展
B：接口允许定义成员，但必须是常量（public final static）
C：抽象类和接口都不能使用new操作
(单选题) 40、以下声明合法的是
A default String s
B public finalstatic native int w( )
C abstract double d
D abstract finaldouble hyperbolicCosine( )
正确答案是：B
解析：
A：变量不能被defalut修饰
B：native修饰方法，native修饰的方法简单来说就是：一个Java方法调用了一个非Java代码的接口。
定义navtive方法时，并不提供实现体，因为其实现体是用非Java语言在外面实现的。native可以和任何修饰符连用，abstract除外。因为native暗示这个方法时有实现体的，而abstract却显式指明了这个方法没有实现体。
C：abstract修饰方法和类
D：final修饰的方法不能被重写。而abstract定义的方法没有实现，必须被子类重写，明显不能一起使用。

(单选题)41、下面这三条语句
System.out.println(“is ”+ 100 + 5)；
System.out.println(100 + 5 +“ is”)；
System.out.println(“is ”+ (100 + 5))；
的输出结果分别是？ ( )
A is 1005, 1005 is, is 1005
B is 105, 105 is, is 105
C is 1005, 1005 is, is 105
D is 1005, 105 is, is 105
正确答案是：D
解析：
1."is"说明后面的内容都会被强制转换为string，所以是最后结果是拼接起来的
2.100+5先得到105，然后与is拼接
3.先算括号内的
(单选题)42、下面程序段执行后b的值是()。
Integer integ =new Integer(9) ；
boolean b = integ instanceof Object;
A 9
B true
C 1
D false
正确答案是：B
解析：instanceof 用来在运行时指出对象是否是特定类的一个实例，instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例 Object是任何类的父类，所以应该返回true。
(单选题)43、不考虑反射，String类型变量所指向内存空间中的内容是不能被改变的 。 （ ）
A 正确
B 错误
正确答案是：B
解析：指向的内容不可改变，但是指向哪个内容是可以变的，为String赋新的值可以理解为其实就是指向新的内容，原内容就舍弃了
(单选题)44、 String str1 = “abc”，“abc”分配在内存哪个区域？
A 堆
B 栈
C 字符串常量区
D 寄存器
正确答案是：C
解析：
栈：存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中
堆：存放用new产生的数据
静态域：存放在对象中用static定义的静态成员
常量池：存放常量
非RAM存储：硬盘等永久存储空间
(不定项选择题)45、在JAVA中，下列哪些是Object类的方法（）
A synchronized()
B wait()
C notify()
D notifyAll()
E sleep()
正确答案是：BCD
解析：
A.Synchronized是一个关键字不是方法
E.sleep()是Thread的方法。
Object中包含以下方法：
clone();
equals();
finalize();
getClass();
notify(),notifyAll();
hashCode();
toString();
wait();
(不定项选择题) 46、java8中，忽略内部接口的情况，不能用来修饰interface里的方法的有（ ）
A private
B public
C protected
D static
正确答案是：ACD
解析：接口只能由public和默认来修饰

(单选题)47、有一个源代码，只包含importjava.util.* ; 这一个import语句，下面叙述正确的是？ ( )
A 只能写在源代码的第一句
B 可以访问java/util目录下及其子目录下的所有类
C 能访问java/util目录下的所有类，不能访问java/util子目录下的所有类
D 编译错误
正确答案是：C
解析
导入java.util.*不能读取其子目录的类，因为如果java.util里面有个a类，java.util.regex里面也有个a类，我们若是要调用a类的方法或属性时，应该使用哪个a类呢。所以也应该选C
(单选题) 48、多个线程可同时操作一个数据，为了保证该数据的准确性，可将操作该数据的部分改为 ()
A 同步
B 异步
C 只读
D 只写
正确答案是:A
解析：
多个线程可同时操作一个数据，为了保证该数据的准确性，可将操作该数据的部分改为同步。
同步方法和同步代码块的区别是什么？
同步方法 ( 粗粒度锁 ):
1. 修饰一般方法 : public synchronized void method (){...}, 获取的是当前调用 对象 this 上的锁
2. 修饰静态方法 : public static synchronized void method (){...}, 获取当前类的 字节码对象上的锁
同步代码块 ( 细粒度锁 ):
synchronized ( obj ) {...}, 同步代码块可以指定获取哪个对象上的锁 , obj 任意
(单选题)49、A派生出子类B，B派生出子类C，并且在java源代码中有如下声明：
A a0=new A();
A a1=newB();
A a2=newC();
以下哪个说法是正确的？
A 第1行，第2行和第3行的声明都是正确的
B 第1,2,3行都能通过编译，但第2,3行运行时出错
C 第1,2行能通过编译，但第3行编译出错
D 只有第1行能通过编译
正确答案是：A
解析：
多态的三种表现形式:继承重写，重载，向上转型。A a=new B()属于向上转型，该语句创建了一个B的对象，并将A的对象变量(引用)指向B的对象，即父类引用指向子类对象，是可以的
(单选题)50、选项中哪一行代码可以替换 //add code here 而不产生编译错误
public abstract class MyClass {
　　public intconstInt = 5;
　　//add codehere
　　public voidmethod() {
　　}
}
A public abstractvoid method(int a);
B consInt=constInt+5;
C public intmethod();
D public abstractvoid anotherMethod(){}
正确答案是：A
解析：
B.类中不能直接进行运算，可以写在代码块和静态代码块中
C.和method()重复了
D.abstract不能有{}
(单选题) 51、在基本JAVA类型中，如果不明确指定，整数型的默认是什么类型？带小数的默认是什么类型？
A int float
B int double
C long float
D long double
正确答案是：B
解析：
Java中，如果对整数不指定类型，默认时int类型，对小数不指定类型，默认是double类型
如果要指定长整型，最好写为long a = 100000000L,如果要指定为单精度最好写为float a= 12.34F
(单选题) 52、Whichlines of the following will produce an error?
1. byte a1 = 2,a2 = 4, a3;
2. short s = 16;
3. a2 = s;
4. a3 = a1 * a2;
A Line 3 and Line4
B Line 1 only
C Line 3 only
D Line 4 only
正确答案是：A
解析：
1、 Java中整数默认 类型为int型，浮点默认为double型；
2、对于byte型运算时，会自动转化为int 型；
3、对于byte\short\char同级别运算时，需要强制转换；
4、高级型向低级需要强制类型转换；
高级向低级必须强制类型转换byte<char<short<int<long<float<double
short,byte,char是同级别的，所有逻辑操作都会自动转换成int型再进行相关运算

(单选题)53、有以下程序片段，下列哪个选项不能插入到行 1 。（）。
1.
2.public class A{
3.//do sth
4. }
A public classMainClass{ }
B package mine;
C classANotherClass{ }
D importjava.util.*;
正确答案是：A
解析：
Java一个源程序只能有一个public类存在，且类名与文件名相同。Java程序是从main方法开始执行的，public为类加载器提供入口，然后找到public类中的main方法开始执行。如果存在多个public类，程序将不知道该从哪里执行。
注意，内部类可以是public的，因为内部类是作为外部类的成员存在的。
(单选题)54、设有定义 int a=3 ，b=4，c=5； 则以下的表达式中 ， 值为 false 的是 （）
A a < b&& b < c
B a <= b
C a < ( b + c )
D ! ( a < b )
正确答案是:D
解析：
a < b && b < c true && true true
a <= b true
a < ( b + c ) true
! ( a < b ) !true false
D项。考查运算符的规则 及优先级。()优先级高于！，所以先算括号，括号的结果为true，取反为false
(单选题)55、Given the following code:

public class Test {
    private static int j = 0;

    private static Boolean methodB(intk) {
        j += k;
        returntrue;
    }

    public static void methodA(inti) {
        booleanb;
        b = i < 10| methodB(4);
        b = i < 10|| methodB(8);

    }

    public static void main(String args[]){
        methodA(0);
        System.out.println(j);
    }
}

What isthe result?
A The programprints”0”
B The programprints”4”
C The programprints”8”
D The programprints”12”
E The code doesnot complete.
正确答案是：B
解析：

考察按位或 ‘|’和逻辑或“||”的区别和静态变量。
|:参与运算 的两个值无论什么情况都要进行运算
||：先判断左边，如果为true则右边不参与运算，如果为false则右边要参与运算。

(单选题) 56、下列命令中，用来运行 Java 程序的是（）
A java
B javadoc
C jar
D javac
正确答案是：A
解析：

A.java用来运行一个.class文件
B.javadoc用来生成api文档
C.jar用来生成jar包
D.javac用来把.java文件编译为.class文件

(不定项选择题)57、 Considerthe following code:
String s=null;
Which code fragments cause an object of type NullPointerException to be thrown?
A if((s!=null)&(s.length()>0))
B if((s!=null)&&(s.length()>0))
C if((s==null)|(s.length()==0))
D if((s==null)||(s.length()==0))
正确答案是：AC
解析：

String为引用类型，如果对象为null,也就是说这个对象都不存在了，再去调用对象的相关方法，肯定会报空指针异常。这里调用了String类的length()方法
&&和||具有短路的效果，在进行&&时，如果&&前的是false，那么&&后的不再执行，直接返回false，同理||也一样。所以BD的s.length()不会被执行，AC会抛出空指针异常.

(不定项选择题) 58、实现或继承了Collection接口的是（）
A Map
B List
C Vector
D Iterator
E Set
正确答案是：BCE
解析：

在java.util包中提供了一些集合类，常用的有List、Set和Map类，其中List类和Set类继承了Collection接口。这些集合类又称为容器，长度是可变的，数组用来存放基本数据类型的数据，集合用来存放类对象的引用。
List接口、Set接口、Map接口以及Collection接口的主要特征如下：
Collection接口是List接口和Set接口的父接口，通常情况下不被直接使用。
List接口继承了Collection接口，List接口允许存放重复的对象，排序方式为按照对象的插入顺序。
Set接口继承了Collection接口，Set接口不允许存放重复的对象，排序方式为按照自身内部的排序规则。
Map接口以键值对（key—value）的形式存放对象，其中键（key）对象不可以重复，值（value）对象可以重复，排序方式为按照自身内部的规则。
C：Vector实现了List接口，即间接实现Collection接口
D：Iterator是Java迭代器最简单的实现，没有实现Collection接口

(单选题)59、设三个整型变量 x = 1 , y = 2 , z = 3，则表达式 y＋＝z－－/＋＋x 的值是( )。
A 3
B 3.5
C 4
D 5
正确答案是：A
解析：

y是2，返回的结果是2+（z--/++x），再来看z--/++x，结果应该是3/2，但是因为x,y,z都是int型的，所以最后的返回值只能是int，这时候z--/++x的值就是1，那么最终的结果就是2+1=3

(单选题)60、编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( )。
A java
B class
C html
D exe
正确答案是: B
解析：

Java源程序的后缀名为“.java”
经过编译之后生成的字节码文件后缀名为“.class”

(单选题)61、下列关于修饰符混用的说法，错误的是( )
A abstract不能与final并列修饰同一个类
B abstract类中不应该有private的成员
C abstract方法必须在abstract类或接口中
D staic方法中能处理非static的属性
正确答案是：B
解析：
B选项我做的时候没看清，还以为写的是不能有，确实不应该有，不管是成员变量，还是非抽象方法都不建议用private修饰，抽象方法是禁止使用private修饰。原因就是我们创建抽象类的目的就是要实现代码复用，方便子类继承，private修饰的是不能继承的，同时抽象类不能实例化对象，所以用private修饰的成员毫无用处。
抽象类的中抽象方法只允许用public和默认修饰（JDK1.8之前默认是用protected修饰，但在JDK1.8之后则是默认为default修饰）
(单选题)62、关于下面的程序Test.java说法正确的是( )。

public class Test {
    static String x="1";
    static int y=1;
    public static void main(String args[]) {
        static int z=2;
        System.out.println(x+y+z);
    }
}

A 3
B 112
C 13
D 程序有编译错误
正确答案是：D
解析：局部变量不能用static修饰
(不定项选择题)63、下面哪几个函数 public void example(){....} 的重载函数？（）
A public void example(int m){...}
B public int example(){..}
C public void example2(){..}
D public int example(int m,float f){...}
正确答案是：AD
解析：
java重载的时候以参数个数和参数类型作为区分，方法名相同，返回类型可以相同也可以不同，但不以返回类型作为区分，所以b也是错的，因为b的参数列表和原来的一样，
(不定项选择题)64、以下为 java 语法保留不能作为类名和方法名使用的是
A default
B int
C implements
D throws
正确答案是：ABCD
解析：
implements是java实现接口的关键字，default是保留字，int是整型数据类型的关键字，throws是抛出异常的关键字，所以正确答案是ABCD

(单选题)65、main 方法是 Java Application 程序执行的入口点，以下描述哪项是合法的（）。
A public static void main（）
B public static void main（ String args[] ）
C public static int main（String [] arg ）
D public void main（String arg[] ）
正确答案是:B
解析：统一格式就是B public static void main（ String args[] ）
(单选题)66、下列关于包（package）的描述，正确的是（）
A 包（package）是Java中描述操作系统对多个源代码文件组织的一种方式。
B import语句将所对应的Java源文件拷贝到此处执行。
C 包（package）是Eclipse组织Java项目特有的一种方式。
D 定义在同一个包（package）内的类可以不经过import而直接相互使用。
正确答案是：D
解析：
1、为了更好地组织类，Java提供了包机制。包是类的容器，用于分隔类名空间。如果没有指定包名，所有的示例都属于一个默认的无名包。Java中的包一般均包含相关的类，java是跨平台的，所以java中的包和操作系统没有任何关系，java的包是用来组织文件的一种虚拟文件系统。A错
2、import语句并没有将对应的java源文件拷贝到此处仅仅是引入，告诉编译器有使用外部文件，编译的时候要去读取这个外部文件。B错
3、Java提供的包机制与IDE没有关系。C错
4、定义在同一个包（package）内的类可以不经过import而直接相互使用。
(单选题)67、在Java中，main()方法的返回值的类型是：
A public
B static
C void
D String
正确答案是：C
解析:
main方法的格式讲解：
public static void main(String[] args) {...}
public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
void:方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。
main:是一个常见的方法入口。我见过的语言都是以main作为入口。
String[] args:这是一个字符串数组。这个东西早期是为了接收键盘录入的数据的。
(单选题)68、以下叙述正确的是
A 实例方法可直接调用超类的实例方法
B 实例方法可直接调用超类的类方法、
C 实例方法可直接调用子类的实例方法
D 实例方法可直接调用本类的实例方法
正确答案是：D
解析:
A.父类叫super class所以也叫超类，实例方法就是构造方法，本选项错在子类不能调用父类的private实例方法。
B.private的类方法子类不能调用
C.父类看不见子类
(单选题) 69、下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？
A private
B 无修饰符
C public
D protected
正确答案是：B
解析：
1、public：任何地方均可访问；
2、private：只限类的内部访问；
3、protected：受保护的，类的内部可访问；同一个包下的不管是否有继承关系均可访问；不同包下只有有继承关系的才可访问；
4、默认（default）：类的内部可访问；同一个包下不管是否有继承关系均可访问；不同包下不管有没有继承关系都不能访问。

 (单选题) 70、与InputStream流相对应的Java系统的“标准输入对象”是（）
A System.in

B System.out
C System.err
D System.exit()
正确答案：A
解析：
A.标准输入 B.标准输出 C.错误输出 D.结束程序
(单选题)71、一个类中，有两个方法名、形参类型、顺序和个数都完全一样，返回值不一样的方法,这种现象叫覆盖。（  ）
A 正确
B 错误
正确答案是：B
解析：
重载（overload）和重写（override）的区别： 重载就是同一个类中，有多个方法名相同，但参数列表不同（包括参数个数和参数类型），与返回值无关，与权限修饰符也无关。调用重载的方法时通过传递给它们不同的参数个数和参数类型来决定具体使用哪个方法，这叫多态。 重写就是子类重写基类的方法，方法名，参数列表和返回值都必须相同，否则就不是重写而是重载。权限修饰符不能小于被重写方法的修饰符。重写方法不能抛出新的异常或者是比被重写方法声明更加宽泛的检查型异常。
(单选题)72、定义类中成员变量时不可能用到的修饰是（）
A final
B vold
C protected
D static
正确答案是：B
解析：
类中的成员变量和成员方法可用的修饰符有：public、protected、private和default。
(单选题) 73、下列关于构造函数的描述中，错误的是（）
A 构造函数可以设置默认的参数
B 构造函数在定义类对象时自动执行
C 构造函数可以是内联函数
D 构造函数不可以重载
正确答案是：B
解析：
构造函数可以重载（不可以重写），默认构造函数为空，可以通过重载构造函数对成员变量赋初始值
(单选题)74、如下代码的 输出结果是什么？

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
解析：
错误在static int i = 0;这句，static不能用于局部变量，局部变量是有相对短的生命周期，而static变量的生命周期和整个程序一样，不方便内存回收。Java中不允许定义静态局部变量。
(不定项选择题) 75、下列哪个选项是合法的标识符？（）
A 123
B _name
C class
D first
正确答案是：BD
解析：
Java标识符由 数字、字母、下划线(_)、美元符号($) 组成， 首位不能是数字 。并且 Java关键字不能作为标识符 

(单选题)76、protected访问权限要小于包访问权限。（ ）
A 正确
B 错误
正确答案是：B
解析：public>protected>(同包)default>private
(单选题) 77、判断对错。List，Set，Map都继承自继承Collection接口。
A 对
B 错
正确答案是：B
解析：List，Set等集合对象都继承自Collection接口
Map是一个顶层结果，不继承自Collection接口
(单选题)、已知 boolean result ，则下面哪个选项是合法的：
A result=1
B result=true;
C if(result!=0) {//so something…}
D if(result) {//do something…}
正确答案是：B
解析：
A. 和C/C++ 不同，取值只有true,false
B.正确
C.需要和布尔值比较，不能和int型比较，C/C++可以。
D.局部变量未初始化错误
(单选题)79、Given:

public class IfTest{
    public static void main(string[]args){
        int x=3;
        int y=1;
        if(x=y)
            System.out.println(“Not equal”);
        else
            System.out.println(“Equal”);
    }
}

What is the result?
A The output is “Equal”
B The output in “Not Equal”
C An error at line 5 causes compilation to fall.
D The program executes but does not print a message.
正确答案是：C
if()语句括号中为比较表达式，返回值要么是true，要么是false，if(x=y)是将y赋值给x，但是数据类型是int类型的，编译不能通过，如果把代码改为这样：
boolean x =false;
boolean y =ture;
if(x=y){...}这样就就不会报错了，编译正常通过。
(单选题)80、（）是方法定义和常量值的集合。
A 接口
B 变量
C 单元
D 成员
正确答案是：A
解析：接口中的所以方法都是抽象的-方法定义
接口中的值都是public static final的-常量值
(不定项选择题) 81、java中HashTable, Vector, TreeSet, LinkedList哪些线程是安全的？
A HashTable
B Vector
C TreeSet
D LinkedList
正确答案是：AB
解析：
LinkedList 和 ArrayList 都是不同步的，线程不安全；
Vector 和 Stack 都是同步的，线程安全；
Set是线程不安全的；
Hashtable的方法是同步的，线程安全；
HashMap的方法不是同步的，线程不安全；

 (单选题)82、一个文件中的字符要写到另一个文件中，首先需要（）。
A 使用标准输出流System.out.println()。
B 建立文件字符输出流。
C 建立文件字符输入流。
D 标准输入流System.in.read()。
正确答案是：B
解析：input 和out 是对计算机而言的，input是往计算机中输入，对计算机而言就是读，反之,out 就是从计算机往外输出就是写
读进来，写出去
(单选题)83、以下哪个方法用于定义线程的执行体？ （）
A start()
B join()
C run()
D synchronized()
正确答案是：C
解析：run()方法是用来定义这个线程在启动的时候需要做什么，但是，直接执行run()方法那就不是线程，必须使用start()启动,那样才是线程。
(单选题)84、下列方法定义中 ， 正确 的是（）
A int x( ){ char ch=’a’; return (int)ch; }
B void x( ){ ...return true; }
C int x( ){ ...return true; }
D int x( int a, b){ return a+b; }
正确答案是：A
解析：
A.Java中涉及到byte、short和char类型都可以强制转化为int，符合返回类型 A正确
B.方法中定义为void 应该没有返回值，但返回值为boolean类型 B错
C. 方法中类型为int，应该返回int类型值，但是 返回值为boolean类型 C错 
D.方法应该定义为int(int a,int b)，所以D错
(单选题)85、在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（）
A this.A(x)
B this(x)
C super(x)
D A(x)
正确答案是：B。
解析：
this的作用其中一个就是在一个构造方法中调用另一个构造方法，格式为this(参数)；
构造方法直接this()，非构造方法则用this.()
super是调用父类的方法；
A(a)这种形式是在new一个类时使用。
(不定项选择题)86、在程序代码中写的注释太多，会使编译后的程序尺寸变大。
A 对
B 错
正确答案是：B
解析：注释是给人看的，不是给机器看的

(单选题) 87、下列哪一种叙述是正确的（）
A abstract修饰符可修饰字段、方法和类
B 抽象方法的body部分必须用一对大括号{ }包住
C 声明抽象方法，大括号可有可无
D 声明抽象方法不可写出大括号
正确答案是D
解析：abstract可以修饰方法和类，不能修饰属性。抽象方法没有方法体，即没有大括号{}
(单选题)88、下列哪种说法是正确的？
A 实例方法可直接调用超类的实例方法
B 实例方法可直接调用超类的类方法
C 实例方法可直接调用本类的类方法
D 实例方法可直接调用其他类的实例方法
正确答案是：C
Java中实例方法可直接调用本类的类方法。
实例方法可以调用超类公有实例方法
实例方法可以直接调用超类的公有类方法
实例方法可以通过类名调用其他类的类方法
(单选题)89、在使用 interface 声明一个接口时，只可以使用（）修饰符修饰该接口
A private
B protected
C private protected
D public
正确答案是：D
解析：接口必须被继承，所以得是public
(单选题)90、如果希望某个变量只可以被类本身访问和调用，则应该使用下列哪一种访问控制修饰？
A public
B private
C private protected
D protected
正确答案是：B
解析：
private修饰的仅自己能访问，protected同包或子类可以访问，public是不同包也可以访问。
(单选题)91、以下程序的运行结果是（）

public class Increment{
    public static void main(Stringargs[]){
        int a;
        a = 6;
        System.out.print(a);
        System.out.print(a++);
        System.out.print(a);
    }
}

A 666
B 667
C 677
D 676
正确答案是：B
解析：
++在前先加后用 ++在后先用后加
a++为后++操作，System.out.print(a++),a先返回后，在进行自增+1操作，故输出为6.第三行的打印输出，在a++操作后a的值变为7
(单选题)92、 关于Float，下列说法错误的是()
A Float是一个类
B Float在java.lang包中
C Float a=1.0是正确的赋值方法
D Float a= new Float(1.0)是正确的赋值方法

正确答案是：C
解析：
1. Float是类，float不是类.
2. 查看JDK源码就可以发现Byte，Character，Short，Integer，Long，Float，Double，Boolean都在java.lang包中.
3. Float正确赋值方式是Float f=1.0f,若不加f会被识别成double型,double无法向float隐式转换.
4. Float a= new Float(1.0)是正确的赋值方法，但是在1.5及以上版本引入自动装箱拆箱后，会提示这是不必要的装箱的警告，通常直接使用Float f=1.0f.

 (单选题)93、类Car里面有个方法run()，如果直接用Car.run()，则方法run前面必须用的关键词是？  ( )
A class
B final
C public
D static
正确答案是:D
解析：使用static修饰的方法,可以直接用类名点方法名的方式直接调用..
(单选题)94、在使用 interface 声明一个接口时，只可以使用（）修饰符修饰该接口
A private
B protected
C private protected
D public
正确答案是：D
解析：接口必须被继承，所以得是public
(单选题)95、java 语言使用的字符码集是
A ASCII
B BCD
C DCB
D Unicode
正确答案是：D
解析：Java语言使用的是Unicode字符集，ASCII是国际上使用最广泛的字符编码
(不定项选择题) 96、下面选项中,哪些是interface中合法方法定义?()
A public void main(String [] args);
B private int getSum();
C boolean setFlag(Boolean [] test);
D public float get(int x);
正确答案是：ACD
解析：java程序的入口必须是static类型的，接口中不允许有static类型的方法。A项没有static修饰符，可以作为普通的方法。而且接口中的方法必须是public的。想想借口就是为了让别人实现的，相当于标准，标准不允许别人使用是不合理的，所以接口中的方法必须是public。C项中，接口中的方法默认是public的。D项属于正常的方法。所以答案是：ACD
(单选题) 97、Java 程序中使用赋值运算符进行对象赋值时，可以得到两个完全相同的对象。
A 正确
B 错误
正确答案是:A
解析：对象赋值时，比如A=B，只是把A对象的地址指向了B对象的地址，所以其实对象只有一个
(不定项选择题) 98、不能用来修饰interface的有（）1/1
A private
B public
C protected
D static
正确答案是：：ACD
解析：
A,C,D都不能用来修饰interface。
就访问来说，可以用public,默认修饰符，而不能用private，因为接口本身就是为了让别的类或接口使用的，用private就没有了意义。
protected也是不可以的，ptotected的访问权限是包内对象以及包外继承该类的包外对象，其实和public意义也就一样了，也就没必要选择protected。
static是用来修饰变量或者方法的，而不修饰类。（在接口中 static只能修饰变量不能修饰方法）
（final同样不能修饰接口）

 (单选题)99、在视图上不能完成的操作是（）?
A 更新视图
B 查询
C 在视图上定义新的表
D 在视图上定义新的视图
正确答案是:C
解析：
视图是基于数据表的一种查询窗口。怎么可能在这种查询窗口中再建数据表呢？
就像你可以在房子上开窗，但你不能在窗子上盖个房子吧？
(单选题)100、按照传统的数据模型分类，数据库系统可以分为三种类型（）。
A 大型、中型和小型
B 西文、中文和兼容
C 层次、网状和关系
D 数据、图形和多媒体
正确答案是：C
(单选题) 101、在SQL语言的SELECT语句中，实现排序操作的是哪个子句（）。
A WHERE
B FROM
C SELECT
D ORDER BY
正确答案是：D
解析：
WHERE：条件判断
 FROM：来自哪一张表
SELECT：查询
(单选题)102、DBMS 提供 DML 实现对数据的操作。可以独立交互 使用的 DML 称为（）。
A 宿主型
B 独立型
C 自含型
D 嵌入型
正确答案是：C
解析：数据操纵子语言通常又分为两类：一类是嵌入主语言，由于这种语言本身不能独立使用，故称为宿主型的语言；另一类是交互式命令语言，由于这种语言本身能独立使用，故又称为自主型或自含型的语言。
(单选题) 103、JDBC的主要功能有？1/1
A 创建与数据库的连接
B 发送SQL语句到数据库中
C 处理数据并查询结果
D 以上都是
正确答案是：D
解析：根据JDBC的定义，JDBC是由一系列连接（Connection）、SQL语句（Statement）和结果集（ResultSet）构成的，其主要作用概括起来有如下3个方面：
    建立与数据库的连接。
    向数据库发起查询请求。
    处理数据库返回结果。
(单选题)104、表toutiao_tb
title   data       auther type
abc     2016.2.23   bob    1
bcv     2016.3.3    http   1
cvt     2016.3.3    http   1
bcvvcm  2016.3.5    js     2
nmhh    2016.2.3    html   2
hhj     2016.3.3    java   3
rrr     2016.3.2    cc     1
查询title中包含cv且type是1的记录
A select * from toutiao_tb where title = 'cv' and type='1'
B select * from toutiao_tb where title like '%cv%' andtype=1
C select * from toutiao_tb where title like '*cv' andtype=1
D select * from toutiao_tb where title ='*cv*' and type='1‘
正确答案是：B
解析：
% 表示任意0个或多个字符
_ 表示任意单个字符
%...%:这是查询包含...的任意字符串
%...:这是查询以...结束的任意字符串
...%:这是查询以...开头的任意字符串

(单选题)105、在 java 中，一个类可同时定义为许多同名的方法，这些方法的形式参数个数，类型或顺序各不相同，传回的值可能个不相同，这种面向对象的特性称为（）
A 隐藏
B 覆盖
C 重载
D 无此特性
正确答案是：C
解析：
java中重载的特点就是同一个类中方法名相同，参数不同，这是java中重载的显著特征。
覆盖和重写是一回事，重写的方法名和参数类型均相同，隐藏是子类中存在与父类同名同参的方法时，父类方法被隐藏
(单选题)106、 下列关于继承的哪项叙述是正确的？
A 在java中允许多继承
B 在java中一个类只能实现一个接口
C 在java中一个类不能同时继承一个类和实现一个接口
D java的单一继承使代码更可靠
正确答案是：D
解析：
A：Java只能单继承。所以A选项错误
B：Java中一个类可以实现多个接口，所以B错误
C：Java中一个类只能实现继承一个父类但是可以同时实现多个接口，所以C错误
D：Java的单一继承使代码更可靠，是正确的。
(单选题) 107、从运行层面上来看，从四个选项选出不同的一个。
A JAVA
B Python
C objectC
D C#
正确答案是：B
解析：python是脚本语言，与其它不同
(不定项选择题) 108、关于 java 的异常处理机制的叙述哪些正确？
A 不论程序是否发生错误及捕捉到异常情况，都会执行finally部分
B 当try区段的程序发生异常时，才会执行catch区段的程序
C catch部分捕捉到异常情况时，才会执行finally部分
D 其它选项都不正确
正确答案是：AB
解析：
A、不论程序是否发生错误及捕捉到异常情况，都会执行finally部分。（正确）
B、当try区段的程序发生异常时，才会执行catch区段的程序。（正确）
C、 catch部分捕捉到异常情况时，才会执行finally部分（错误，不管有没有捕捉到异常，都会执行finally）
D、上面有正确的，D错误。
(不定项选择题) 109、在java语言中，如果你编写一个多线程序，可以使用的方法是（）
A 扩展类Thead
B 实现Runnable接口
C 扩展类 Runnable
D 实现接口Thead
正确答案是：AB
解析：
1.继承Thread类（Override它的run方法）
2.实现Runnable接口（实现run方法）
(不定项选择题) 110、在Jdk1.7中，下述说法中抽象类与接口的区别正确的有哪些？
A 抽象类中可以有普通成员变量，接口中没有普通成员变量。
B 抽象类和接口中都可以包含静态成员常量。
C 一个类可以实现多个接口，但只能继承一个抽象类
D 抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法。
正确答案是：ABCD
解析：
总结一下
1. 一个子类只能继承一个抽象类,但能实现多个接口
2. 抽象类可以有构造方法,接口没有构造方法
3. 抽象类可以有普通成员变量,接口没有普通成员变量
4. 抽象类和接口都可有静态成员变量,抽象类中静态成员变量访问类型任意,接口只能public static final(默认)
5. 抽象类可以没有抽象方法,抽象类可以有普通方法,接口中都是抽象方法
6. 抽象类可以有静态方法,接口不能有静态方法
7. 抽象类中的方法可以是public、protected;接口方法只有public

 (单选题) 111、如果子类要调用父类的构造函数，则通过super（）调用来实现。
A 正确
B 错误
正确答案是：A
解析：子类构造函数一定要调用父类构造函数（第一行），不过父类无参的构造函数可以隐式调用，当父类没有无参构造函数时需要显式调用
(单选题) 112、ArrayList和LinkList的描述，下面说法错误的是？
A LinkedeList和ArrayList都实现了List接口
B ArrayList是可改变大小的数组，而LinkedList是双向链接串列
C LinkedList不支持高效的随机元素访问
D 在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在ArrayList的中间插入或删除一个元素的开销是固定的
正确答案是：D
解析：
这个说法说反了
Arraylist的内存结构是数组，当超出数组大小时创建一个新的数组，吧原数组中元素拷贝过去。其本质是顺序存储的线性表，插入和删除操作会引发后续元素移动，效率低，但是随机访问效率高
LinkedList的内存结构是用双向链表存储的，链式存储结构插入和删除效率高，不需要移动。但是随机访问效率低，需要从头开始向后依次访问
(单选题)113、假设有以下代码 
String s=”hello”;
String t=”hello”;
Char c[] ={‘h’,’e’,’l’,’l’,’o’};
下列选项中返回false的语句是：
A s.equals(t);
B t.equals(c);
C s==t;
D t.equals(new String(“hello”));
正确答案是：B
解析：
==是比较地址值是否相等，.equals()方法是比较值是否相等
s和t两个变量都是指向字符串常量池中的同一个内存区域，所以地址值相等，值当然也相等，AC正确
Char c[]是一个字符数组，和字符串t使用.equals()方法比较，返回false
D选项new了一个新的字符串，它的值和s、t是相同的，但是由于是新new出来的，就会重新开辟一个空间进行存储，所以地址不同，但是值相同
(单选题)114、下列Java代码中的变量a、b、c分别在内存的____存储区存放。
class A {
        private String a = “aa”;
        public boolean methodB() {
           String b = “bb”;
           final String c = “cc”;
        }
}
A 堆区、堆区、堆区
B 堆区、栈区、堆区
C 堆区、栈区、栈区
D 堆区、堆区、栈区
E 静态区、栈区、堆区
F 静态区、栈区、栈区
正确答案是：C
a是类中的成员变量，存放在堆区
b、c都是方法中的局部变量，存放在栈区
(不定项选择题)115、下面有关java的instanceof、?、&、&&说法正确的有？
A instanceof 可用来判断某个实例变量是否属于某种类的类型。
B "?："  三目运算符
C &在逻辑运算中是非短路逻辑与，在位运算中是按位与
D && 逻辑运算：逻辑与
正确答案是：ABCD
解析：
instanceof：用来判断某个实例变量是否属于某种类的类型，但是实例变量可以放置在前面也可以放置在后面
"?：": 三目运算符
&：  逻辑与（不短路）
&&：逻辑运算：（短路）

 (单选题)116、下列选项中，用于在定义子类时声明父类名的关键字是：( )
A interface
B package
C extends
D class
正确答案是：C
解析：
A是接口
B是包
D是类
(单选题) 117、Continue语句跳出整个循环
A 正确
B 错误
正确答案是：B
解析：
continue时，本次循环结束，直接开始下一次循环；循环体还没结束
break时是跳出本循环体，循环体结束！
(单选题)118、java 接口的修饰符可以为（）
A private
B protected
C final
D abstract
正确答案是：D
解析：
接口只能用public和abstract修饰
(单选题)119、下面关于程序编译说法正确的是（）
A java语言是编译型语言，会把java程序编译成二进制机器指令直接运行
B java编译出来的目标文件与具体操作系统有关
C java是解释型语言，在运行时才进行翻译指令
D java编译出来的目标文件，可以运行在任意jvm上
正确答案是：C
解析：
A:字节码文件
B：与操作系统无关
D：jvm可以有不同实现
(不定项选择题) 120、不能用来修饰interface的有（）
A private
B public
C protected
D static
正确答案是：ACD
解析：接口只能用public和abstract修饰
(不定项选择题)121、下面哪几个函数 public void example(){....} 的重载函数？（）
A public void example(int m){...}
B public int example(){..}
C public void example2(){..}
D public int example(int m,float f){...}
正确答案是：AD
解析：
重载的依据是参数列表不同，返回值不能作为重载的依据
重载只要求参数列表不同，返回值无关。

 (单选题) 122、关于下面的程序Test.java说法正确的是(    )。

public class Test {
    static String x="1";
    static int y=1;
    public static void main(String args[]) {
        static int z=2;
        System.out.println(x+y+z);
    }
}

A 3
B 112
C 13
D 程序有编译错误
正确答案是：D
解析：
被static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效，所以static不能修饰局部变量
(单选题)123、在 JAVA 编程中， Java 编译器会将 Java 程序转换为（ ）
A 字节码
B 可执行代码
C 机器代码
D 以上都不对
正确答案是:A
解析：
编译器将.java原代码转换成以.class为后缀名的字节码文件
(单选题)124、下列语句序列执行后，输出结果是（）

public class ex{
    public static void main(String[]args){
        int a=13;
        a=a/5；
        System.out.println(a);
    }
}

A 1
B 2
C 3
D 4
正确答案是：B
解析：因为a为int类型  所以13/5取商为2，然后再赋值给a,所有输出a=2。
(不定项选择题)125、给出下面的代码段:

public class Base{
    int w, x, y ,z;
    public Base(int a,int b){
        x=a; y=b;
    }
    public Base(int a, int b, int c, int d){
    // assignment x=a, y=b
        w=d;z=c;
    }
}

在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的？（） 
A Base(a,b);
B x=a, y=b;
C x=a; y=b;
D this(a,b);
正确答案是：CD
解析：
A错，调用Base这个构造方法应该这样  newBase(a,b)
B错，和C相比应该是分号不是逗号，帅的一塌糊涂
C正常赋值操作
D调用本类的构造方法
(单选题) 126、下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换：
1     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
解析：
操作步骤就是先解码再编码
用new String(src，"GBK")解码得到字符串
用getBytes("UTF-8")得到UTF8编码字节数组
(单选题) 127、语句：char foo='中'，是否正确？（假设源文件以GB2312编码存储，并且以javac – encoding GB2312命令编译）
A 正确
B 错误
正确答案是：A
解析：
在Java中，GB2312编码，中文字符占2个字节，正好Java基本类型中的char 是单一的16位Unicode字符，可以储存任何字符，不管是数字还是英文还是中文汉字，都占两个字节。所以char foo='中'正确。

 (单选题) 128、程序文件名必须与公共外部类的名称完全一致（包括大小写）
A 正确
B 错误
正确答案是：A
解析：统一规范类名必须与文件名一致
(单选题)129、在 main() 方法中给出的字节数组，如果将其显示到控制台上，需要（）。
A 标准输出流System.out.println()。
B 建立字节输出流。
C 建立字节输入流。
D 标准输入流System.in

.read()。
正确答案是：A
解析：输出到控制台，直接
System.out.println()
(单选题)130、装箱、拆箱操作发生在: ()
A 类与对象之间
B 对象与对象之间
C 引用类型与值类型之间
D 引用类型与引用类型之间
正确答案是
正确答案是:C
解析：
通俗的讲，就是基本数据类型和包装类之间的转换。如： int  类型和  Integer  类的转换
基本数据类型转化成包装类是装箱  (如： int  --> Integer)。
包装类转化成基本数据类型就是拆箱  (如：Integer -->  int)。
包装类就是引用类型，基本数据类型就是值类型。所以选C
(单选题)131、下面的输出结果是什么？
public class Demo {
  public static void main(String args[])
  {
    String str=new String("hello");
    if(str=="hello")
    {
      System.out.println("true");
    }      
    else     {
      System.out.println("false");
    }
  }
}
A true
B false
正确答案是：
正确答案是：B
解析：==判断的是对象引用地址是否相同，
 String str=newString("hello");
这句话new了一个新的String对象，所以地址与"hello"字符串常量的地址不同，
注意这两句话，
1.新建的对象保存在堆内存中，引用变量str保存在栈内存中并指向堆内存中的对象。
2.而“hello”这种直接保存在字符串常量池中。
3。两个不是同一个地址啊！返回false
(单选题)132、在基本 JAVA 类型中，如果不明确指定，整数型的默认是 __ 类型，带小数的默认是 __ 类型？ (  )
A int float
B int double
C long float
D long double
正确答案是：B
解析：
整型默认为int，如果需要long，须加l或L。小数默认double，d或D可省略，但如果需要float，须加f或F，例如float = 0.1f

 (单选题)133、当编译并运行下面程序时会发生什么结果（）
public class Bground extends Thread{
    public static void main(String argv[]){
        Bground b = new Bground();
       b.run();
    }
    public void start(){
        for(int i=0;i<10;i++){
            System.out.println("Value of i= "+i);
        }
    }
}
A 编译错误，指明run方法没有定义
B 运行错误，只鞥呢run方法没有定义
C 编译通过并输出0到9
D 编译通过，但无输出
正确答案是:D
解析：主函数中调用的run()方法是继承自Thread类的，并没有实现具体函数内容；而且main函数中并没有调用start()方法，所以整个运行过程中并没有调用start()方法，所以没有任何输出；选D。
(不定项选择题) 134、根据下面的代码，
String s = null;
会抛出NullPointerException异常的有（）。
A if( (s!=null) & (s.length()>0) )
B if( (s!=null) && (s.length()>0) )
C if( (s==null) | (s.length()==0) )
D if( (s==null) || (s.length()==0) )
正确答案是：AC
解析：
 逻辑运算符：&&和|| 是按照“短路”方式求值的。如果第一个操作数已经能够确
定表达式的值，第二个操作数就不必计算了
位移运算符：&和| 运算符应用于布尔值，得到的结果也是布尔值，不按“短路”方式计算。即在得到计算结果之前，一定要计算两个操作数的值。
(单选题)135、对抽象类的描述正确的是()
A 抽象类的方法都是抽象方法
B 一个类可以继承多个抽象类
C 抽象类不能有构造方法
D 抽象类不能被实例化
正确答案是：D
解析：包含抽象方法的类必须定义为抽象类；抽象类不一定包含抽象方法，也可以包含普通方法；抽象类有构造方法，但是不能new一个对象所以抽象类不能被实例化；抽象类只支持单继承。
(单选题)136、下面所示的java代码，运行时，会产生（）类型的异常
int Arry_a[] =new int[10];
System.out.println(Arry_a[10]);
A ArithmeticException
B NullPointException
C IOException
D ArrayIndexOutOfBoundsException
正确答案是:D
解析：
定义的数组长度为10，下标即为0-9
所以Array_a[10]会提示数组下标越界

 (单选题)137、下列修饰符中与访问控制权限无关的是？（ ）
A private
B public
C protected
D final
正确答案是：D
解析：
private：修饰私有变量
public：修饰公有变量
protected：修饰受保护变量
final：保护私有变量不受改变
(单选题)138、现有一变量声明为 boolean aa; 下面赋值语句中正确的是 （ ）
A aa=false;
B aa=False;
C aa="true";
D aa=0;
正确答案是：A
解析：
B aa=False;  False应该改成false;
C aa="true";加双引号相当于是字符串 所以是错的
boolean类型允许的取值为true或false
(单选题) 139、只有实现了()接口的类，其对象才能序列化。1/1
A Serializable
B Cloneable
C Comparable
D Writeable
正确答案是：A
解析：
强制记忆题：实现Serializable 接口才可以对该类实现序列化和反序列化
(单选题)140、映射 (Map) 的key和value都不可重复。（    ）
A 正确
B 错误
正确答案是：B
解析：
Map的key不可以重复，value是可以重复的
(单选题)141、在 java 中 , 一个类（）
A 可以继承多个类
B 可以实现多个接口
C 在一个程序中只能有一个子类
D 只能实现一个接口
正确答案是：B
解析：
在Java中，一个类可以实现多个接口，只能继承一个类，可以有多个子类，
(单选题) 142、关于Float，下列说法错误的是()
A Float是一个类
B Float在java.lang包中
C Float a=1.0是正确的赋值方法
D Float a= new Float(1.0)是正确的赋值方法
正确答案是：C
解析：
1. Float是类，float不是类.
2. 查看JDK源码就可以发现Byte，Character，Short，Integer，Long，Float，Double，Boolean都在java.lang包中.
3. Float正确复制方式是Float f=1.0f,若不加f会被识别成double型,double无法向float隐式转换.
4. Float a= new Float(1.0)是正确的赋值方法，但是在1.5及以上版本引入自动装箱拆箱后，会提示这是不必要的装箱的警告，通常直接使用Float f=1.0f.

(不定项选择题) 143、下面为true的是
Integer i = 42;
Long l = 42l;
Double d = 42.0;
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
解析：
A B C 3 个选项很明显，不同类型引用的 == 比较，会出现编译错误，不能比较。
D E F 选项 调用 equals 方法，因为此方法先是比较类型，而 i ， d ， l 是不同的类型，所以返回假。
选项 G ，会自动装箱，将 42L 装箱成 Long 类型，所以调用 equals 方法时，类型相同，且值也相同，因此返回真。

 (单选题)144、执行下列代码的输出结果是( )

public class Demo{
　  public static void main(String args[]){
　　　   int num = 10;
　　　   System.out.println(test(num));
    }
    public static int test(intb){
　　　   try{
　　　　  　　b += 10;
　　　　     returnb;
　　　　　}catch(RuntimeException e){

　　　　　}catch(Exception e2){

　　　　　}finally{
　　　　　　　b += 10;
　　　　  　　returnb;
　　　　　}
　   }
}

A 10
B 20
C 30
D 40
正确答案是：C
解析：
如果finally语句块中没有return语句，则返回20，因为finally在return语句之前执行，不能通过在return中重新赋值改变返回值。
如果finally中有有return语句，则会覆盖try语句块中的返回值，故为30.
(单选题)145、关于final说法正确的是？  ( )
A final类的方法肯定不能被同一个包的类访问
B final类的方法能否被同一个包的类访问不是由final决定
C final方法等同于private方法
D final对象本身的引用和值都不能改变
正确答案是:B
解析：
A:能不能被同一个包的类访问与final无关，由public protectdefault private 决定
D:引用不能改变、值可以改变
(单选题)146、局部变量能否和成员变量重名？
A 可以，局部变量可以与成员变量重名，这时可用“this”来指向成员变量
B 可以，这时可用“local”关键字来指向局部变量
C 不能，局部变量不能与成员变量重名
D 不能，在一个类中不能有重名变量，不管是成员变量还是函数中的局部变量
正确答案是:A
解析：
java采用局部优先的思想。局部变量可以和成员变量相同，使用标识符调用时，优先使用局部变量。在实例方法中出现变量名相同时，可以使用this关键字来调用。
(单选题)147、java 中哪个关键字可以对对象加互斥锁？
A transient
B synchronized
C serialize
D static
正确答案是：B
解析：
1.static 修饰符，用来创建类方法和类变量。
2.final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
3.abstract 修饰符，用来创建抽象类和抽象方法。
4.synchronized 用于多线程的同步。用来给对象和方法或者代码块加锁，各线程互斥访问。
5.volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
6.transient：序列化的对象包含被 transient 修饰的实例变量时，java虚拟机(JVM)跳过该特定的变量。
(单选题)148、有时为了避免某些未识别的异常抛给更高的上层应用，在某些接口实现中我们通常需要捕获编译运行期所有的异常， catch 下述哪个类的实例才能达到目的：（）
A Error
B Exception
C RuntimeException
D Throwable
正确答案是:B
解析：
因为error是系统出错，catch是无法处理的，难以修复的，RuntimeException不需要程序员进行捕获处理，error和exception都是throwable的子类，我们只需要对exception的实例进行捕获即可

 (单选题) 149、以下有关构造方法的说法，正确的是：（）
A 一个类的构造方法可以有多个
B 构造方法在类定义时被调用
C 构造方法只能由对象中的其他方法调用
D 构造方法可以和类同名，也可以和类名不同
正确答案是：A
解析：
A正确，构造方法可以重载，所以可以有多个；
B错误，构造方法在类实例化对象时调用来初始化对象，自动调用；
C错误，解析见B
D错误，构造方法必须和类相同。
(单选题)150、如果int x=20, y=5，则语句System.out.println(x+y+""+(x+y)+y);  的输出结果是（）
A 2530
B 55
C 2052055
D 25255
正确答案是：D
解析：主要考的运算符优先级与结合性。
括号里先算，然后再从左到右开始算  刚开始第1个＋就是运算符所以20+5=25 ，当遇到“”时转换为字符串。这时+就是连接符了而不是运算符再与后面＋就都字符串了 25 25  5  所以最后答案是25255
(单选题)151、下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的（ ）
A public
B private
C static
D final
正确答案是：C
解析：static表示静态变量，归类所有，该类的所有对象公用
(单选题)152、以下关于集合类 ArrayList 、 LinkedList 、 HashMap 描述错误的是：
A HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值
B ArrayList和LinkedList均实现了List接口
C 添加和删除元素时，ArrayList的表现更佳
D ArrayList的访问速度比LinkedList快
正确答案是：C
解析：
HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值。
ArrayList和LinkedList均实现了List接口。
ArrayList的访问速度比LinkedList快。添加和删除元素时，LinkedList的表现更佳。
(不定项选择题) 153、下面属于java引用类型的有？
A String
B byte
C char
D Array
正确答案：AD
解析：
java语言是强类型语言，支持的类型分为两类：基本类型和引用类型。
基本类型包括boolean类型和数值类型，数值类型有整数类型和浮点类型。整数类型包括：byte、short、int、long和；浮点类型包括：float和double
引用类型包括类、接口和数组类型以及特殊的null类型。

 (单选题)154、若所用变量都已正确定义，以下选项中，非法的表达式是（）
A a!= 4||b==1
B ’a’ % 3
C ’a’ = 1/3
D ’A’ + 32
正确答案是：C
解析：'a'是个常数，压根就不能赋值  =就是错的
(单选题)155、覆盖（重写）与重载的关系是（）。
A 覆盖（重写）只有出现在父类与子类之间，而重载可以出现在同一个类中
B 覆盖（重写）方法可以有不同的方法名，而重载方法必须是相同的方法名
C final修饰的方法可以被覆盖（重写），但不能被重载
D 覆盖（重写）与重载是同一回事
正确答案是：A

面试很喜欢问的：
     首先，重载和重写都是多态的一种体现方式。重载是编译期间的活动，重写是运行期间的活动。
     其次，重载是在一个类中定义相同的名字的方法，方法的参数列表或者类型要互相不同，但是返回值类型不作为是否重载的标准，可以修改可见性；
     重写是不同的，要求子类重写基类的方法时要与父类方法具有相同的参数类型和返回值，可见性需要大于等于基类的方法
final修饰的方法可以被重载，但不可以被重写
(单选题)156、编译 java 源程序文件将产生响应的字节码文件，这些字节码文件的扩展名为
A .class
B .java
C .html
D .exe
正确答案是：A
写好的java文件后缀名为xxx.java
编译java文件：输入javac xxx.java回车,编译会生成.class文件
运行java文件：java xxx.class；
(单选题)157、以下程序的运行结果是（）

public class Increment{
    public static void main(String args[]){
        int a;
        a = 6;
        System.out.print(a);
        System.out.print(a++);
        System.out.print(a);
    }
}

A 666
B 667
C 677
D 676
正确答案是：B
解析：++在前先加后用 ++在后先用后加
(单选题)158、执行如下代码段后，变量s1引用的字符串值是(    )。
Strings1 = "ABCD";
String s2 = "1234";
System.out.println(s1 + s2);
A ABCD
B 1234
C ABCD1234
D 1234ABCD
正确答案是：A
解析：
这道题考的不是知识掌握能力，而是审题！！！！
不要直接看代码，把题目先读一遍
(单选题)159、关于如下程序的描述哪个是正确的？（）

public class Person{
    static intarr[] = new int[5];
    public static void main(String a[]){
        System.out.println(arr[0]);
    }
}

A 编译将产生错误
B 编译时正确，但运行时将产生错误
C 正确，输出0
D 正确，输出 null
正确答案是：C
解析：
被static修饰的会默认初始化，int就是0咯。

 (单选题) 160、Java中只有整型才能使用的运算符为？
A *
B /
C %
D +
正确答案是：C
解析：ABD选项的操作符都可用于int 但是结果不一定是int
所以只有%取余操作，只适用于整型
(不定项选择题)161、Consider the following code:
Integer s=new Integer(9);
Integer t=new Integer(9);
Long u=new Long(9);
Which testwould return true?
A (s==u)
B (s==t)
C (s.equals(t))
D (s.equals(9))
E (s.equals(newInteger(9))
正确答案是：CDE
解析：
(s==u) ，因为， s 是 Integer 类型， u 是 Long 类型，两个不同类型的引用不能进行 == 比较。  
(s==t) ， s 是指向一个 9 的引用，而 t 也是一个指向 9 的引用，虽然都是指向 9 ，但却是指向不同的 9 ，即是两个不同的引用。因此 == 比较返回的是假。 
(s.equals(t)) ， Integer 的 equals 方法如下：    
 public boolean equals(Object obj) {  
      if (obj instanceof Integer) {           
 return value ==((Integer)obj).intValue();       
  }       
  return false ;
 } 
是 Integer 的实例且 value 值也相等的情况下返回真，其他返回假。在这里， s 和 t 都是 Integer 类型且值都为 9 ，因此结果为真。  
(s.equals(9)) , 在进行 equals 比较之前，会对 9 调用 Integer.valueOf方法，进行自动装箱 , 由于 IntegerCache 中已经存在 9 ，所以，直接返回其引用，引用相同， equals 就自然相同了。所以结果为真。 
(s.equals( new Integer(9)) ，直接创建了一个新的 Integer 实例，但且值也为 9 ，所以，满足条件，返回真。
(单选题)162、下面的程序段创建了BufferedReader类的对象in，以便读取本机c盘my文件夹下的文件1.txt。File构造函数中正确的路径和文件名的表示是(    )。
Filef = new File( 填代码处);
file =new FileReader(f);
in=new BufferedReader(file);
A "./1.txt"
B "../my/1.txt"
C "c:\\my\\1.txt"
D "c:\ my\1.txt"
正确答案是：C
解析："c:\\my\\1.txt"  "c:/my/1.txt" 都是正确的答案
(单选题) 163、已知表达式int m[]={0，1，2，3，4，5，6}；下面哪个表达式的值与数组下标量最大值相等？
A m. length()
B m. length-1
C m. length()+1
D m. length+1
正确答案是：B
解析：
1.数组的下标是从0 开始的，所以数组的下标最大为5。
2.m.length的值为6。
所以，答案为：5=m.length()-1
(单选题)164、下面的代码运行的结果是：

class B extends Object{
    static{
        System.out.println("Load B");
    }
    public B(){
        System.out.println("Create B");
    }
}
class A extends B{
    static{
        System.out.println("Load A");
    }
    public A(){
        System.out.println("Create A");
    }
}
public class Testclass{
    public static void main(String[] args){
        new A();
    }
}

A Load B ->Create B->Load A -> Create A
B Load B -> Load A ->Create B ->Create A
C Load B -> Create B-> Create A -> Load A
D Create B ->Create A ->Load B ->Load A
正确答案是：B
解析：初始化块在构造器执行之前执行，类初始化阶段先执行最顶层父类的静态初始化块，依次向下执行，最后执行当前类的静态初始化块；创建对象时，先调用顶层父类的构造方法，依次向下执行，最后调用本类的构造方法。

 (单选题)165、对于以下代码段，4个输出语句中输出true的个数是(    )。
class A{}
class B extends A{}
class C extends A{}
class D extends B{}
A obj = new D();
System.out.println(obj instanceof B);
System.out.println(obj instanceof C);
System.out.println(obj instanceof D);
System.out.println(obj instanceof A);
A 1
B 2
C 3
D 4
正确答案是：C
解析：
C直接继承自A，obj的实际类型为D，和C没有关系。所以obj instanceof C输出false。

(单选题)166、 代码System. out. println(10 % 3 * 2)；将打印出？
A 1
B 2
C 4
D 6
正确答案是：B
解析：%和*优先级相同，顺序执行，10%3=1  1*2=2
(不定项选择题) 167、对于构造方法，下列叙述正确的是（ ）。
A 构造方法的优先级一般比代码块低。
B 构造方法的返回类型只能是void型。
C 构造方法的主要作用是完成对类的对象的初始化工作。
D 一般在创建新对象时，系统会自动调用构造方法。
正确答案是：ACD
解析：
A：静态成员变量或静态代码块>main方法>非静态成员变量或非静态代码块>构造方法
B：think in java中提到构造器本身并没有任何返回值。所以不能用void
C: 构造方法的主要作用是完成对类的对象的初始化工作。
D: 一般在创建(new)新对象时，系统会自动调用构造方法。
(单选题)168、 java中用()字指明继承关系.用()关键字指明对接口的实现。
A implementsextends
B extendsimplements
C extend implement
D implement extend
正确答案是：B
解析：extends表继承父类
 implements表是实现接口
(单选题)169、如果希望某个变量只可以被类本身访问和调用，则应该使用下列哪一种访问控制修饰？
A public
B private
C private protected
D protected
正确答案是：B
解析：private修饰的仅自己能访问，protected同包或子类可以访问，public是不同包也可以访问。

 (单选题)170、对于如下代码段可以放入到横线位置，使程序正确编译运行，而且不产生错误的选项是（ ）

class A{
    public A foo(){return this;}
}
class B extends A{
    public A foo(){
        return this;
    }
}
class C extends B{
    _______
}

A public void foo(){}
B public int foo(){return 1;}
C public A foo(B b){return b;}
D public A foo(){return A;}
正确答案是:C
复习一下子类方法重写父类方法遵循“两同两小一大”的规则
子类覆盖父类要遵循“两同两小一大”
“两同”即方法名相同，形参列表相同
“两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等。
  （注：看到有网友有这样的疑问，父类方法返回值是double，子类修改成int为什么不行呢？
这是因为返回值类型更大或者更小，是对于同一类型而言的。也就是说，返回值的类型需要有继承关系才去考虑大小这个概念。类型不同，肯定不是方法重写）
“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。
注意：覆盖方法和被覆盖方法要么都是类方法，要么都是实例方法，不能一个是类方法一个是实例方法，否则编译出错。
所以，根据这个原理，再来分析上面这道题。
A.public void foo(){}
返回值类型与父类不一致，所以不可能是方法的重写。又因为方法名相同，那么只能是方法重载，而方法重载有需要满足三个条件：形参个数、顺序、类型必须有一者不同，A选项都不满足，错
B.public int foo(){return 1;}
与A选项一样
C.public A foo(B b){return b;}
返回值类型与父类相同，但由于参数列表不同，所以是对父类方法的重载
D.public A foo(){return A;}   语法错误
(单选题)171、要表示10个学生的成绩，下列声明并初始化数组正确的是（）
A int[] score=new int[ ]
B int score[10]
C int score[]=new int[9]
D int score[]=new int[10]
正确答案是：D
解析：
以下两种写法都可以：
int score[] = new int[10];
int[] score = new int[10];
注意：数组的下标是从0开始 所以第一个学生的成绩则是这样表示score[0]
(单选题)172、关于下面代码 int[] x=new int[25]; 描述正确的是（）
A x[25]存放了数据“\0”。
B x[24] 存放了数据“\0”。
C 若访问x[25]，程序将抛出异常。
D x[1]访问此数组的第一个元素。
正确答案是：C
解析：
A:不存在x[25] 索引从0开始到length-1
B:x[24] 存的是默认值0(java中没有'\0'这一说)
C:超出内存正确
D:第二元素
(单选题) 173、已知 声明并初始化二维数组 int a[ ][ ]={{1,2},{3,4},{5,6}} ，则 a[1][1] 的值为（）
A 1
B 2
C 4
D 5
正确答案是：C
解析：
二维数组:      0 1
                0  {1,2}
                1  {3,4}
                2  {5,6}  所以a[1][1]=4;
(单选题)174、面向对象程序设计语言的三个基本特征是？(    )
A 封装、接口和多态
B 继承、接口和动态
C 跨平台、接口和动态
D 封装、继承和多态
正确答案是：D
解析：
封装：访问权限继承：子父类之间属性方法的访问多态：同一个方法名的不同功能