Java选择题

最新推荐文章于 2024-12-09 18:49:33 发布

原创最新推荐文章于 2024-12-09 18:49:33 发布 · 1.9k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #后端

Java 专栏收录该内容

19 篇文章

订阅专栏

本文详细解析了一系列Java选择题，涉及注释、装箱拆箱、字符串操作、内存管理、多线程、继承、异常处理、内存区域、程序设计原则等多个核心概念，帮助Java开发者巩固基础知识。

文章目录

一、java选择题

一、java选择题

在程序代码中写的注释太多，会使编译后的程序尺寸变大。
正确答案: B 你的答案: A (错误)
正确
错误

注释不会被编译

装箱、拆箱操作发生在: ()
正确答案: C 你的答案: C (正确)
类与对象之间
对象与对象之间
引用类型与值类型之间
引用类型与引用类型之间

通过装箱和拆箱操作，能够在值类型和引用类型中架起一做桥梁
装箱——值类型转换为引用类型；如： int --> Integer
拆箱——引用类型转换为值类型。如：Integer --> int

执行以下程序后的输出结果是（）
public class Test {
public static void main(String[] args) {
StringBuffer a = new StringBuffer(“A”);
StringBuffer b = new StringBuffer(“B”);
operator(a, b);
System.out.println(a + “,” + b);
}
public static void operator(StringBuffer x, StringBuffer y) {
x.append(y); y = x;
}
}
正确答案: D 你的答案: D (正确)
A,A
A,B
B,B
AB,B

a和x是同个地址，b和y是同个地址，然后执行x.append(y)就把y的值放在x的地址里面此时a地址和x是同一个所以a就是AB了，接着执行y=x是把x的地址给y，这时候axy属于同一个地址。
所以y=x 只是改变了y的地址没改变b的地址，所以b还是B。

下列java程序的输出结果为____。
public class Example{
String str=new String(“hello”);
char[]ch={‘a’,‘b’};
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]=‘c’;
}
}
正确答案: B 你的答案: B (正确)
hello and ab
hello and cb
hello and a
test ok and ab
test ok and cb
test ok and c

String类是final类型的，不能继承和修改这个类。str=“tesk ok”，其实是隐含的让Java生成一个新的String对象，那么就与原来的“Hello”没有任何关系，当函数结束，str作用结束，所以输出的还是“Hello”。 char ch[] 是传递引用，修改了原内容。
String很奇特，虽然是引用数据类型，但是采用的却是值传递！！！基本数据类型采用的都是值传递,数组和对象都是引用传递(数组可以按照对象来算),值传递不会改变本身,只是传递拷贝,而引用传动却会改变本身！！！str属于值传递,不会改变！char[] 属于引用传递，所以改变本身值！

一般用()创建InputStream对象,表示从标准输入中获取数据,用()创建OutputStream对象，表示输出到标准输出设备中。
正确答案: A 你的答案: C (错误)
System.in System.out
System.out System.in
System.io.in System.io.out
System.io.out System.io.in

System.in 和 System.out 是java中的标准输入输出流，一般情况下代表从控制台输入和输出到控制台

顺序执行下列程序语句后，则b的值是（）
String a=“Hello”;
String b=a.substring(0,2);
正确答案: C 你的答案: C (正确)
Hello
Hel
He
null
下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？
正确答案: B 你的答案: B (正确)
private
无修饰符
public
protected

无修饰符就是默认权限，也叫包访问权限，只能被同一包内类访问

以下哪个不是Collection的子接口？
正确答案: D 你的答案: D (正确)
List
Set
SortedSet
Map
/…/中可以嵌套//注释，也能嵌套/…/注释。
正确答案: B 你的答案: A (错误)
正确
错误

多行注释可以嵌套单行注释，但是不能嵌套多行注释

以下代码的输出的正确结果是
public class Test {
public static void main(String args[]) {
String s = “祝你考出好成绩！”;
System.out.println(s.length());
}
}
正确答案: D 你的答案: D (正确)
24
16
15
8

GBK一个中文字符占两个字节，utf-8则是三个字节
java默认是JBK
字符串中的一个字符2个字节，所以输出为8个长度

以下对继承的描述错误的是（）
正确答案: A 你的答案: A (正确)
Java中的继承允许一个子类继承多个父类
父类更具有通用性，子类更具体
Java中的继承存在着传递性
当实例化子类时会调用父类中的构造方法

