刷牛客之路-Java基础题(二)

1.在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序特性称为

A.隐藏
B.重写
C.重载
D.Java不支持此特性

• 方法重写：
  在子类中，出现和父类中一模一样的方法声明的现象。

• 方法重载：
  同一个类中，出现的方法名相同，参数列表不同的现象。

• 方法重载能改变返回值类型，因为它和返回值类型无关。

• Override：方法重写

• Overload：方法重载

• 所以C

2.覆盖与重载的关系是

A.覆盖只有发生在父类与子类之间，而重载可以发生在同一个类中
B.覆盖方法和重载方法都可以不同名，也可以同名
C.final修饰的方法可以被覆盖，但不能被重载
D.覆盖与重载是同一回事

• 在同名的前提下才有重载和覆写，不重名就是两个方法了
• final修饰的方法可以被继承，不可以覆写。重载与final没有关系
• 重写与重载两个不同
• A

3.有以下程序片段且Interesting不是内部类，下列哪个选项不能插入到行1

1.
2.public class Interesting{
3. // 省略代码
4.}

A.import java.awt.*;
B.package mypackage;
C.class OtherClass{ }
D.public class MyClass{ }

• 在同一个java原文件中，可以有多个class类，但是只有有一个公共的 public class
• D

4.在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的

A.管道
B.消息队列
C.高速缓存数据库
D.套接字

• 要求是对于不同的服务器之间的通信，是要要求全双工形式的，而管道只能是半双工，虽然可以双向，但是同一时间只能有一个方向传输，全双工和半双工的区别可以如下图示理解
  
• A

5.以下哪项陈述是正确的？

A.垃圾回收线程的优先级很高，以保证不再 使用的内存将被及时回收
B.垃圾收集允许程序开发者明确指定释放 哪一个对象
C.垃圾回收机制保证了JAVA程序不会出现 内存溢出
D.进入”Dead”状态的线程将被垃圾回收器回收
E.以上都不对

• 垃圾回收在jvm中优先级相当相当低
• 垃圾收集器（GC）程序开发者只能推荐JVM进行回收，但何时回收，回收哪些，程序员不能控制
• 垃圾回收机制只是回收不再使用的JVM内存，如果程序有严重BUG，照样内存溢出
• 进入DEAD的线程，它还可以恢复，GC不会回收
• 所以E

6.given the following code,what will be the output

class Value{
    public int i=15;
}
public class Test{
    public static void main(String argv[]){
        Test t=new Test( );
        t.first( );
    }
 
public void first( ){
    int i=5;
    Value v=new Value( );
    v.i=25;
    second(v,i);
    System.out.println(v.i);
}
 
public void second(Value v,int i){
    i = 0;
    v.i = 20;
    Value val = new Value( );
    v = val;
    System.out.println(v.i+" "+i);
   }
}

A.15 0 20
B.15 0 15
C.20 0 20
D.0 15 20

7.假定str0,…,str4后序代码都是只读引用。Java 7中，以上述代码为基础，在发生过一次FullGC后，上述代码在Heap空间（不包括PermGen）保留的字符数为

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

A.5
B.10
C.15
D.20

• 方法区：主要存储结构信息的地方，比如方法体，同时也是存储静态变量，以及静态代码块的区域，构造函数，常量池，接口初始化等等
  方法区物理上还是在堆中，是在堆的持久代里面。堆有年轻代 (由一个Eden区和俩个survivor区组成)，老年代，持久代。新创建的对象都在年轻代的Eden区，经过一次JC收集后，存活下来的会被复制到survivor区(一个满了，就全部移动到另外一个大的中，但要保证其中一个survivor为空)，经过多次JC后，还存活的对象就被移到老年代了。
• 持久代就是经常说的方法区里面存放类信息，常量池，方法等
• static String str1=“0123456789”;是放在方法区里。也就是持久代，题目中已经说了，不包含持久代，所以剩余空间为5+5+5=15
• C

8.Java 多线程有几种实现方法？

A.继承Thread类
B.实现Runnable接口
C.实现Thread接口
D.以上都不正确

• AB外还有一种方法实现Callable接口

9.下列说法正确的是（）

