牛客选择题练习【一】（20道题）（含答案和解析）

1.执行如下程序，输出结果是（C）

class Test
{
	private int data;
	int result = 0;
	public void m()
	{
	result += 2;
	data += 2;
	System.out.print(result + " " + data);
	}
}
class ThreadExample extends Thread
{
	private Test mv;
	public ThreadExample(Test mv)
	{
	this.mv = mv;
	}
	public void run()
	{
		synchronized(mv)
		{
			mv.m();
		}
	}
}
class ThreadTest
{
	public static void main(String args[])
	{
		Test mv = new Test();
		Thread t1 = new ThreadExample(mv);
		Thread t2 = new ThreadExample(mv);
		Thread t3 = new ThreadExample(mv);
		t1.start();
		t2.start();
		t3.start();
	}
}

A 0 22 44 6
B 2 42 42 4
C 2 24 46 6
D 4 44 46 6
解析：
（1） 使用synchronized关键字加同步锁，使三个线程依次顺序操作m() 方法
（2）t1.start(); 使得result=2,data=2,输出即为2 2
t2.start(); 使得result=4,data=4,输出即为4 4
t3.start(); 使得result=6,data=6,输出即为6 6
（3）System.out.print(result +" "+ data)；是print()方法，不会自动换行，所以输出结果为2 24 46 6

2.要使对象具有序列化能力，则其类应该实现如下哪个接口(A)。
A java.io.Serializable
B java.lang.Cloneable,
C java.lang.CharSequence
D java.lang.Comparable
解析：
A选项：专门提供给类实现序列化的
B选项：实现克隆方法的；Object.clone() 方法可以合法地对该类实例进行按字段复制
C 选项：CharBuffer、String、StringBuffer、StringBuilder四个类都实现此接口，
这样当处理String或者StringBuffer的类时就不用重载
D选项：用于对实现它的每个类的对象进行整体排序
（1）序列化是干什么的？
为了保存在内存中的各种对象的状态，并且可以把保存的对象状态再读出来！
虽然可以用自己的各式方法来保存Object States，
但是Java提供一种较好的保存对象状态的机制，那就是序列化。
（2）什么情况下需要序列化 ？
a）当你想把内存中的对象保存到一个文件中或者数据库中时；
b）当你想用套接字在网络上传送对象时；
c）当你想通过RMI传输对象。

3.下列选项中属于面向对象设计方法主要特征的是（A）。
A 继承
B 自顶向下
C 模块化
D 逐步求精
解析：
A选项：面向对象设计的三大特征为：封装、继承、多态，如果问到四大特征，那就是：封装、继承、多态、抽象
B选项：算法中：分治法是自底向上的策略；动态规划是自顶向下的策略。面向过程的系统两种都采用，也就是“先局部再整体”和“先整体再局部”。
C选项：模块化就是：把程序划分成独立运行且可以独立访问的模块，每个模块完成一个子功能，把这些模块集成起来构成一个整体，可以完成指定的功能满足用户的需求。前端使用模块化可以：降低耦合度，减少重复代码，提高代码重用性，并且更清晰。
D选项：结构设计是一种应用最广泛的系统设计方法，是以“数据流”为基础，自顶向下、逐步求精和模块化的过程。

4.关于下列程序段的输出结果，说法正确的是：（D）

public class MyClass{
	static int i;
	public static void main(String argv[]){
		System.out.println(i);
	}
}

A 有错误，变量i没有初始化。
B null
C 1
D 0
解析：
int 型变量的默认初始值为0；
八大基本数据类型的默认值如下:
boolean（false） short（0） byte（0） float（0.0F或0.0f）
double（0.0） long（0L） char（‘\u0000’）

5.下列代码的执行结果是：（B）

public class Test3{
	public static void main(String args[]){
		System.out.println(100%3);
		System.out.println(100%3.0);
	}
}

A 1和1
B 1和1.0
C 1.0和1
D 1.0和1.0
解析：
类型转换的问题，前一个式子两个整型数据运算，结果为整型；
后一个式子一个整型和一个double型运算，结果应为double型

6. 在基本 JAVA 类型中，如果不明确指定，整数型的默认是 __ 类型，带小数的默认是 __ 类型？ (B)
A int float
B int double
C long float
D long double

7.方法通常存储在进程中的哪一区（D）
A 堆区
B 栈区
C 全局区
D 方法区
解析：
堆区放真正的数据，对象的属性信息；栈区存放局部变量；全局区放全局变量；方法区存放方法；另外，垃圾空间是指：没有任何栈内存指向的堆内存空间

8.不考虑反射，关于私有访问控制符 private 修饰的成员变量，以下说法正确的是（）
A 可以三种类所引用：该类自身、与它在同一包中的其他类，在其他包中的该类的子类
B 可以被两种类访问和引用：该类本身、该类的所有子类
C 只能被该类自身所访问和修改
D 只能被同一个包中的类访问
解析：
A选项：public权限
B选项：protected权限
C选项：private 修饰的变量，是私有变量。私有变量只能被本类自己所使用。
D选项：默认default

9.Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少 ( ).
A 11 ,-11
B 11 ,-12
C 12 ,-11
D 12 ,-12
解析：
(1)round方法，在Math中有重载的，一个参数是float，一个是double，对应返回int和long值。返回值是当前值+0.5向下取整（-0.5 --> 0）；
(2)ceil方法，没有重载，参数就是double，返回值也是double，但是这个时候就有区了，向上取整（-0.5 —> -0.0），注意一下，负号是保留的，和round有区别的；
(3) floor，和ceil一样，没有重载，参数和返回值都是double，向下取整（-0.5 -->-1.0）。
简单来说：
floor ： 意为地板，指向下取整，返回不大于它的最大整数
ceil ： 意为天花板，指向上取整，返回不小于它的最小整数
round ： 意为大约，表示“四舍五入”，而四舍五入是往大数方向入。

