Java选择题（七）

1.在JAVA中， 下列标识符合法的是（）

正确答案: C 你的答案: C (正确)
A.3kyou
B.@163
C.name
D.while

解释：
JAVA中,标识符, 指用于给变量.类.方法名 等命名的名称. 1,标识以数字,字符,下划线,以及美元$符组成.（不能包括@、%、空格等）,不能以数字开头. 2,不能与JAVA关键字重复 3,严格区分的大小写,（Flag和flag是两个变量） abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for goto if implements import instanceof int interface long native new package private protected public return strictfp short static super switch synchronized this throw throws transient try void volatile while 等

2.如果类的方法没有返回值，该方法的返回值类型应当是abstract。（）

正确答案: B 你的答案: B (正确)
A.正确
B.错误

解释：
没有返回值就是不返回任何东西
abstract肯定是错的了
void返回值为空
所以说的是构造函数吧

3.设有定义 int a=3 ，b=4，c=5； 则以下的表达式中 ， 值为 false 的是 （）

正确答案: D 你的答案: D (正确)
A.a < b && b < c
B.a <= b
C.a < ( b + c )
D.! ( a < b )

解释：
a < b && b < c true && true true
a <= b true
a < ( b + c ) true
! ( a < b ) !true false

4.编译 Java 源程序文件产生的字节码文件的扩展名为（）

正确答案: B 你的答案: B (正确)
A.java
B.class
C.html
D.exe

解释：
java源文件的后缀名是.java。源文件通过jvm虚拟机编译后会生成二进制字节码文件，后缀是.class

5.Which of the following statements are valid array declaration?
(A) int number();
(B) float average[];
© double[] marks;
(D) counter int[];

正确答案: A 你的答案: C (错误)
A.(B) & ©
B.(A)
C.(A) & ©
D.(D)

解释：
nvalid 无效的 valid 有效的
可能大家错误都犯在这里

6.以下定义一维数组的语句中，正确的是：（）

正确答案: D 你的答案: D (正确)
A.int a [10]
B.int a []=new [10]
C.int a[]
int a []=new int [10]
D.int a []={1,2,3,4,5}

解释：
（1）静态初始化（声明并初始化，此时不能指定容量）：
1）int[] arr = new int[]{1, 2, 3}
或
2）int[] arr = {1, 2, 3}
（2）动态初始化（先声明再初始化，此时必须指定容量）：
int[] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

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

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

解释：
定义在类中的变量是类的成员变量，可以不进行初始化，Java会自动进行初始化，如果是引用类型默认初始化为null,如果是基本类型例如int则会默认初始化为0
局部变量是定义在方法中的变量，必须要进行初始化，否则不同通过编译
被static关键字修饰的变量是静态的，静态变量随着类的加载而加载，所以也被称为类变量
被final修饰发变量是常量

8.下面关于垃圾收集的说法正确的是

正确答案: D 你的答案: D (正确)
一旦一个对象成为垃圾，就立刻被收集掉。
对象空间被收集掉之后，会执行该对象的finalize方法
finalize方法和C++的析构函数是完全一回事情
一个对象成为垃圾是因为不再有引用指着它，但是线程并非如此

解释：
1、在java中，对象的内存在哪个时刻回收，取决于垃圾回收器何时运行。
2、一旦垃圾回收器准备好释放对象占用的存储空间，将首先调用其finalize()方法， 并且在下一次垃圾回收动作发生时，才会真正的回收对象占用的内存（《java 编程思想》）
3、在C++中，对象的内存在哪个时刻被回收，是可以确定的，在C++中，析构函数和资源的释放息息相关，能不能正确处理析构函数，关乎能否正确回收对象内存资源。
在java中，对象的内存在哪个时刻回收，取决于垃圾回收器何时运行，在java中，所有的对象，包括对象中包含的其他对象，它们所占的内存的回收都依靠垃圾回收器，因此不需要一个函数如C++析构函数那样来做必要的垃圾回收工作。当然存在本地方法时需要finalize()方法来清理本地对象。在《java编程思想》中提及，finalize()方法的一个作用是用来回收“本地方法”中的本地对象

9.下面关于Java package的描述，哪个是正确的:（）
I. 包不提供将所有类名分区为更易管理的块的机制.
II. 包提供可见性控制机制.
III. 包的一个重要属性是包内定义的所有类都可以通过该包外的代码访问.
IV. 声明为包的一部分的类的.class文件可以存储在多个目录中.