A.我们直接调用Thread对象的run方法会报异常，所以我们应该使用start方法来开启一个线程
B.一个进程是一个独立的运行环境，可以被看做一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源
C.synchronized可以解决可见性问题，volatile可以解决原子性问题
D.ThreadLocal用于创建线程的本地变量，该变量是线程之间不共享的

• volatile与synchronized的区别
  • volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的,需要从主存中读取,synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住.
  • volatile仅能使用在变量级别,synchronized则可以使用在变量,方法.
  • volatile仅能实现变量的修改可见性,但不具备原子特性,而synchronized则可以保证变量的修改可见性和原子性.
  • volatile不会造成线程的阻塞,而synchronized可能会造成线程的阻塞.
  • volatile标记的变量不会被编译器优化,而synchronized标记的变量可以被编译器优化.
• BD

10.下列哪个选项是错误的

A.一个文件中只能有一个public class。
B.一个文件中可以有多个类。
C.一个类中可以有两个main方法。
D.若类中只含一个main方法，则必须是public的

• 外部类为public，还可以有public的内部类 A错
• BC对
• AD错

11.final方法等同于private方法

A.对
B.错

• private方法只可以在类的内部使用，在类外根本访问不到
• 而final方法可以在类外访问，但是不可以重写该方法，就是说可以使用该方法的功能但是不可以改变其功能，这就是private方法和final方法的最大区别
• B

12.以下对继承的描述错误的是

A.Java中的继承允许一个子类继承多个父类
B.父类更具有通用性，子类更具体
C.Java中的继承存在着传递性
D.当实例化子类时会递归调用父类中的构造方法

• java类只能单继承 但可以实现多个接口
• 接口可以继承多个
• A错

13.在java中，无论在何处调用，使用静态属性必须以类名做前缀

A.正确
B.错误

• 如果是本类使用，可以直接就用静态变量名
• 如果是其他类使用，可以使用类名来调用，也可以创建一个实例对象来调用
• 如果静态变量所在的类是静态类，那么不管在本类里或者在其他外部类，都可以直接使用静态变量名
• B

14.Java是从（）语言改进重新设计

A.Ada
B.C++
C.Pascal
D.BASIC

• B

15.关于以下application,说法正确是什么？

public class Test {
    static int x=10;
    static {x+=5;}
    public static void main(String[] args) //4
        {
        System.out.println("x="+x);
    }
    static{x/=3;};
}//9

A.4行与9行不能通过编译，因为缺少方法名和返回类型
B.编译通过，执行结果是：x=5
C.编译通过，执行结果是：x=3
D.9行不能通过编译，因为只能有一个静态初始化器

• 首先初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化
• 然后初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化
• 其次初始化父类的普通成员变量和代码块，再执行父类的构造方法
• 最后初始化子类的普通成员变量和代码块，再执行子类的构造方法
• 对象初始化时，先给对象的属性赋默认值，然后调用构造方法
• B

16.指出以下程序运行的结果是

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

17.在Java中，关于HashMap类的描述，以下错误的是

A.HashMap使用键/值得形式保存数据
B.HashMap 能够保证其中元素的顺序
C.HashMap允许将null用作键
D.HashMap允许将null用作值

• ACD对
• HashMap不能保证元素的顺序
• HashMap线程不安全，Hashtable线程安全

18.以下代码执行后输出结果为

public class Test
{
    public static Test t1 = new Test();
    {
         System.out.println("blockA");
    }
    static
    {
        System.out.println("blockB");
    }
    public static void main(String[] args)
    {
        Test t2 = new Test();
    }
 }

A.blockAblockBblockA
B.blockAblockAblockB
C.blockBblockBblockA
D.blockBblockAblockB

• 静态块：用static申明，JVM加载类时执行，仅执行一次
• 构造块：类中直接用{}定义，每一次创建对象时执行
• 执行顺序优先级：静态块>main()>构造块>构造方法
• 静态块按照申明顺序执行，先执行Test t1 = new Test()
• 调用了构造块所有先输出blockA，然后执行静态块，输出blockB，最后执行main
• 方法中的Test t2 = new Test();输出blockA

19.下面为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

20.关于 访问权限说法正确 的是