10.假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？（C）

public class A
{
	public int i;
	static String s;
	void method1(){}
	static void method2(){}
}

A System.out.println(a.i);
B a.method1();
C A.method1();
D A.method2();
解析：
static修饰的变量为静态成员变量；static修饰的方法为静态方法；静态成员变量，静态方法可以直接通过类名或对象名去调用；而非静态方法，应该是通过对象的实例化去调用。
即：C项应该是 a.method1();

11.A 派生出子类 B ， B 派生出子类 C ，并且在 java 源代码有如下声明：
A a0=new A();
A a1=new B();
A a2=new C();
问以下哪个说法是正确的？（D）
A 只有第一行能通过编译
B 第1、2行能通过编译，但第3行编译出错
C 第1、2、3行能通过编译，但第2、3行运行时出错
D 第1行，第2行和第3行的声明都是正确的
解析：
继承具有传递性，子类可以无条件的向上转型，所以都对。

12.下面代码将输出什么内容：（B）

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()方法的功能是：将String字符中的字母全变为小写，而非字母的保持不变。例如：toLowerCase（“Zyqqq_123”）的结果为“zyqqq_123”。又因为==比较的是地址，所以返回的是false

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

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方法！ 另外，在其他类的静态方法中也是可以调用公开的静态方法，此题hello方法是使用public修饰的所以在MyApplication中调用hello也可以。
在Test test=null;中会加载静态方法，所以test数据中包含Test类的静态初始化数据，
但是test并不能调用该类的非静态数据。

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

1. super()，this()和super，this关键字不是一个概念，
   前者是在构造器之间相互调用的语法，后者是代之父类或者本类的对象。
2. 每个构造器默认的第一行都是super()，但是有的时候直接父类的没有无参构造，
   那么就必须在子类构造的第一行显式的声明要调用哪个构造器。
3. this()和super()都必须出现在构造器的第一行，所以两者不可能出现在同一个构造器中。
4. this和super都不能出现在静态方法、静态块中。
   为什么要放置在第一行？
   (1)super()防止子类后面调用父类属性，在第一行初始化父类；
   (2)this()其自带调用super(),出现第一行，保证父类初始化的唯一性，不然会多次重复初始化

15.如下代码的 结果是什么 ?(B)

class Base {
	Base() {
		System.out.print("Base");
	}
}
public class Alpha extends Base {
	public static void main( String[] args ) {
		new Alpha();
		//调用父类无参的构造方法
		new Base();
	}
}

A Base
B BaseBase
C 编译失败
D 代码运行但没有输出
E 运行时抛出异常
解析：
Alpha作为子类继承了父类Base,当子类实例化对象前会先调用父类的构造方法产生父类对象，由两条new语句分别调用父类构造方法一次，所以输出 BaseBase。

16.如下代码的输出结果是什么？（D）

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 编译失败
解析：
从第三行语句开始就错了。静态变量又称为“类变量”，始终跟类联系在一起，只能定义在类主体里，不能定义在方法中，即便是静态方法也不行！！static的任何都是先于类而加载的。

17.下列哪一种叙述是正确的（D）
A abstract修饰符可修饰字段、方法和类
B 抽象方法的body部分必须用一对大括号{ }包住
C 声明抽象方法，大括号可有可无
D 声明抽象方法不可写出大括号
解析：
A选项： 不能修饰字段，可以有抽象类和抽象方法
B选项： 抽象方法不能有body部分，只能在子类中覆写
C选项： 声明时大括号绝对不能有，覆写时要补全方法体
D选项：抽象方法不能拥有方法体，即不能写出代表代码块的{}大括号。

18.下列说法正确的有：（C）
A class中的constructor不可省略
B constructor必须与class同名，但方法不能与class同名
C constructor在一个对象被new 时执行
D 一个class只能定义一个constructor
解析：
A选项： 可以省略，系统默认提供无参构造器
B选项： 构造器支持重载，构造方法就是要与主类同名，且在子类中还要重载（类名相同但参数列表不同）

19.选项中哪一行代码可以替换 //add code here 而不产生编译错误（A）

public abstract class MyClass {
	public int constInt = 5;
	//add code here
	public void method() {
	}
}

A public abstract void method(int a);
B consInt=constInt+5;
C public int method();
D public abstract void anotherMethod(){}
解析：
A选项： 抽象类可以包含抽象方法
B选项： 类中定义成员和方法，不能直接进行运算，可以写在代码块{}或者静态代码块static{}中
C选项： 与第四行想要构成重载，二者区别是返回类型，但是返回类型不能作为重载的依据
D选项： 该方法使用abstract修饰，是抽象方法，但是他有方法体(带有{}的就是方法体，即使里面是空的)，就不能作为抽象方法

20.java 中哪个关键字可以对对象加互斥锁？（B）
A transient
B synchronized
C serialize
D static
解析 ：
（1）synchronized关键字 : 用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码。
（2）volatile： 用来确保将变量的跟新操作通知到其他线程，当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。然而，在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比 synchronized关键字更轻量级的同步机制。
（3）serialize： Java 对象序列化为二进制文件。
（4）static关键字： static关键字可以修饰变量，方法，静态代码块。