Java笔试题摘录-基础中的基础
1.存在使i + 1 < i的数吗（）
答案：存在
解析：如果i为int型，那么当i为int能表示的最大整数时，i+1就溢出变成负数了，此时不就
答案：存在
解析：比如Double.NaN或Float.NaN
3.下面哪个流类属于面向字符的输入流( )
A BufferedWriter B FileInputStream C ObjectInputStream D InputStreamReader
答案：D
解析：Java的IO操作中有面向字节(Byte)和面向字符(Character)两种方式。
以InputStream（输入）/OutputStream（输出）为后缀的是字节流； 以Reader（输入）/Writer（输出）为后缀的是字符流。
4. ArrayList list = new ArrayList(20);中的list扩充几次（）
5.下面程序的运行结果是什么（）
class HelloA { public HelloA() {
System.out.println("HelloA");
}
{ System.out.println("I'm A class"); } static { System.out.println("static A"); }
}
public class HelloB extends HelloA {
public HelloB() {
System.out.println("HelloB");
}
{ System.out.println("I'm B class"); }
static { System.out.println("static B"); }
public static void main(String[] args) { new HelloB();
}
}
答案:
static A
static B
I'm A class
HelloA
I'm B class
HelloB
6.下面代码的运行结果为：（）
import java.io.*;
import java.util.*;
public class foo{
public static void main (String[] args){
String s;
System.out.println("s=" + s);
}
}
答案：由于String s没有初始化，代码不能编译通过；Java中所有定义的基本类型或对象都必须初始化才能输出值。
7.选项中哪一行代码可以替换题目中//add code here而不产生编译错误？（）
Apublic abstract void method(int a);
B constInt = constInt + 5;
C public int method();
D public abstract void anotherMethod() {}
答案：A
解析：考察抽象类的使用。
8. 阅读Shape和Circle两个类的定义。在序列化一个Circle的对象circle到文件时，下面哪个字段会被保存到文件中？ ( )
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class Shape
{
public String name;
}
public class Circle extends Shape implements Serializable{
private float radius;
transient int color;
public static String type = "Circle";
public static void main(String[] args) {
//1.try-with-resource创建文件流
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:/eclipse/workspace/work/circle.txt"))){
Circle circle = new Circle();
//2.将对象序列化到文件
oos.writeObject(circle);
} catch (Exception e) {
e.printStackTrace();
}
}
}
A name
B radius
C color
D type
答案：B
解析 1.父类无序列化，2.transient 3.static (反序列化时可以看到这个值，不过值为类的静态值而不是反序列化值)
9.输出内容
public class Dervied extends Base {
private String name = "dervied";
public Dervied() {
tellName();
printName();
}
public void tellName() {
System.out.println("Dervied tell name: " + name);
}
public void printName() {
System.out.println("Dervied print name: " + name);
}
public static void main(String[] args){ new Dervied();
}
}
class Base {
private String name = "base";
public Base() {
tellName();
printName();
} public void tellName() {
System.out.println("Base tell name: " + name);
} public void printName() {
System.out.println("Base print name: " + name);
}
}
答案：
Dervied tell name: null
Dervied print name: null
Dervied tell name: dervied
Dervied print name: dervied
10.以下程序的执行结果是什么
class Base{
void test() {
System.out.println(“Base.test()”);
}
}
public class Child extends Base {
void test() {
System.out.println(“Child.test()”);
}
public static void main(String[] a) {
Child anObj = new Child();
Base baseObj = (Base)anObj;
baseObj.test();
}
}
A Child.test() Base.test()
B Base.test() Child.test()
C Base.test()
D Child.test()
解答：D
测试代码相当于：Base baseObj = new Child();父类的引用指向子类的实例，子类又重写了父类的test方法，因此调用子类的test方法。
11.以下程序的执行结果是什么
class Base{
static void test() {
System.out.println(“Base.test()”);
}
}
public class Child extends Base {
void test() {
System.out.println(“Child.test()”);
Base.test(); //Call the parent method
}
static public void main(String[] a) {
new Child().test();
}
}
A Child.test() Base.test()
B Child.test() Child.test()
C 编译报错.
D 运行报错.
解答：C
静态方法不能在子类中被重写
12.以下程序的执行结果是什么；’ ?’ 是空格的意思.
public class Base{
private void test() {
String aStr = “?One?”;
String bStr = aStr;
aStr.toUpperCase();
aStr.trim();
System.out.println(“[" + aStr + "," + bStr + "]“);
}
static public void main(String[] a) {
new Base().test();
}
}
A [ONE,?One?]
B [?One?,One]
C [ONE,One]
D [ONE,ONE]
E [?One?,?One?]
解答：E
13.下面关于变量及其范围的陈述哪些是不正确的（ ）
A．实例变量是类的成员变量
B．实例变量用关键字static声明
C．在方法中定义的局部变量在该方法被执行时创建
D．局部变量在使用前必须被初始化
解答：BC
由static修饰的变量称为类变量或是静态变量；方法加载的时候创建局部变量
14.编译运行以下程序后，关于输出结果的说明正确的是
public class Conditional{
public static void main(String args[ ]){
int x=4;
System.out.println(“value is “+ ((x>4) ? 99.9 :9));
}
}
A、 输出结果为：value is 99.99
B、 输出结果为：value is 9
C、 输出结果为：value is 9.0
D、 编译错误
解答：C
三目运算符中：第二个表达式和第三个表达式中如果都为基本数据类型，整个表达式的运算结果由容量高的决定。99.9是double类型 而9是int类型，double容量高。
15.关于以下程序代码的说明正确的是（ ）：
class HasStatic{
private static int x=100；
public static void main(String args[ ]){
HasStatic hs1=new HasStatic( );
hs1.x++;
HasStatic hs2=new HasStatic( );
hs2.x++;
hs1=new HasStatic( );
hs1.x++;
HasStatic.x - -;
System.out.println(“x=”+x);
}
}
A、5行不能通过编译，因为引用了私有静态变量
B、10行不能通过编译，因为x是私有静态变量
C、程序通过编译，输出结果为：x=101
D、程序通过编译，输出结果为：x=102
E、程序通过编译，输出结果为：x=103
解答：D
静态变量是所有对象所共享的，所以上述代码中的几个对象操作是同一静态变量x， 静态变量可以通过类名调用。
16.下列哪种说法是正确的（）
A．实例方法可直接调用超类的实例方法
B．实例方法可直接调用超类的类方法
C．实例方法可直接调用其他类的实例方法
D．实例方法可直接调用本类的类方法
解答：D
A. 实例方法不可直接调用超类的私有实例方法
B. 实例方法不可直接调用超类的私有的类方法
C．要看访问权限
17.下面代码的执行结果是？
import java.util.*;
public class ShortSet{
public static void main(String args[]){
Set
for(Short i=0;i<100;i++){
s.add(i);
s.remove(i-1);
}
System.out.println(s.size());
}
}
A.1
B.100
C.Throws Exception
D.None of the Above
解答：B
i是Short类型， i-1是int类型,其包装类为Integer，所以s.remove(i-1)不能移除Set集合中Short类型对象；只有将（i-1）强转为Short类型的时候，才能移除Set集合中的对象
18.以下关于面向对象概念的描述中，不正确的一项是（）
A.在现实生活中，对象是指客观世界的实体
B.程序中的对象就是现实生活中的对象
C.在程序中，对象是通过一种抽象数据类型来描述的，这种抽象数据类型称为类（class）
D.在程序中，对象是一组变量和相关方法的集合
解答：B
面向过程强调的是每一个功能的具体实现步骤，面向对象强调的是对象调用功能
19.插入排序算法，将元素插入一个有序队列：第一步取数，第二步插入
public static void injectionSort(int[] number) {
// 第一个元素作为一部分，对后面的部分进行循环
for (int j = 1; j < number.length; j++) {
int tmp = number[ j ];
int i = j – 1;
while (tmp < number[ i ]) {
number[i + 1] = number[ i ];
i - -;
if (i == -1)
break;
}
number[i + 1] = tmp;
}
}
20.冒泡排序，元素上浮：第一步循环次数，第二步元素上浮
//N个数字冒泡排序，总共要进行N-1趟比较，每趟的排序次数为(N-i)次比较
public static void bubbleSort(int[] arr){
//一定要记住判断边界条件，很多人不注意这些细节，面试官看到你的代码的时候都懒得往下看，你的代码哪个项目敢往里面加？
if(arr==null||arr.length<2){
return;
}
//需要进行arr.length趟比较
for(int i = 0 ;i
for(int j = 0 ;j
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
// System.out.println("最终得出的数组为：");
// for (int k =0 ; k < arr.length;k++){
// System.out.print(arr[k]+" ");
// }
}
21.选择排序：挑选元素放到指定位置。第一步，选择位置；第二步，选择元素
public static void selectSort(int [] arr,int n){
for (int i = 0; i < n - 1; i++) {
int index = i;
int j;
// 找出最小值得元素下标
for (j = i + 1; j < n; j++) {
if (arr[j] < arr[index]) {
index = j;
}
}
int tmp = arr[index];
arr[index] = arr[i];
arr[i] = tmp;
System.out.println(Arrays.toString(arr));
}
}
22.下列程序的运行结果是什么？
public class Test {
public static void main(String[] args) {
String str = NULL;
System.out.println(str);
}
}
A. NULL
B. 编译时报错
C. ""
D.运行时报错
23、下列程序执行结果是什么？
public class Text{
public static void main(String[] args){
int a=10,b=4,c=20,d=6;
System.out.println(a++*b+c*--d);
}
}
A、144
B、164
C、140
D、160
解答：C
在java中执行加减乘除基本运算时，已就遵循先乘除后加减的原则，而++a与a++的区别在于，++a是先自增后在参与运算，a++是先参与运算之后在自增，所以最终答案是10*4+20*5=140
24、下列哪两个选项不能直接导致线程停止？
A. 跳出同步代码块
B. 调用wait方法
C. 调用notify方法
D. 调用读取流的方法
E. 设置线程的优先权
25.下列程序的运行结果是什么:
public class TestInner {
class Foo {
public int i = 3;
}
public static void main (String args[]) {
Object o = (Object) new TestInner().new Foo();
Foo foo = (Foo)o;
System.out.println(foo.i);
}
}
26.public class Text{
public static void main(String[] args){
int i=12;
System.out.println(i+=i-=i*=i);
}
}
A、程序无法编译
B、100
C、0
D、-120
解答：D
本题我们先将i+=i-+i*=i编号 => i1+=i2-=i3*=i4;在计算之前先明白i1=i2=i3=i4=i=12;先计算i3=i*i=144,;再计算i1+=i2即为i1=i1+i2=24，此时i1=i2=24;最后计算i2-=i3即为i2=i2-i3=-120;
总结出下来就是，对于同一个变量，左边变量变化对右边
变量产生影响，而右边变量的变化对左边变量不产生影响。
27、 下列选项中，哪些选项与第2行相等:
1. public interface Foo{
2. int k = 4;
3. }
A. final int k = 4;
B. Public int k = 4;
C. static int k = 4;
D. Private int k = 4;
E. Abstract int k = 4;
F. Volatile int k = 4;
G. Transient int k = 4;
H. protected int k = 4;
ABC
解析：Interface 变量等同于 public static final int k = 4;
28、 下列代码的执行结果是什么:
public class foo {
static String s;
public static void main (String[]args) {
System.out.println (“s=” + s);
}
}
A. 代码编译成功并输出“s=”
B. 代码编译成功并输出“s=null”
C. 因为变量s没有初始化，所以代码编译失败
D. 代码编译成功，但在调用toString的时候抛出NullPointerException异常
解答：B
String为引用数据类型，引用类型数据成员的默认值为null
29.从下面代码中选择出错误的代码段（）
public class Something {
void doSomething () {
private String s ="";
int l = s.length();
}
}
30.请看如下代码
class Person {
private int a;
public int change(int m){
return m;
}
}
public class Teacher extends Person{
public int b;
public static void main(String arg[]){
Person p = new Person();
Teacher t = new Teacher();
int i;
// point x
}
}
下面哪些放在// point x?行是正确的？
A， i = m;
B， i = b;
C， i = p.a;
D， i = p.change(3);
E， i = t.b;
解答：DE
A.不同的作用域
B．静态方法中不能直接使用非静态成员变量
C．类外不能访问其它类私有的成员
D，E．在类方法中可以通过实例化对象调用类中的实例成员。