java可以多实现，只能单继承
毕竟亲的只能有一个，干的可以有多个

off-heap是指那种内存（）
正确答案: B 你的答案: D (错误)
JVM GC能管理的内存
JVM进程管理的内存
在JVM老年代内存区
在JVM新生代内存

程序计数器
几乎不占有内存。用于取下一条执行的指令。
off-heap叫做堆外内存，将你的对象从堆中脱离出来序列化，然后存储在一大块内存中，这就像它存储到磁盘上一样，但它仍然在(RAM)机存取存储器中。对象在这种状态下不能直接使用，它们必须首先反序列化，也不受垃圾收集。序列化和反序列化将会影响部分性能使用堆外内存能够降低GC导致的暂停。堆外内存不受垃圾收集器管理，也不属于老年代，新生代。

一个容器类数据结构，读写平均，使用锁机制保证线程安全。如果要综合提高该数据结构的访问性能，最好的办法是______。
正确答案: C 你的答案: C (正确)
只对写操作加锁，不对读操作加锁
读操作不加锁，采用copyOnWrite的方式实现写操作
分区段加锁
无法做到
当我们需要所有线程都执行到某一处，才进行后面的的代码执行我们可以使用？
正确答案: B 你的答案: C (错误)
CountDownLatch
CyclicBarrier
Semaphore
Future

CountDownLatch 一个或者多个线程，等待其他多个线程完成某件事情之后才能执行。举例：百米赛跑，就绪运动员等待发令枪发动才能起步。
CyclicBarrier多个线程互相等待，直到到达同一个同步点，再继续一起执行。举例：排队上摩天轮时，每到齐四个人，就可以上同一个车厢。

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

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

以下代码执行的结果显示是多少（）？
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 你的答案: C (错误)
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

首先，调用父类构造方法Super(){},然后调用test方法，由于子类Sub重写了父类的test方法,调用子类的test方法，输出flag=1，然后调用Sub的有参构造方法，输出信息。

关于异常的编程，以下描述错误的是：（）
正确答案: A 你的答案: A (正确)
在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
int i=Integer.parseInt(”123a”);将产生NumberFormatException
int a[]=null; a[0]=1; 将产生NullPointerException
输入输出流编程中，读和写时都要抛出IOException

运行时异常
ClassCastException(类转换异常)
ClassNotFoundException
IndexOutOfBoundsException(数组越界异常)
NullPointerException(空指针异常)
ArrayStoreException(数组存储异常，即数组存储类型不一致)
IO操作的BufferOverflowException异常
非运行异常
IOException
SqlException

下列哪个选项是正确计算42度（角度）的余弦值？
正确答案: C 你的答案: C (正确)
double d = Math.cos(42)
double d = Math.cosine(42)
double d = Math.cos(Math.toRadians(42))
double d = Math.cos(Math.toDegrees(42))

Math.cos为计算弧度的余弦值，Math.toRadians函数讲角度转换为弧度

表达式(short)10/10.2*2运算后结果类型是（）
正确答案: C 你的答案: C (正确)
short
int
double
float

首先，要注意是(short)10/10.22，而不是(short) (10/10.22)，前者只是把10强转为short，又由于式子中存在浮点数，所以会对结果值进行一个自动类型的提升，浮点数默认为double，所以答案是double；后者是把计算完之后值强转short。
可以小转换大，就是小孩可以穿进去大人的衣服，而大人要穿小孩的衣服，就需要强制转换

如何获取ServletContext设置的参数值？
正确答案: B 你的答案: C (错误)
context.getParameter()
context.getInitParameter()
context.getAttribute()
context.getRequestDispatcher()

getParameter()是获取POST/GET传递的参数值；
getInitParameter获取Tomcat的server.xml中设置Context的初始化参数
getAttribute()是获取对象容器中的数据值；
getRequestDispatcher是请求转发。

jre 判断程序是否执行结束的标准是（）
正确答案: A 你的答案: C (错误)
所有的前台线程执行完毕
所有的后台线程执行完毕
所有的线程执行完毕
和以上都无关