A.类定义前面可以修饰public,protected和private
B.内部类前面可以修饰public,protected和private
C.局部内部类前面可以修饰public,protected和private
D.以上说法都不正确

这题不严谨…具体看我的内部类的博客

21.以下二维数组声明合法的是

A.char[2][3] ch = new char[][]
B.char[2][] ch = new char[][3]
C.char[][] ch = new char[2][3]
D.char[][] ch = new [2]char[3]

int [][] table = new int[2][2];
int [][] table = new int[2][];
int [] table [] = new int[2][2];
int [] table [] = new int[2][];
//都是正确的 new int[2][];

• C

22.关于抽象类叙述正确的是？

A.抽象类不能实现接口
B.抽象类必须有“abstract class”修饰
C.抽象类必须包含抽象方法
D.抽象类也有类的特性，可以被实例化

• 抽象类是可以实现接口的，而且抽象类也可以继承自抽象类
• 抽象类指有abstract修饰的class，其可以包含抽象方法，也可以不包含
• 抽象类和接口都是不能被实例化的，只有具体的类才可以被实例化
• B

23.若所用变量都已正确定义，以下选项中，非法的表达式是

A.a!= 4||b==1
B.’a’ % 3
C.’a’ = 1/3
D.’A’ + 32

• 'a’是个常数，不能赋值 所以C

24.下列哪些语句关于内存回收的说明是正确的?

A.程序员必须创建一个线程来释放内存
B.内存回收程序负责释放无用内存
C.内存回收程序允许程序员直接释放内存
D.内存回收程序可以在指定的时间释放内存对象

• JVM一旦启动，就会创建一个守护线程来监测是否需要有对象内存被释放
• 内存回收程序无法直接释放
• 不可以指定时间，System.gc()，只是提醒JVM可以进行一次Full GC，但是什么时候真正执行，还是不知道的
• B对

25.指出下列程序运行的结果

public class Example{
    String str=new String("tarena");
    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.tarena and abc
B.tarena and gbc
C.test ok and abc
D.test ok and gbc

• java中只有值传递 所以B

26.下面代码的运行结果是

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

A.代码编程成功，并输出”s=”
B.代码编译成功，并输出”s=null”
C.由于String s没有初始化，代码不能编译通过。
D.代码编译成功，但捕获到NullPointException异常

• 局部变量没有默认值 s没有初始化 所以C

27.阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有

package NowCoder;
class Test {
    public static void hello() {
        System.out.println("hello");
    }
}
public class MyApplication {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Test test=null;
        test.hello();
    }
}

A.能编译通过，并正确运行
B.因为使用了未初始化的变量，所以不能编译通过
C.以错误的方式访问了静态方法
D.能编译通过，但因变量为null，不能正常运行

• 因为Test类的hello方法是静态的，所以是属于类的，当实例化该类的时候，静态会被优先加载而且只加载一次，所以不受实例化new Test();影响，只要是使用到了Test类，都会加载静态hello方法
• 所以A

28.对于JVM内存配置参数

-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3

其最小内存值和Survivor区总大小分别是（）
A.5120m，1024m
B.5120m，2048m
C.10240m，1024m
D.10240m，2048m

• -Xmx：最大堆大小
• -Xms：初始堆大小
• -Xmn:年轻代大小
• -XXSurvivorRatio：年轻代中Eden区与Survivor区的大小比值
• 年轻代5120m， Eden：Survivor=3，Survivor区大小=1024m（Survivor区有两个，即将年轻代分为5份，每个Survivor区占一份），总大小为2048m。
• -Xms初始堆大小即最小内存值为10240m
• 所以D

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

A.子类能继承父类的所有成员
B.子类继承父类的非私有方法和状态
C.子类只能继承父类的public方法和状态
D.子类只能继承父类的方法

• 子类从其父类继承所有成员（字段，方法和嵌套类）。 构造函数不是成员，所以它们不被子类继承，但是可以从子类调用超类的构造函数
• A

30.给定以下JAVA代码，这段代码运行后输出的结果是