正确答案: B 你的答案: D (错误)
A.只有I
B.只有II
C.只有III
D.只有IV

解释：
为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
包的作用
1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

10.下列关于修饰符混用的说法，错误的是( )

正确答案: D 你的答案: C (错误)
A.abstract不能与final并列修饰同一个类
B.abstract类中不应该有private的成员
C.abstract方法必须在abstract类或接口中
D.static方法中能直接调用类里的非static的属性

解释：
1、abstract不能与final并列修饰同一个类 对的。
2、abstract类中不应该有private的成员 对的 ：abstract类中可以有private 但是不应该有。
3、abstract方法必须在abstract类或接口中 对的 ： 若类中方法有abstract修饰的，该类必须abstract修改。接口方法默认public abstract。
4、static方法中能处理非static的属性 错误 ：在JVM中static方法在静态区，静态区无法调用非静态区属性。

11.当点击鼠标或者拖动鼠标时，触发的事件是下列的哪一个？（）

正确答案: D 你的答案: D (正确)
A.KeyEvent
B.AxtionEvent
C.ItemEvent
D.MouseEvent

解释：
触发ActionEvent这个事件的动作有：
1.点击按钮。
2.双击列表中选项。
3.选择菜单项。
4.在文本框中输入回车

12.下面程序的运行结果是

String str1 = "hello";
String str2 = "he" + new String("llo");
System.err.println(str1 == str2);

正确答案: B 你的答案: B (正确)
A.true
B.false
C.exception
D.无输出

解释：
String str1 = “hello”;这里的str1指的是方法区的字符串常量池中的“hello”，编译时期就知道的； String str2 = “he” + new String(“llo”);这里的str2必须在运行时才知道str2是什么，所以它是指向的是堆里定义的字符串“hello”，所以这两个引用是不一样的。
如果用str1.equal(str2)，那么返回的是True；因为两个字符串的内容一样。

13.以下哪个接口的定义是正确的？（ ）

正确答案: D 你的答案: B (错误)
A.interface B
{ void print() { } ;}
B.interface B
{ static void print() ;}
C.abstract interface B extends A1, A2 //A1、A2为已定义的接口
{ abstract void print(){ };}
D.interface B
{ void print();}

解释：
A，接口中方法的默认修饰符时public abstract，抽象方法可是没有方法体的，没有大括号{}
B，JDK8中，接口中的方法可以被default和static修饰，但是！！！被修饰的方法必须有方法体。
C，注意一下，接口是可以多继承的。整个没毛病，和A选项一样，抽象方法不能有方法体

14.ArrayList和LinkList的描述，下面说法错误的是？

正确答案: D 你的答案: B (错误)
A.LinkedeList和ArrayList都实现了List接口
B.ArrayList是可改变大小的数组，而LinkedList是双向链接串列
C.LinkedList不支持高效的随机元素访问
D.在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在ArrayList的中间插入或删除一个元素的开销是固定的

解释：
Arraylist的内存结构是数组，当超出数组大小时创建一个新的数组，吧原数组中元素拷贝过去。其本质是顺序存储的线性表，插入和删除操作会引发后续元素移动，效率低，但是随机访问效率高
LinkedList的内存结构是用双向链表存储的，链式存储结构插入和删除效率高，不需要移动。但是随机访问效率低，需要从头开始向后依次访问

15.在Web应用程序的文件与目录结构中，web.xml是放置在( )中。

正确答案: A 你的答案: A (正确)
A.WEB-INF目录
B.conf目录
C.lib目录
classes目录

解释：
（1）/WEB-INF/web.xml 是部署描述文件
（2）/WEB-INF/classes 用来放置应用程序用到的自定义类(.class)，必须包括包(package)结构。
（3）/WEB-INF/lib 用来放置应用程序用到的JAR文件。

16.Java中基本的编程单元为：

正确答案: A 你的答案: A (正确)
A.类
B.函数
C.变量
D.数据

解释：
java的基本编程单元是类，基本存储单元是变量。

17.在 applet 的方法中 , 可关闭小应用程序并释放其占用资源的是（ ）

正确答案: D 你的答案: B (错误)
A.stop()
B.paint()
C.init()
D.destroy()

