本题目仅针对初、中级Java工程师的笔试复习，另附 Java经典面试题
1、0.6332的数据类型是（B）
A、float
B、double
C、Float
D、Double
解析：默认为 double 型，如果为 float 型需要加上f显示说明，即 0.6332f
2、int[]a=new int[10];以下正确的是（C）
A、a[9]未定义
B、a[9]为空
C、a[9]为0
D、a[10]为0
3、下面代码输出值System.out.println(2.00-1.10);（C）
A、0.9
B、0.90
C、0.8999999999999999
D、以上答案都不对
4、下列程序输出值：（C）
System.out.println(new Integer(0)==new Integer(0));
System.out.println(new Integer(0)==0);
A、true,true
B、true,false
C、false,true
D、false,false
5、下列程序输出值：（B）
int i=0;
i=i++;
i++;
System.out.println(i);
A、0
B、1
C、2
D、以上答案都不对
6、以下哪个表达式是不合法的（CD）
A、Strings="abc";int i=1;s+=i;
B、Strings="abc";int i=1;s=s+i;
C、Strings="abc";int i=1;if(s==i){}
D、Strings=null;int i=(s!=null)&&(s.length>0)?s.length:0;
7、以下程序输出值：（C）
public static int fun(int i){
int result=0;
switch(i){
case 1:
result =+i*1;
case 2:
result =+i*2;
case 3:
result =+i*3;
}
return result;
}
A、2
B、4
C、6
D、10
解析：=+不是+=
8、下列程序输出值：（D）
try{
//发生RuntimeException
}catch(ArithmeticExceptione){
System.out.println("AE");
}catch(RuntimeExceptione){
System.out.println("RE");
}catch(Exceptione){
System.out.println("E");
}
A、AE,RE,E
B、AE,RE
C、RE,E
D、RE
9、下列程序输出值：（A）
int i=5;
while(i-->=1){
try{
System.out.print(i);
if(i==2){
new Exception();
}
}catch(Exceptione){
i=1;
System.out.print(i);
}finally{
System.out.print(i);
}
}
A、4433221100
B、443321100
C、44332110
D、44332100
10、以下代码输出结果：
public static void main(String[]args){
System.out.println("return i="+function());
}
public static int function(){
int i=1;
try{
i=2;
return i;
}finally{
i=3;
System.out.println("finally i="+i);
}
}
结果：finally i=3,return i=2
11、下列程序分别只用语句1、2、3是否能编译通过（C）
public interface T1 {
void fun()throws Exception;
}
public interface T2 {
void fun()throws IOException;
}
public interface T3extends T1, T2 {}
public class Cimplements T3 {
public void fun()throws Exception;//语句1
void fun(){};//语句2
public void fun()throws IOException {}//语句3
}
A、不能、不能、能
B、不能、能、不能
C、不能、不能、不能
D、不能、能、能
12、下列程序输出值：（B）
public class Fun {
private Fun(Objecto){
System.out.println("Object");
}
private Fun(double[]d){
System.out.println("Array");
}
public static void main(String[]args){
new Fun(null);
new Fun((Object)null);
}
}
A、Object,Array
B、Array,Object
C、Object,Object
D、Array,Array
13、以下程序输出值：（C）
public class T1 {
public static void f1(){
System.out.println("T1.f1");
}
public void f2(){
System.out.println("T1.f2");
}
}
public class T2extends T1 {
public static void f1(){
System.out.println("T2.f1");
}
public void f2(){
System.out.println("T2.f2");
}
}
public static void main(String[]args) {
T1t1=new T1();
T1t2=new T2();
t1.f1();
t1.f2();
t2.f1();
t2.f2();
}
A、T1.f1,T1.f2,T2.f1,T2.f2
B、T1.f1,T1.f2,T1.f1,T1.f2
C、T1.f1,T1.f2,T1.f1,T2.f2
D、以上答案都不对
14、以下程序输出值：（D）
public class A {
static class B{
static Strings="B.s";
}
static CB=new C();
}
public class C {
Strings="C.s";
}
public static void main(String[]args) {
System.out.println(A.B.s);
System.out.println(((A.B)null).s);
}
A、B.s,B.s
B、B.s,C.s
C、C.s,C.s
D、C.s,B.s
15、下列程序运行的结果（B）
public class Main {
Strings=new String("abc");
char[]c={'1','2','3'};
public static void change(Strings,char[]c){
s="xyz";//或new String("xyz");
c[0]='0';
}
public static void main(String[]args) {
Mainm=new Main();
m.change(m.s,m.c);
System.out.println(m.s+"/"+String.valueOf(m.c));
}
}
A、abc/123
B、abc/023
C、xyz/123
D、xyz/023
【考查值传递和地址传递的关系】
16、下列代码说法正确的是（C）
public class Testextends Threadimplements Runnable {
private Testtest=this;//语句1
private int i;
public void run(){
i++;
System.out.println("test.i="+(++test.i));//语句2
System.out.println("Test.i="+i);
}
public static void main(String[]args){
Threadt=new Thread(new Test());
t.start();
}
}
A、语句1编译错误
B、语句2编译错误
C、输出test.i=2，Test.i=2
D、输出test.i=2，Test.i=1
17、以下代码说法正确的是（D）
public class Main {
static int i=10;
static{//语句1
i+=5;
}
public static void main(String[]args){
System.out.println("i="+i);
}
static{//语句2
i/=3;
}
}
A、语句1和语句2编译错误，因为缺少方法名和返回值类型
B、语句2编译错误，因为只能有一个静态代码块
C、编译通过，输出：i=15
D、编译通过，输出：i=5
18、以下代码说法正确的是（C）
public class Main {
private static int i=10;
public static void main(String[]args){
Mainm1=new Main();
m1.i++;//语句1
Mainm2=new Main();
m2.i++;
m1=new Main();
m1.i++;
Main.i++;//语句2
System.out.println("i="+Main.i);
}
}
A、语句1编译错误，因为引用私有静态变量
B、语句2编译错误，因为引用私有静态变量
C、编译通过，输出：i=14
D、编译通过，输出：i=13
19、以下程序的输出值：（A）
package pag01;
public class A {
public void fun1(){
fun2();
}
void fun2(){
System.out.println("A.fun2");
}
}
package pag02;
import pag01.A;
public class B {
private static class Cextends A{
void fun2(){
System.out.println("C.fun2");
}
}
public static void main(String[]args){
new C().fun1();
}
}
A、A.fun2
B、C.fun2
C、编译错误
D、编译通过，运行错误
【当A、B同包则输出：C.fun2】
20、以下程序输出值：（A）
public class Null {
public static void fun(){
System.out.println("fun");
}
public static void main(String[]args){
((Null)null).fun();
}
}
A、fun
B、NullPointerException
C、编译错误
D、编译通过，运行错误
【任意类对null强转都等于类本身】
21、下面说法正确的是（C）
A、Class中的constructor不可省略
B、constructor必须与类同名，而方法不能与Class同名
C、constructor在对象被new时执行
D、一个Class中只能有一个constructor
22、下面哪个类属于面向字符的输入流（D）
A、BufferedWriter
B、FileInputStream
C、ObjectInputStream
D、InputStreamReader
23、Java接口的修饰符可以是（D）
A、private
B、protected
C、final
D、abstract
24、下列说法正确是（ABC）
A、LinkedList实现List
B、AbstractSet实现Set
C、HashSet继承AbstractSet
D、WeakHashMap继承HashMap
25、下列哪些是Thread类的方法（ABD）
A、start()
B、run()
C、exit()
D、getPriority()
26、比较以下两种写法的正确性：
short n = 1;n =n + 1;//语句1
short n = 1;n += 1;//语句2
语句1错误，n+1是整型，再次赋值给short类型值要强制类型转换
语句2正确，+= 是Java语言规定的运算符，编译器会对它做特殊处理
27、（1）最有效率的方法算出2乘以8等于几?
因8=2^3，2*8即2*2^3，故2 <<3
（2）最有效率的方法算出2乘以17等于几?
因17=2^4+1，2*17即2*(2^4+1)，故(2 << 4)+2
【+优先级大于<<，不能写成2<<4+2】
28、以下代码是否存在错误，修正后输出结果?
public class A {
public Strings=new String("abc");
public A(){
System.out.println("A created...");
}
}
public class Bextends A {
public B(){
System.out.println("B created...");
}
public String getSupers(){
System.out.println(super.s);
return super.s;
}
}
public class C {
public static void main(String[]args){
Aa=new B();
Strings="abc";
System.out.println(((B)a).getSupers()==s);
System.out.println(((B)a).getSupers().equals(s));
}
}
结果：A created...
B created...
abc
false
abc
true
29、以下代码有几处错误，修正后输出结果？
public abstract class A {
private Stringname;//错误1
static{
name="zhangsan";
}
private abstract boolean fun1(Stringname){};//错误2,3
void fun2(){
private Strings="";//错误4
int i=s.length;//错误5
System.out.println("fun2.i="+i+",fun1="+fun1(A.name));
}
}
public class Bextends A {
boolean fun1(Stringname) {
return name.equals("zhangsan");
}
}
public class Main {
public static void main(String[]args){
Aa=new B();
a.fun2();
}
}
结果：fun2.i=0,fun1=true
30、以下代码输出结果：
public class Main {
Strings1;
public void function(){
Strings2;
System.out.println("s1="+s1);
System.out.println("s2="+s2);
}
}
结果：s1=null,s2编译期错误
31、以下代码的输出结果：
public class Dogimplements Animal {
public Dog(){
System.out.println(this.getClass().getName());
System.out.println(super.getClass().getName());
System.out.println(this.getClass().getSuperclass().getName());
}
public static void main(String[]args){
Animala=new Dog();
}
}
结果：Dog,Dog,java.lang.Object
32、以下代码的输出结果：
public class Parent {
{
System.out.println("父类非静态代码块");
}
static {
System.out.println("父类静态代码块");
}
public Parent() {
System.out.println("父类的构造方法");
}
public static void parentStaticMethod() {
System.out.println("父类的静态方法");
}
}
public class Childextends Parent {
{
System.out.println("子类非静态代码块");
}
static {
System.out.println("子类静态代码块");
}
public Child() {
System.out.println("子类的构造方法");
}
public static void childStaticMethod() {
System.out.println("子类的静态方法");
}
}
public static void main(String[]args) {
new Child();
}
结果：父类静态代码块
子类静态代码块
父类非静态代码块
父类的构造方法
子类非静态代码块
子类的构造方法
33、以下代码输出结果：
Strings1="abc";
Strings2="abc";
System.out.println(s1==s2);//TRUE
System.out.println(s1.equals(s2));//TRUE
Strings3=new String("abc");
System.out.println(s1==s3);//FALSE
System.out.println(s1.equals(s3));//TRUE
Integeri1=127;
Integeri2=127;
Integeri3=128;
Integeri4=128;
System.out.println(i1==i2);//TRUE
System.out.println(i3==i4);//FALSE
System.out.println(i3.equals(i4));//TRUE
Integeri5=new Integer(127);
System.out.println(i1==i5);//FALSE
【Integer常量池：-128-127】
34、下列程序输出值：（B）
public class A {
public A(){
System.out.println(1);
}
public A(Stringname){
System.out.println(2);
}
}
public class Bextends A {
public B(){
System.out.println(3);
}
public B(Stringname){
System.out.println(4);
}
}
public static void main(String[]args) {
Aa=new B("zhangsan");
}
A、4
B、1,4
C、2,4
D、3,4
【如果父类显式声明有参构造函数但没有显式声明无参构造函数，子类就不能显式声明无参构造函数，且子类的有参构造函数必须显示调用父类的有参构造函数（使用supper关键字），否则编译期错误；如果父类显式声明无参构造函数，子类构造函数在使用时必须在调用父类的无参构造函数之后才能执行本构造函数】
35、下列程序可以正确执行的是（E）
A、private synchronized Objecto;
B、void go(){
synchronized(){}
}
C、public void synchronized go(){}
D、private synchronized(this) go(){}
E、void go(){
synchronized(Object.class){}
}
F、void go(){
synchronized(o){}
}
36、子线程循环2次，接着主线程循环4，接着又回到子线程循环2次，接着再回到主线程又循环4，如此循环2次，请写出程序。
public class RunThread {
boolean runMain =false;
public synchronized void mainThread(int i) {
if (runMain)
try {
this.wait();
}catch (InterruptedExceptione) {
e.printStackTrace();
}
for (int j = 0;j < 4;j++) {
System.out.println(Thread.currentThread().getName());
}
runMain =true;
this.notify();
}
public synchronized void subThread(int i) {
if (!runMain)
try {
this.wait();
}catch (InterruptedExceptione) {
e.printStackTrace();
}
for (int j = 0;j < 2;j++) {
System.out.println(Thread.currentThread().getName());
}
runMain =false;
this.notify();
}
}
public static void main(String[]args) {
final RunThreadrunThread =new RunThread();
// Thread-0
new Thread(new Runnable() {
public void run() {
for (int i = 0;i < 3;i++) {
runThread.mainThread(i);
}
}
}).start();
// Thread-1
new Thread(new Runnable() {
public void run() {
for (int i = 0;i < 3;i++) {
runThread.subThread(i);
}
}
}).start();
}
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