public class Test
{  
    public static int aMethod(int i)throws Exception
    {
        try{
            return i/10;
        }
        catch (Exception ex)
        {
            throw new Exception("exception in a aMethod");
        }finally{
      System.out.printf("finally");
        }
} 
    public static void main(String[] args){
        try
        {
            aMethod(0);
        }
        catch (Exception ex)
        {
            System.out.printf("exception in main");
        }
        System.out.printf("finished");
    }
}

A.exception in main finished
B.finally finished
C.exception in main finally
D.finally exception in main finally

• 进入main方法->try->aMethod(0)->return 0/10;这里注意并没有出现异常所以执行finally打印finally，返回的时候也并没有异常，所以不会打印exception in main然后按照顺序执行然后打印finished
• 所以B

31.设有下面一段代码

class  Student  extends  Person {
long    id;     // 身份证号
int  score;  // 入学总分
String  name;   // 姓名
int  getScore(){
return  score;
}
}

问：类 Person 和类 Student 的关系是（ ）
A.包含关系
B.继承关系
C.关联关系
D.无关系，上述类定义有语法错误

• B

32.关于以下程序代码的说明正确的是

public class HasStatic {// 1
    private static int x = 100;// 2
    public static void main(String args[]) {// 3
        HasStatic hsl = new HasStatic();// 4
        hsl.x++;// 5
        HasStatic hs2 = new HasStatic();// 6
        hs2.x++;// 7
        hsl = new HasStatic();// 8
        hsl.x++;// 9
        HasStatic.x--;// 10
        System.out.println(" x=" + x);// 11
    }
}

A.程序通过编译，输出结果为:x=102
B.程序通过编译，输出结果为:x=103
C.10行不能通过编译.因为x星私有静态变量
D.5行不能通过编译.因为引用了私有静态变量

• 同一个类内，private变量可以访问，所以CD错。由于x是static的，存贮在类内，而不是对象内，所以++、–操作的是同一个变量
• 所以A

33.下列关于计算机系统和Java编程语言的说法，正确的是

A.计算机是由硬件、操作系统和软件组成，操作系统是缺一不可的组成部分。
B.Java语言编写的程序源代码可以不需要编译直接在硬件上运行。
C.在程序中书写注释不会影响程序的执行，可以在必要的地方多写一些注释。
D.Java的集成开发环境（IDE），如Eclipse，是开发Java语言必需的软件工具。

• 计算机系统由硬件系统和软件系统组成
• C

34.如果一个接口Glass有个方法setColor()，有个类BlueGlass实现接口Glass，则在类BlueGlass中正确的是？

A.protected void setColor() { …}
B.void setColor() { …}
C.public void setColor() { …}
D.以上语句都可以用在类BlueGlass中

• JAVA 子类重写继承的方法时,不可以降低方法的访问权限 所以C

35.在Java图形用户界面编程中，如果需要显示信息，一般是使用__________类的对象来实现

A.JLabel
B.JButton
C.JTextArea
D.JtextField

• 从上到下分别是标签 按钮 文本(多行文本) 文本(单行文本)
• 所以A

36.下列哪项不属于jdk1.6垃圾收集器

A.Serial收集器
B.parNew收集器
C.CMS收集器
D.G1收集器

• D

37.下面有关struts1和struts2的区别，描述错误的是？

A.Struts1要求Action类继承一个抽象基类。Struts 2 Action类可以实现一个Action接口
B.Struts1 Action对象为每一个请求产生一个实例。Struts2 Action是单例模式并且必须是线程安全的
C.Struts1 Action 依赖于Servlet API，Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试
D.Struts1 整合了JSTL，Struts2可以使用JSTL，但是也支持OGNL

• servlet是单例的 但是Struts2是多例的 所以B

38.下面哪一项不属于优化Hibernate所鼓励的？

A.使用单向一对多关联，不使用双向一对多
B.不用一对一，用多对一取代
C.配置对象缓存，不使用集合缓存
D.继承类使用显式多态

• Hibernate鼓励使用双向一对多关联，不使用单向一对多关联。单向一对多关联映射是在one端维护关系的，必须先保存many端后才可以保存one端，所以在保存many端时该端不知道one端是否存在相应的数据，所以只能将维护的关系字段设置为null，如果为非空则无法保存。因为是one端维护关系，所以在保存one端时，会发出多余的update语句维护many端的外键关系
• A