解释：
Applet 类是浏览器类库中最为重要的类，同时也是所有 JAVA 小应用程序的基本类。 一个 Applet 应用程序从开始运行到结束时所经历的过程被称为 Applet 的生命周期。 Applet 的生命周期涉及 init() 、 start() 、 stop() 和 destroy() 四种方法，这 4 种方法都是 Applet 类的成员，可以继承这些方法，也可以重写这些方法，覆盖原来定义的这些方法。除此之外，为了在 Applet 程序中实现输出功能，每个 Applet 程序中还需要重载 paint() 方法：
1、 public void init()
init()方法是 Applet 运行的起点。当启动 Applet 程序时，系统首先调用此方法，以执行初始化任务。
2、 public void start()
start()方法是表明 Applet 程序开始执行的方法。当含有此 Applet 程序的 Web 页被再次访问时调用此方法。因此，如果每次访问 Web 页都需要执行一些操作的话，就需要在 Applet 程序中重载该方法。在 Applet 程序中，系统总是先调用 init() 方法，后调用 start() 方法。
3、 public void stop()
stop()方法使 Applet 停止执行，当含有该 Applet 的 Web 页被其他页代替时也要调用该方法。
4、 public void destroy()
destroy()方法收回 Applet 程序的所有资源，即释放已分配给它的所有资源。在 Applet 程序中，系统总是先调用 stop() 方法，后调用 destroy() 方法。
5、 paint(Graphics g)
paint(Graphics g)方法可以使 Applet 程序在屏幕上显示某些信息，如文字、色彩、背景或图像等。参数 g 是 Graphics 类的一个对象实例，实际上可以把 g 理解为一个画笔。对象 g 中包含了许多绘制方法，如 drawstring() 方法就是输出字符串。

18.下面有个hibernate延迟加载，说法错误的是？

正确答案: C 你的答案: A (错误)
A.Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）
B.Hibernate3 提供了属性的延迟加载功能
C.get支持延迟加载，load不支持延迟加
D.hibernate使用Java反射机制，而不是字节码增强程序来实现透明性

解释：
Hibernate 中 get()和load() 的区别：
1.get()采用立即加载方式,而load()采用 延迟加载 ; get()方法执行的时候,会立即向数据库发出查询语句, 而load()方法返回的是一个***(此***中只有一个id属性),只有等真正使用该对象属性的时候,才会发出 sql语句 2.如果数据库中没有对应的记录,get()方法返回的是null.而load()方法出现异常ObjectNotFoundException

19.以下哪个事件会导致线程销毁？（）

正确答案: D 你的答案: C (错误)
A.调用方法sleep()
B.调用方法wait()
C.start()方法的执行结束
D.run()方法的执行结束

解释：
A. 调用sleep()方***让线程进入睡眠状态—睡眠指定的时间后再次执行；
B. 调用wait()方***让线程进入等待状态 ----等待别的线程执行notify()或notifyAll()唤醒后继续执行；
C.调用start()方***让线程进入就绪状态—得到CPU时间就执行线程；
D.run()方法是线程的具体逻辑方法，执行完，线程就结束。

以下代码段执行后的输出结果为

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

正确答案: D 你的答案: D (正确)A
A.-1
B.2
C.1
D.-2

解释：
Y(被除数) % X(除数) 当除数与被除数的符号相同时，取余和取模的结果是完全相同的； 当除数与被除数的符号不相同时，结果不同。 　　具体说，取余结果的符号与被除数相同；取模结果的符号与除数相同。 通常取模运算也叫取余运算，他们都遵循处罚法则，返回结果都是余数； 1.取余 　　 rem(3,2)=1 　　 rem(-3,-2)=-1 　　 rem(3,-2)=1 　　 rem(-3,2)=-1 　　 2.取模 　　 mod(3,2)=1 　　 mod(-3,-2)=-1 　　 mod(3,-2)=-1 　　 mod(-3,2)=1

21.以下代码结果是什么？
下面展示一些 内联代码片。

public class foo {
public static void main(String sgf[]) {

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;
}
}

正确答案: C 你的答案: C (正确)
代码可以编译运行，输出“AB.AB”。
代码可以编译运行，输出“A.A”。
代码可以编译运行，输出“AB.B”。
代码可以编译运行，输出“A.B”。

解释：
引用a指向对象A
引用b指向对象B
引用x指向对象A
引用y指向对象B
在operate方法中，引用x指向的对象A被连接了B，对象A也就被改变为AB
然后又把引用y指向了x所指向的对象地址，也就是此时引用a,x,y指向同一个对象AB
而引用b没有发生任何变化，依旧指向对象B。

22.下面程序的输出结果是什么。