后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM的垃圾回收线程就是一个后台线程。前台线程：是指接受后台线程服务的线程，其实前台后台线程是联系在一起，就像傀儡和幕后操纵者一样的关系。傀儡是前台线程、幕后操纵者是后台线程。由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。

以下代码段执行后的输出结果为
public class Test {
public static void main(String args[]) {
int i = -5;
i = ++(i++);
System.out.println(i);
}
}
正确答案: C 你的答案: B (错误)
-7
-3
编译错误
-5

++（）括号里面必须是一个变量，而 i ++ 是一个字面量。

关于匿名内部类叙述正确的是？ ( )
正确答案: B 你的答案: B (正确)
匿名内部类可以继承一个基类，不可以实现一个接口
匿名内部类不可以定义构造器
匿名内部类不能用于形参
以上说法都不正确

由于构造器的名字必须与类名相同，而匿名类没有类名，所以匿名类不能有构造器。

运行代码，输出的结果是（）
public class P {
public static int abc = 123;
static{
System.out.println(“P is init”);
}
}
public class S extends P {
static{
System.out.println(“S is init”);
}
}
public class Test {
public static void main(String[] args) {
System.out.println(S.abc);
}
}
正确答案: A 你的答案: C (错误)
P is init
123
S is init
P is init
123
P is init
S is init
123
S is init
123

不会初始化子类的几种

调用的是父类的static方法或者字段
调用的是父类的final方法或者字段
通过数组来引用

以下哪些语言是面向对象的是（）
正确答案: B C 你的答案: B C (正确)
C
C++
JAVA
汇编

c是面向过程，c++面向对象，JAVA面向对象，汇编是面向机器

下列哪个是合法的 Java 标识符？（）
正确答案: B C 你的答案: A B C (错误)
Tree&Glasses
FirstJavaApplet
First_Applet
273.5

标识符只有英文，数字，下划线和$

final、finally、finalize三个关键字的区别是（）
正确答案: A B C 你的答案: B C (错误)
final是修饰符（关键字）可以修饰类、方法、变量
finally在异常处理的时候使用，提供finally块来执行任何清除操作
finalize是方法名，在垃圾收入集器将对象从内存中清除出去之前做必要的清理工作
finally和finalize一样都是用于异常处理的方法

final：可用来定义变量、方法传入的参数、类、方法。
finally：只能跟在try/catch语句中，并且附带一个语句块，表示最后执行。
finalize：是垃圾回收器操作的运行机制中的一部分，进行垃圾回收器操作时会调用finalize方法，因为finalize方法是object的方法，所以每个类都有这个方法并且可以重写这个方法，在这个方法里实现释放系统资源及其他清理工作，JVM不保证此方法总被调用。

有以下程序段，则下面正确的选项是（）
ublic class MyThead extends Thread{
public static void main(String[] args) {
MyThead t=new MyThead();
MyThead s=new MyThead();
t.start();
System.out.println(“one.”);
s.start();
System.out.println(“two.”);
}
public void run() {
System.out.println(“Thread”);
}
}
正确答案: B C D 你的答案: B C (错误)
编译失败
程序运行可能结果为：
one.
Thread
two.
Thread
程序运行可能结果是：
one.
two.
Thread
Thread
程序运行结果不稳定

start()是开启线程，等待获得时间片，一到获得时间片就执行。所以可能一开启就获得了时间片执行，也有可能等到two输出后才获得了时间片。所以BC都可能，所以D也正确。

java运行时内存分为“线程共享”和“线程私有”两部分，以下哪些属于“线程共享”部分
正确答案: B D 你的答案: B D (正确)
程序计算器
方法区
java虚拟机栈
java堆

共享的资源有：堆，全局变量，静态变量，文件等公共资源
独享的资源有：栈，寄存器，程序计数器

下面关于面向对象的一些理解哪些是错误的( )
正确答案: C 你的答案: C (正确)
面向对象的最重要的特性是支持继承、封装和多态
系统设计应该遵循开闭原则，系统应该稳定不不可修改，但应支持通过继承、组合等方式进行扩展
函数式的语言必然是面向对象的语言
面向对象设计时，每个类的职责应该单一，不要再一个类中引入过多的接口
过程式语言和面向对象的语言各有其优势，过程式语言更加灵活，面向对象语言更加强调抽象和封装
Java和C++都是静态类型的面向对象编程语言