39.面向对象的程序设计语言具有（）等共同特性

A.封装性
B.多态性
C.简单性
D.复杂性
E.继承性

• ADE

40.下面关于Applet的说法是正确的是

A.Applet可以在带有Java解释器的浏览器中运行
B.Applet类必须继承java.applet.Applet
C.Applet可以访问本地文件
D.Applet是Object类的子类

• ABCD 过时的知识 了

41.有这么一段程序

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

• equals没重写时候和==一样，比较的是对象的地址
• 而Test没重写 而String是重写了的
• 所以C

42.下列外部类定义中，不正确的是

A.class x { … }
B.class x extends y { … }
C.static class x implements y1,y2 { … }
D.public class x extends Applet { … }

• 内部类可以是静态static的，也可用public，default，protected和private修饰
• 外部类的修饰符只能是public，abstract，final
• 所以C

43.下列哪种异常是检查型异常，需要在编写程序时声明

A.NullPointerException
B.ClassCastException
C.FileNotFoundException
D.IndexOutOfBoundsException

• 粉红色的是受检查的异常(checked exceptions),其必须被 try{}catch语句块所捕获,或者在方法签名里通过throws子句声明.受检查的异常必须在编译时被捕捉处理,命名为 Checked Exception 是因为Java编译器要进行检查,Java虚拟机也要进行检查,以确保这个规则得到遵守.
• 绿色的异常是运行时异常(runtime exceptions),需要程序员自己分析代码决定是否捕获和处理,比如 空指针,被0除
• 而声明为Error的，则属于严重错误，如系统崩溃、虚拟机错误、动态链接失败等，这些错误无法恢复或者不可能捕捉，将导致应用程序中断，Error不需要捕捉。
• 所以C

44.下列代码的输出结果是_____

boolean b=true?false:true==true?false:true;
System.out.println(b);

A.true
B.false
C.null
D.空字符串

• B

45.以下哪项不属于java类加载过程

A.生成java.lang.Class对象
B.int类型对象成员变量赋予默认值
C.执行static块代码
D.类方法解析

• 类的加载包括：加载，验证，准备，解析，初始化
• 生成java.lang.Class对象是在加载时进行的。生成Class对象作为方法区这个类的各种数据的访问入口
• 既然是对象成员，那么肯定在实例化对象后才有。在类加载的时候会赋予初值的是类变量，而非对象成员
• C这个会调用。可以用反射试验
• 类方法解析发生在解析过程
• B

46.It is an important feature of the Java language that it always provides a default constructor to a class.

A.对
B.错

• 总是为一个类提供了一个默认的构造函数是Java语言的一个重要特性
• B(只有在不显示声明构造方法时，系统才提供默认无参构造方法)

47.Java数据库连接库JDBC用到哪种设计模式?

A.生成器
B.桥接模式
C.抽象工厂
D.单例模式

• 桥接模式
  • 定义 ：将抽象部分与它的实现部分分离，使它们都可以独立地变化
  • 意图 ：将抽象与实现解耦
• JDBC连接 数据库 的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不动，原因就是JDBC提供了统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了

48.下面代码将输出什么内容

public class SystemUtil{
    public static boolean isAdmin(String userId){
        return userId.toLowerCase()=="admin";
    }
    public static void main(String[] args){
        System.out.println(isAdmin("Admin"));
    }
}

A.true
B.false
C.1
D.编译错误

• 在源码中 toLowerCase 是重新 new String()
  
• 而==对于引用类型来说 比较的是地址
• B

49.在程序代码中写的注释太多，会使编译后的程序尺寸变大

A.对
B.错

• 注释是给人看的，不是给机器看的 B

50.下面几个关于Java里queue的说法哪些是正确的（）？

A.LinkedBlockingQueue是一个可选有界队列，不允许null值
B.PriorityQueue，LinkedBlockingQueue都是线程不安全的
C.PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）
D.PriorityQueue，ConcurrentLinkedQueue都遵循FIFO原则