public class A2{ 
public static void main(String[] args){
    int[] a={2,4,6,8,3,6,9,12};
    doSomething(a,0,a.length-1);
    for(int i=0;i<=a.length-1;i++)
    System.out.print(a[i]+" ");
} 
private static void doSomething(int[] a,int start,int end){
    if(start<end){
        int p=core(a,start,end);
        doSomething(a,start,p-1);
        doSomething(a,p+1,end);
    }
}
private static int core(int[] a,int start,int end)
{
    int x=a[end];
    int i=start;
    for(int j=start;j<=end-1;j++){
        if(a[j]>=x){
            swap(a,i,j);
            i++;//交换了几次 
        }
    }//把最大的放到最后
    swap(a,i,end);//把最大的放到i的位置 
    return i;
} 
  
private static void swap(int[] a,int i,int j) 
{
    int tmp=a[i];
    a[i]=a[j];
    a[j]=tmp;
}
} 
;

正确答案: C 你的答案: C (正确)
A.找到最大值
B.找到最小值
C.从大到小的排序
D.从小到大的排序

解释：
这道题目的核心思想是：根据交换的次数，决定存储的位置，交换0次，存在第一位，代表最大，交换1次，存在第二位，代表次大，以此类推…结果可以拿一个有序的递增序列进行验证，这样比较直观，而且简单粗暴

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

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

解释；深入理解Java虚拟机 书籍中p66，真正宣布一个对象死亡，至少需要经历2次标记过程。当第一次标记时会同时进行一次筛选(判断此对象是否有必要执行finalize方法)。如果对象没有覆盖该方法，就面临死亡，所以说这个方法是对象逃脱死亡命运的最后一次机会。 大家顶我上去，让更多的人看到。看前面没人讲的很详细，如果想深究，去看书。

24.检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。

package algorithms.com.guan.javajicu; 
public class Inc { 
    public static void main(String[] args) { 
       Inc inc = new Inc(); 
       int i = 0; 
       inc.fermin(i); 
       i= i ++; 
       System.out.println(i);
    
    } 
    void fermin(int i){ 
       i++; 
    } 
}

正确答案: A 你的答案: A (正确)
A.0
B.1
C.2
D.3

解释：
i++ 先赋值在计算结果；
++i 先计算结果再赋值。
int i = 0;
i = i ++; // 左边这个i其实是障眼法，就是一个中间变量，可以和下行的i合并；
System.out.println(i); 这里等价于:
int i = 0;
System.out.println(i++); 这下再看，先赋值(先将i传给println函数打印出来,在计算表达式结果)
所以打印出来的是0，实际上整个表达式的结果已经是1了，只是没有打印出整个表达式的结果。
所以我们知道如下结论：
1、无论怎么变，i++和++i的整个表达式的结果都是1.
2、有时我们打印的是表达式的结果(System.out.println(++i)),
有时我们打印的只是一个中间变量(System.out.println(i++))。

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

正确答案: A 你的答案: A (正确)
A.子类能继承父类的所有成员
B.子类继承父类的非私有方法和状态
C.子类只能继承父类的public方法和状态
D.子类只能继承父类的方法

解释：
在一个子类被创建的时候，首先会在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类的对象。所以所谓的继承使子类拥有父类所有的属性和方法其实可以这样理解，子类对象确实拥有父类对象中所有的属性和方法，但是父类对象中的私有属性和方法，子类是无法访问到的，只是拥有，但不能使用。就像有些东西你可能拥有，但是你并不能使用。所以子类对象是绝对大于父类对象的，所谓的子类对象只能继承父类非私有的属性及方法的说法是错误的。可以继承，只是无法访问到而已。

26.下列代码输出结果为（ ）

class Animal{
    public void move(){
        System.out.println("动物可以移动");
    }
}
class Dog extends Animal{
    public void move(){
        System.out.println("狗可以跑和走");
    }
    public void bark(){
        System.out.println("狗可以吠叫");
    }
}
public class TestDog{
    public static void main(String args[]){
        Animal a = new Animal();
        Animal b = new Dog(); 
        a.move();
        b.move();
        b.bark();
    }
}

正确答案: D 你的答案: C (错误)
A.动物可以移动
狗可以跑和走
狗可以吠叫
B.动物可以移动
动物可以移动
狗可以吠叫
C.运行错误
D.编译错误

解释：
编译错误：The method bark() is undefined for the type Animal。Animal中没有定义bark()方法。
Dog继承自Animal。
当用Dog对象初始化Animal类对象时，完成了对Animal对象中方法与变量的覆盖与隐藏，也就是b.move()调用的是Dog中move()方法。而Animal中本身并没有bark()方法，不存在被覆盖的情况，亦无法访问，也就是b.bark()会报错。

