java笔试题选择题

程序员文章站 2022-06-17 18:46:26

...

来源于文章地址:
0-60
https://blog.csdn.net/qq_36075612/article/details/71126487
60致120
https://blog.csdn.net/qq_36075612/article/details/71126670
120致180
https://blog.csdn.net/zhangbingtao2011/article/details/80610694

父子类的继承关系

重写

子类重写父类时权限不能降低
子类重写父类的方法返回值类型要相同或是父类方法返回值类型的子类

class A {
	protected int method1 (int a, int b) {
		return 0;
	}
}
A. public int method 1 (int a, int b) { return 0; }
B. private int method1 (int a, int b) { return 0; }
C. private int method1 (int a, long b) { return 0; }
D. public short method1 (int a, int b) { return 0; }
AC

在下面程序的第6行补充上下列哪个方法,会导致在编译过程中发生错误?
1) class Super{
2) public float getNum(){
3) return 3.0f;
4) }
}
5) pubhc class Sub extends Super{
6)
7) }
A,public float getNum(){retun 4.0f;}
B.public void getNum(){}
C.public void getNum(double d){}
D.public double getNum(float d){ retun 4.0f ;} 解答：B
方法重写的问题。子类中有和父类的方法名相同，但是参数不同，不会出编译错误，认为是子类
的特有的方法，但是如果子类中方法和父类的方法名，参数，访问权限，异常都相同，只有返回值
类型不同会编译不通过。

static方法不能被重写,如果重写也只能在子类中同样用static来重写
java笔试题选择题

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();
	}
}
Select most appropriate answer.
A Child.test()
Base.test()
B Child.test()
Child.test()
C Compilation error. Cannot override a static method by an instance method
D Runtime error. Cannot override a static method by an instance method
答案为C 静态方法不能在子类中被重写

 Which two declarations prevent the overriding of a method? (Choose Two)
A. final void methoda() {}
B. void final methoda() {}  #final放在这个位置会出现编译错误,需要放在void前面
C. static void methoda() {} #子类也可以重写这个方法只不过是static来重写
D. static final void methoda() {}
E. final abstract void methoda() {} # abstract不能与final一起用非法
解答：AD
final修饰方法，在子类中不能被重写。

父引用子类