• LinkedBlockingQueue是一个基于节点链接的可选是否有界的阻塞队列，不允许null值。
• LinkedBlockingQueue是一个线程安全的阻塞队列，实现了先进先出等特性
• PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）
• PriorityQueue是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。ConcurrentLinkedQueue是一个基于链接节点的无界线程安全队列，该队列的元素遵循FIFO原则
• AC

51.面向对象程序设计语言的三个基本特征是封装、继承、多态

A.正确
B.错误

• A

52.下列程序段执行后t3的结果是（）

int t1=2, t2=3, t3;
t3=t1

A.2
B.4
C.5
D.6

• 三目运算符 A

53.以下程序运行的结果为（）

public class Example extends Thread{
     @Override
     public void run(){
        try{
             Thread.sleep(1000);
             }catch (InterruptedException e){
             e.printStackTrace();
             }
             System.out.print("run");
     }
     public static void main(String[] args){
             Example example=new Example();
             example.run();
             System.out.print("main");
     }
}

A.run main
B.main run
C.main
D.run
E.不能确定

• 这个类虽然继承了Thread类，但是并没有真正创建一个线程。
• 创建一个线程需要覆盖Thread类的run方法，然后调用Thread类的start()方法启动
• 这里直接调用run()方法并没有创建线程，跟普通方法调用一样，是顺序执行的
• 所以A

54.What is the result?

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

A.ABDCBDCB
B.ABCDABCD
C.Compilation fails.
D.An exception is thrown at runtime.

for(条件1;条件2;条件3) {
    //语句
}
执行顺序是条件1->条件2->语句->条件3->条件2->语句->条件3->条件2........
如果条件2为true，则一直执行。如果条件2位false，则for循环结束

• A

55.如果要建立一个java.scut.computer的包，叙述正确的是？

A.只需在代码中加入“package java.scut.computer;”一个语句，并且必须放在代码的第一行
B.只需在代码中加入“package java.scut;”一个语句
C.必须在代码中加入“package java.scut;”和“package java.scut.computer;”两个语句
D.在代码中，不一定是第一句，只要是类定义前，加入package语句即可

• A

56.下面有关java实例变量,局部变量,类变量和final变量的说法，错误的是

A.实例变量指的是类中定义的变量，即成员变量，如果没有初始化，会有默认值。
B.局部变量指的是在方法中定义的变量，如果没有初始化，会有默认值
C.类变量指的是用static修饰的属性
D.final变量指的是用final 修饰的变量

• 局部变量必须有初始值

57.URL u =new URL(“http://www.123.com”);。如果www.123.com不存在，则返回______。

A.http://www.123.com
B.””
C.null
D.抛出异常

• 不管网址是否存在，最后都会返回该网址的一个连接，打印出来就是该网址
• 所以A

58.final、finally和finalize的区别中，下述说法正确的有

A.final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
B.finally是异常处理语句结构的一部分，表示总是执行。
C.finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源的回收，例如关闭文件等。
D.引用变量被final修饰之后，不能再指向其他对象，它指向的对象的内容也是不可变的。

• AB
• 使用 final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的
• finalize方法，这个选项错就错在，这个方法一个对象只能执行一次，只能在第一次进入被回收的队列，而且对象所属于的类重写了finalize方法才会被执行。第二次进入回收队列的时候，不会再执行其finalize方法，而是直接被二次标记，在下一次GC的时候被GC

59.以下哪些类是线程安全的（）

A.Vector
B.HashMap
C.ArrayList
D.StringBuffer
E.Properties

• ADE
• Vector相当于一个线程安全的List
• HashMap是非线程安全的，其对应的线程安全类是HashTable
• Arraylist是非线程安全的，其对应的线程安全类是Vector
• StringBuffer是线程安全的，相当于一个线程安全的StringBuilder
• Properties实现了Map接口，是线程安全的

60.下列说法错误的有（ ）

A.Java面向对象语言容许单独的过程与函数存在
B.Java面向对象语言容许单独的方法存在
C.Java语言中的非静态方法属于类中的成员（member）
D.Java语言中的方法必定隶属于某一类（对象），调用方法与C语言的过程或C++语言的函数相同

• ABCD

61.下列说法正确的有（ ）

A.class中的constructor不可省略
B.constructor必须与class同名，但方法不能与class同名
C.constructor可在一个对象被new时执行
D.一个class只能定义一个constructor

• C

62.执行如下代码后输出结果为（ ）

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

A.return value of getValue(): 1
B.return value of getValue(): 4
C.return value of getValue(): 5
D.其他几项都不对

• C

63.关于Float，下列说法错误的是()

A.Float是一个类
B.Float在java.lang包中
C.Float a=1.0是正确的赋值方法
D.Float a= new Float(1.0)是正确的赋值方法

• Float f=1.0f 才是对的 所以C错
• Float a= new Float(1.0)是正确的赋值方法，但是在1.5及以上版本引入自动装箱拆箱后，会提示这是不必要的装箱的警告，通常直接使用Float f=1.0f.

64.下面不属于Object类中方法的是:

A.hashCode()
B.finally()
C.wait()
D.toString()

• B(finalize才是)

65.下列循环语句序列执行完成后，i的值是

int i;
for(i=2;i<=10;i++){
System.out.println(i);
}

A.2
B.10
C.11
D.不确定

• C

66.下面代码运行结果是

public class Test{ 
    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 argv[]){ 
         Test test =new Test(); 
         System.out.println("和是："+test.add(9, 34)); 
     }
}

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