27.面向对象的三个基本元素是什么？

正确答案: A B D 你的答案: A B D (正确)
A.封装
B.继承
C.重载
D.多态

解释：
三个基本元素：封装，继承，多态。
五个基本原则：单一职责原则，开放封闭原则，里氏替换原则，依赖倒置原则，接口隔离原则

28.以下哪几种是java的基本数据类型。

正确答案: B C 你的答案: A B C D (错误)
A.String
B.int
C.boolean
D.Double

解释：
以下哪几种是java的基本数据类型。
正确答案: B C 你的答案: A B C D (错误)
String
int
boolean
Double

29.下面的Java赋值语句哪些是有错误的 （）

正确答案: B F 你的答案: B (错误)
A.int i =1000;
B.float f = 45.0;
C.char s = ‘\u0639’
D.Object o = ‘f’;
E.String s = “hello,world\0”;
F.Double d = 100;

解释：
选项F是自动装箱， 装箱过程中调用的是Double类的valueOf( double d )方法， 而这里是100为int型， 所以编译会“cannot convert from int to Double”。

30.下面哪项技术可以用在WEB开发中实现会话跟踪实现？

正确答案: A B C D 你的答案: C D (错误)
A.session
B.Cookie
C.地址重写
D.隐藏域

解释：
HTTP是“无状态”协议：客户程序每次读取 Web 页面，都打开到 Web 服务器的单独的连接，并且，服务器也不自动维护客户的上下文信息。即使那些支持持续性 HTTP 连接的服务器，尽管多个客户请求连续发生且间隔很短时它们会保持 socket 打开，但是，它们也没有提供维护上下文信息的内建支持。上下文的缺失引起许多困难。例如，在线商店的客户向他们的购物车中加入商品时，服务器如何知道购物车中己有何种物品呢？类似地，在客户决定结账时，服务器如何能确定之前创建的购物车中哪个属于此客户呢？这些问题虽然看起来十分简单，但是由于 HTTP 的不足，解答它们却异常复杂困难。对于这个问题，存在 3 种典型的解决方案：
Cookie（结合session使用）
可以使用 cookie 存储购物会话的 ID；在后续连接中，取出当前的会话 ID，并使用这个 ID 从服务器上的查找表（lookup table）中提取出会话的相关信息。 以这种方式使用 cookie 是一种绝佳的解决方案，也是在处理会话时最常使用的方式。但是，sevlet 中最好有一种高级的 API 来处理所有这些任务，以及下面这些冗长乏味的任务：从众多的其他cookie中（毕竟可能会存在许多cookie）提取出存储会话标识符的 cookie；确定空闲会话什么时候过期，并回收它们；将散列表与每个请求关联起来；生成惟一的会话标识符。
URL 重写
采用这种方式时，客户程序在每个URL的尾部添加一些额外数据。这些数据标识当前的会话，服务器将这个标识符与它存储的用户相关数据关联起来。 URL重写是比较不错的会话跟踪解决方案，即使浏览器不支持 cookie 或在用户禁用 cookie 的情况下，这种方案也能够工作。URL 重写具有 cookie 所具有的同样缺点，也就是说，服务器端程序要做许多简单但是冗长乏味的处理任务。即使有高层的 API 可以处理大部分的细节，仍须十分小心每个引用你的站点的 URL ，以及那些返回给用户的 URL。即使通过间接手段，比如服务器重定向中的 Location 字段，都要添加额外的信息。这种限制意味着，在你的站点上不能有任何静态 HTML 页面（至少静态页面中不能有任何链接到站点动态页面的链接）。因此，每个页面都必须使用 servlet 或 JSP 动态生成。即使所有的页面都动态生成，如果用户离开了会话并通过书签或链接再次回来，会话的信息也会丢失，因为存储下来的链接含有错误的标识信息。
隐藏的表单域
HTML 表单中可以含有如下的条目：
这个条目的意思是：在提交表单时，要将指定的名称和值自动包括在 GET 或 POST 数据中。这个隐藏域可以用来存储有关会话的信息，但它的主要缺点是：仅当每个页面都是由表单提交而动态生成时，才能使用这种方法。单击常规的超文本链接并不产生表单提交，因此隐藏的表单域不能支持通常的会话跟踪，只能用于一系列特定的操作中，比如在线商店的结账过程。