class Base{
	void test() {
	System.out.println(“Base.test()”);
	}
}
public class Child extends Base {
	void test() {
		System.out.println(“Child.test()”);
	}
	static public 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方法

类的访问权限

1

14.下列哪种说法是正确的（）
A．实例方法可直接调用超类的实例方法
B．实例方法可直接调用超类的类方法
C．实例方法可直接调用其他类的实例方法
D．实例方法可直接调用本类的类方法
解答：D
A. 实例方法不可直接调用超类的私有实例方法
B. 实例方法不可直接调用超类的私有的类方法
C．要看访问权限

2

1.package foo;
2.import java.util.Vector;
3.private class MyVector extends Vector {
4.int i = 1;
5.public MyVector() {
6.i = 2;
7. }
8.}
9.public class MyNewVector extends MyVector {
10.public MyNewVector () {
11. i = 4;
12.}
13.public static void main (String args []) {
14.MyVector v = new MyNewVector();
15. }
16.}
The file MyNewVector.java is shown in the exhibit. What is the result?
A. Compilation will succeed.
B. Compilation will fail at line 3.
C. Compilation will fail at line 6.
D. Compilation will fail at line 9.
E. Compilation will fail at line 14.
解答：B
类MyVector不能是私有的

不同包子类可以访问父类protected成员

已知A类被打包在packageA , B类被打包在packageB ，且B类被声明为public ，且有一个成员变量x被声明为, protected控制方式 。C类也位于packageA包，且继承了B类 。则以下说话正确的是（ ）
A. A类的实例不能访问到B类的实例
B. A类的实例能够访问到B类一个实例的x成员
C. C类的实例可以访问到B类一个实例的x成员
D. C类的实例不能访问到B类的实例
解答：C
不同包子类的关系， 可以访问到父类B的protected成员

内部类

很刁钻的一种内部类的写法

public class Test {
	public static void main (String args[]) {
		class Foo {
			public int i = 3;
		}
		Object o = (Object) new Foo();
		Foo foo = (Foo)o;
		System.out.println(foo.i);
	}
}
What is the result?
A. Compilation will fail.
B. Compilation will succeed and the program will print “3”
C. Compilation will succeed but the program will throw a ClassCastException at line 6.
D. Compilation will succeed but the program will throw a ClassCastException at line 7.
解答：B
局部内部类的使用

抽象类

抽象方法

抽像方法不能被修饰成static,否则子类无法覆盖

2.Abstract method cannot be static. True or False ?
A True
B False
解答：A

8.下列关于修饰符混用的说法，错误的是（ ）：
A．abstract不能与final并列修饰同一个类
B．abstract类中可以有private的成员
C．abstract方法必须在abstract类中
D．static方法中能处理非static的属性
解答 D
:静态方法中不能引用非静态的成员

String

与运算符在一起

public class Base{
	private void test() {
		System.out.println(6 + 6 + “(Result)”);
	}
	static public void main(String[] a) {
		new Base().test();
	}
}
Select most appropriate answer.
A 66(Result)
B 12(Result)
C Runtime Error.Incompatible type for +. Can’t convert an int to a string.
D Compilation Error.Incompatible type for +. Can’t add a string to an int.
答案为B
“(Result)”+6 + 6	那么结果就是(Result)66
6 + 6 + “(Result)” 那么结果就是 12(Result)

char的范围

31. What is the numerical range of a char?
A. 0 … 32767
B. 0 … 65535
C. –256 … 255
D. –32768 … 32767
E. Range is platform dependent.
解答：B
在Java中，char是一个无符号16位类型，取值范围为0到65535。

String的"aaa"

public class Test {
	public static void main (String [] args) {
		String foo = “blue”;
		String bar = foo;
		foo = “green”;
		System.out.println(bar);
	}
}
What is the result?
A. An exception is thrown.
B. The code will not compile.
C. The program prints “null”
D. The program prints “blue”
E. The program prints “green”
解答：D

String的默认值

public class foo {
static String s;
	public static void main (String[]args) {
		System.out.println (“s=” + s);
	}
}
What is the result?
A. The code compiles and “s=” is printed.
B. The code compiles and “s=null” is printed.
C. The code does not compile because string s is not initialized.
D. The code does not compile because string s cannot be referenced.
E. The code compiles, but a NullPointerException is thrown when toString is called.
解答：B
String为禁用数据类型，引用类型数据成员的默认值为null

String数组初始化

52.下面哪个是正确的？( )
A. String temp [] = new String {“a” “b” “c”};
B. String temp [] = {“a” “b” “c”}
C. String temp = {“a”, “b”, “c”}
D. String temp [] = {“a”, “b”, “c”}
解答：D

局部变量

下面关于变量及其范围的陈述哪些是不正确的（ ）：
A．实例变量是类的成员变量
B．实例变量用关键字static声明
C．在方法中定义的局部变量在该方法被执行时创建
D．局部变量在使用前必须被初始化
答案 为BC
1.实例变量不用static修饰,static个性的是静态属性即类变量
2.局部变量是在方法加载时创建,并不是执行时创建

static

static静态代码块

11.关于以下application的说明，正确的是（ ）：
1． class StaticStuff
2． {
3． static int x=10；
4． static { x+=5；}
5． public static void main（String args[ ]）
6． {
7． System.out.println(“x=” + x);
8． }
9． static { x/=3;}
10. }
A、 4行与9行不能通过编译，因为缺少方法名和返回类型
B、 9行不能通过编译，因为只能有一个静态初始化器
C、 编译通过，执行结果为：x=5
D、编译通过，执行结果为：x=3
解答：C
*块是类加载的时候就会被执行到的，*块的执行顺序是按照在类中出现的先后顺序执行。

static变量是所有对象共享的

12.关于以下程序代码的说明正确的是（ ）：
1．class HasStatic{
2． private static int x=100；
3． public static void main(String args[ ]){
4． HasStatic hs1=new HasStatic( );
5． hs1.x++;
6． HasStatic hs2=new HasStatic( );
7． hs2.x++;
8． hs1=new HasStatic( );
9． hs1.x++;
10． HasStatic.x–;
11． System.out.println(“x=”+x);
12． }
13．}
A、5行不能通过编译，因为引用了私有静态变量
B、10行不能通过编译，因为x是私有静态变量
C、程序通过编译，输出结果为：x=103
D、程序通过编译，输出结果为：x=102
解答：D
静态变量是所有对象所共享的

static变量的访问

You need to insert an inner class declaration at line2. Which two inner class declarations are valid? (Choose Two)
A. static class InnerOne { public double methoda() {return d1;} }
B. static class InnerOne { static double methoda() {return d1;} }
C. private class InnerOne { public double methoda() {return d1;} }
D. protected class InnerOne { static double methoda() {return d1;} }
E. public abstract class InnerOne { public abstract double methoda(); }
解答：CE
AB.内部类可以声明为static的，但此时就不能再使用外层封装类的非static的成员变量；
D.非static的内部类中的成员不能声明为static的，只有在顶层类或static的内部类中
才可声明static成员

向下或向上转型

运算符向上转型

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、 编译错误
三目运算符中 看谁容易量高,在这里double容易最高
所以最后 选C

short的转换

16.下面代码的执行结果是？
import java.util.*;
public class ShortSet{
	public static void main(String args[]){
		Set<Short> s=new HashSet<Short>();
		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类型对象。

Math的操作

41、Which code determines the int value foo closest to a double value bar?
A. int foo = (int) Math.max(bar);  //这个是错的要两个参数
B. int foo = (int) Math.min(bar); //这个是错的要两个凑到
C. int foo = (int) Math.abs(bar); //取决对值
D. int foo = (int) Math.ceil(bar); //cell
E. int foo = (int) Math.floor(bar);
F. int foo = (int) Math.round(bar);
解答：DEF
A B两个选项方法是用错误，都是两个参数。
abs方法是取bar的绝对值，
ceil方法返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。
floor方法返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。
round方法 返回最接近参数的 long。

floor 向下取整
ceil  向上取整
round 则是4舍5入的计算，round方法，它表示“四舍五入”，算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整
Math.floor(1.4)=1.0
Math.round(1.4)=1
Math.ceil(1.4)=2.0

位运行相关

非运算符用符号“~”表示，其运算规律如下：
如果位为0，结果是1，如果位为1，结果是0，下面看一个简单例子。
public class data15
{
public static void main(String[] args)
{
int a=2;
System.out.println(“a 非的结果是：”+(~a)); //-3
}
}

public class test (
public static void main (String args[]) {
int i = 0xFFFFFFF1;
int j = ~i;
}
)
程序运行到第5行时,j的值为多少?( )
A. –15
B. 0
C. 1
D. 14
E. 在第三行的错误导致编译失败
解答：D
1111111111111111111111111111 0001
取完~之后
0000000000000000000000000000 1110 即为14

创建数组

Which two create an instance of an array? (Choose Two)
A. int[] ia = new int [15];
B. float fa = new float [20];  //得写成这样float[] fa
C. char[] ca = “Some String”;
D. Object oa = new float[20];//相当于object指向了数组的引用
E. Int ia [][] = (4, 5, 6) (1, 2, 3)
解答：AD
任何类的父类都是Object，数组也数据引用类型，Object oa = new float[20];这种写法相当于父类的用指向之类的实例。

数据结构

链表

17.链表具有的特点是：(选择3项)
A、不必事先估计存储空间
B、可随机访问任一元素
C、插入删除不需要移动元素
D、所需空间与线性表长度成正比
解答：ACD
A.采用动态存储分配，不会造成内存浪费和溢出。
B. 不能随机访问，查找时要从头指针开始遍历
C. 插入、删除时，只要找到对应前驱结点，修改指针即可，无需移动元素
D. 需要用额外空间存储线性表的关系，存储密度小

插入排序

对记录序列{314，298，508，123，486，145}按从小到大的顺序进行插入排序，经过两趟排序后的结果为：(选择1项)
A {314，298，508，123，145，486}
B {298，314，508，123，486，145}
C {298，123，314，508，486，145}
D {123、298，314，508，486，145}
解答：B
插入排序算法：
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;
		}
}

java笔试题选择题

栈

25.栈是一种。(选择1项)
A 存取受限的线性结构
B 存取不受限的线性结构
C 存取受限的非线性结构
D 存取不受限的非线性结构
解答：A
栈（stack）在计算机科学中是限定仅在表尾进行插入或删除操作的线性表。

多线程

多线程1

实现 run()方法时 run()方法也可以是synchronize修饰的

1.public class X implements Runnable {
2. private int x;
3. private int y;
4. public static void main(String [] args) {
5. X that = new X();
6. (new Thread(that)).start();
7. (new Thread(that)).start();
8. }
9. public synchronized void run( ){
10. for (;;) {
11. x++;
12. y++;
13. System.out.println(“x = “ + x + “, y = “ + y);
14. }
15. }
16.}
What is the result?
A. An error at line 11 causes compilation to fail.
B. Errors at lines 7 and 8 cause compilation to fail.
C. The program prints pairs of values for x and y that might not always be the same on the same line (for example, “x=2, y=1”)
D. The program prints pairs of values for x and y that are always the same on the same line (for example, “x=1, y=1”. In addition, each value appears twice (for example, “x=1, y=1” followed by “x=1, y=1”)
E. The program prints pairs of values for x and y that are always the same on the same line (for example, “x=1, y=1”. In addition, each value appears twice (for example, “x=1, y=1” followed by “x=2, y=2”)
解答：E
多线程共享相同的数据，使用synchronized实现数据同步。

java笔试题选择题