public abstract class Test {
    public static void main(String[] args) {
        System.out.println(beforeFinally());
    }
     
    public static int beforeFinally(){
        int a = 0;
        try{
            a = 1;
            return a;
        }finally{
            a = 2;
        }
    }
}

/*
1
*/

• 当程序执行到try{}语句中的return方法时，它会干这么一件事，将要返回的结果存储到一个临时栈中，然后程序不会立即返回，而是去执行finally{}中的程序， 在执行a = 2时，程序仅仅是覆盖了a的值，但不会去更新临时栈中的那个要返回的值 。执行完之后，就会通知主程序“finally的程序执行完毕，可以请求返回了”，这时，就会将临时栈中的值取出来返回。这下应该清楚了，要返回的值是保存至临时栈中的

public abstract class Test {
    public static void main(String[] args) {
        System.out.println(beforeFinally());
    }
     
    public static int beforeFinally(){
        int a = 0;
        try{
            a = 1;
            return a;
        }finally{
            a = 2;
            return a;
        }
    }
}
/*
2
*/

• 在这里，finally{}里也有一个return，那么在执行这个return时，就会更新临时栈中的值。同样，在执行完finally之后，就会通知主程序请求返回了，即将临时栈中的值取出来返回。故返回值是2
• 所以C

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

public class Demo { class Super{  
		int flag=1;
         Super(){
             test();
         }  void test(){
            System.out.println("Super.test() flag="+flag);
         }
    } class Sub extends Super{
        Sub(int i){  flag=i;
            System.out.println("Sub.Sub()flag="+flag);
        }  void test(){
            System.out.println("Sub.test()flag="+flag);
        }
    }  public static void main(String[] args) {  new Demo().new Sub(5);
     }
}

A.Sub.test() flag=1
Sub.Sub() flag=5
B.Sub.Sub() flag=5
Sub.test() flag=5
C.Sub.test() flag=0
Sub.Sub() flag=5
D.Super.test() flag=1
Sub.Sub() flag=5

• A

68.关于继承的说法正确的是

A.子类将继承父类所有的数据域和方法。
B.子类将继承父类的其可见的数据域和方法。
C.子类只继承父类public方法和数据域
D.子类只继承父类的方法，而不继承数据域

• A
• 父类的静态方法可以继承，但是不能重写。父类的私有方法可以继承，只是不能调用

69.servlet周期包含哪些：

A.初始化
B.销毁
C.请求处理
D.开始

• ABC

init()  --> 初始化
service()  -->  处理请求
destory () --> 销毁（停止）

70.下面代码在main()方法中第八行后可以正常使用的是（ ）

public class Test
{
    private int a=10;
    int b=20;
    static int c=1;
    public static void main(String arg[])
    {
        Test t = new Test();
    }
 }

A.t.a
B.this.c
C.Test.b
D.Test.c

• 静态变量没得this说法,所以B排除
• AD