Java——送命面试题

69 阅读 0 评论 46 点赞

我是靠谱客的博主优秀音响，最近开发中收集的这篇文章主要介绍Java——送命面试题，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1、写出程序运行结果

interface A{}
class B implements A{
	public String func(){
		return "func";
	}
} 

public class Test{
	public static void main(String[] args){
		A a = new B();
		a.func();
		System.out.println(a.func());
	}
}

解：程序编译错误。A a = new B(); 编译看左边，运行看右边，父接口中没有func()方法，所以直接编译失败。

编译结果：

Test.java:11: 错误: 找不到符号
a.func();
^
符号:   方法 func()
位置: 类型为A的变量 a
Test.java:12: 错误: 找不到符号
System.out.println(a.func());
                                    ^
符号:   方法 func()
位置: 类型为A的变量 a
2 个错误

2、写出程序运行结果

class Fu{
	boolean show(char a){
		System.out.println(a);
		return true;
	}
}

public class Test extends Fu{
	public static void main(String[] args){
		int i = 0;
		Fu f = new Test();
		Test d = new Test();
		for(f.show('A');f.show('B')&&(i<2);f.show('C')){
			i++;
			d.show('D');
		}
	}
	boolean show(char a){
		System.out.println(a);
		return false;
	}
}

解：涉及多态与覆盖

编译结果：

A
B

3、写出程序运行结果

interface A{}
class B implements A{
	public String method(){
		return "yes";
	}
}

public class Test{
	static A get(){
		return new B();
	}
	
	public static void main(String[] args){
		A a = get();
		System.out.prinntln(a.method());
	}	
}

解：A a = get(); 相当于A a = new B(); 而A中没有method方法；编译失败，同第一问。

编译结果：Test.java:15: 错误: 找不到符号
System.out.println(a.method());
^
符号: 方法 method()
位置: 类型为A的变量 a
1 个错误

4、写出程序运行结果

class Super{
	int i = 0;
	public Super(String a){
		System.out.println("A");
		i = 1;
	}
	public Super(){
		System.out.println("B");
		i += 2;
	}
}

public class Test extends Super{
	public Test(String a){
		System.out.println("C");
		i += 5;
	}
	
	public static void main(String[] args){
		int i = 4;
		Super d = new Test("A");
		System.out.println(d.i);
	}	
}

解：因为默认子类构造方法中会有一个super() 而不是有参的super(a) ,除非自己写的时候可以定义，不然默认时总是调用父类的无参构造函数。

运行结果：

B
C
7

5、补充代码

interface Inter{
	void show(int a,int b);
	void func();
}

public class Test {	
	public static void main(String[] args){
		//补足代码，调用两个函数，要求用匿名内部类
	}	
}

解：接口指向匿名子类对象。

补充代码：

Inter in = new Inter(){
public void show(int a,int b){
//method
}
public void func(){
//method
}
};
in.show(1,2);
in.func();

6、写出程序运行结果

class TD{
	int y = 6;
	class Inner{
		static int y = 3;
		void show(){
			System.out.println(y);
		}
	}
}

public class Test {	
	public static void main(String[] args){
		TD.Inner ti = new TD().new Inner();
		ti.show();
	}
}

解：编译失败，非静态的内部类中不能定义静态的成员。静态内部类的静态方法可以直接通过类名访问，TD.Inner.show();

静态内部类的费静态方法可以new内部类对象再进行访问，

运行结果：Test.java:4: 错误: 内部类TD.Inner中的静态声明非法
static int y = 3;
^
修饰符 'static' 仅允许在常量变量声明中使用
1 个错误

知识点盲区：静态内部类,可以被new取决于你的静态类里面的方法:

7、

8、写出this关键字的含义，final关键字的特点？
解：

this：代表本类的对象。

初始化动作先执行，且构造函数间互相调用时，this(变量名)必须放第一行

构造函数间互相调用，即重载现象，要用this(变量名)。只有构造函数间能用this(变量名)语句，一般函数不行

final：是个修饰符。

1、可以修饰类，函数，变量。

2、final修饰的类，不可以被继承。

3、被final修饰的方法不可以被覆写。

4、被final修饰的变量是一个常量，（必须定义的时候被初始化），只能赋值一次，既可以修饰成员变量，又可以修饰局部变量

5、常量的书写规范，所有字母都是大写的。如果由多个单词组成，单词间用_连接。

9、写出程序运行结果

class Fu{
	int num = 4;
	void show(){
		System.out.println("showFu");
	}
}

class Zi extends Fu{
	int num = 5;
	void show(){
		System.out.println("showZi");
	}
}

public class Test {
	public static void main(String[] args){
		Fu f = new Zi();
		Zi zi = new Zi();
		System.out.println(f.num);
		System.out.println(zi.num);
		f.show();
		zi.show();	
	}
}

解：成员变量看左边，编译运行看左边；成员函数看左边编译，右边运行。

编译结果：

4
5
showZi
showZi

10、完成空余代码

interface A{
	void show();
}

interface B{
	void add(int a,int b);
}

class C implements A,B{
	//程序代码
}
public class Test {
	public static void main(String[] args){
		C c = new C();
		c.add(4,2);
		c.show(); //通过该函数打印以上两个数的和
	}
}

解：因为容易被方法名所误导，add并不一定要实现add的功能。当然也可以定义一个变量为sum,通过add求和之后在show中打印出sum。

答案： private int a,b;
public void add(int a,int b){
this.a = a;
this.b = b;
}

public void show(){
System.out.println(this.a + this.b);
}

11、写出程序运行结果

public class Test {
	public static void main(String[] args){
		try{
			showExce();
			System.out.println("A");
		} catch(Exception e){
			System.out.println("B");
		} finally {
			System.out.println("C");
		} 
		System.out.println("D");
	}
	public static void showExce() throws Exception{
		throw new Exception();
	}
}

解：从程序入口进去执行，首先进入showExce()方法。因为抛了异常，所以去处理异常，进入catch() ，输出B，接着处理好异常进入finally，没有出现任何问题当然也要输出D。

运行结果：

B
C
D

12、写出程序运行结果

class Super{
	int i = 0;
	
	public Super(String s){
		i = 1;
	}
}


public class Test extends Super{
	public Test(String s){		
		i = 2;
	}
	public static void main(String[] args){
		Test d = new Demo("yes");
		System.out.println(d.i);
	}
}

解：父类中没有空构造器，编译失败。

编译结果：Test.java:11: 错误: 无法将类 Super中的构造器 Super应用到给定类型;
public Test(String s){
^
需要: String
找到: 没有参数
原因: 实际参数列表和形式参数列表长度不同
Test.java:16: 错误: 找不到符号
Test d = new Demo("yes");
^
符号: 类 Demo
位置: 类 Test
2 个错误

13、写出程序运行结果

解：覆盖的返回类型不同，所以会编译失败。

编译结果：（未运行）编译失败

14、写出程序运行结果

public class Test{

	public static void func(){
		try{
			throw new Exception();
			System.out.println("A");
		}
		catch(Exception e){
			System.out.println("B");
		}
	}
	
	public static void main(String[] args){
		try{
			func();
		}
		catch(Exception e){
			System.out.println("C");
		}
		System.out.println("D");
	}
	

}

解：throw之后的任何语句都执行不到，必须转。

编译结果：Test.java:6: 错误: 无法访问的语句
System.out.println("A");
^
1 个错误

15、判断

16、写出程序运行结果

17、补足代码

interface Test{
	void func();
}

public class Test{
	public static void main(String[] args){
		//补足代码：（匿名内部类）
	}
	void show(Test t){
		t.func();
	}
}

补足代码如下：

new Test().show(new Demo(){
public void func(){
System.out.println("ok");
}
});

18、写出程序运行结果。

解：第一个输出语句，不抛异常，所以不进入catch；

第二个输出语句，抛出异常，所以在异常抛出的那一句开始跳转进入catch去捕捉处理异常。尽管里面有return语句，但是仍然会执行finally语句内的内容，最后 +="4" 是不执行的。同时注意：output是个静态常量。

19、写成程序运行结果

public class Test{
	private static int j = 0;
	
	private static boolean methodB(int k){
		j += k;
		return true;
	}
	
	public static void methodA(int i){
		boolean b;
		b = i < 10 | methodB(4);
		b = i < 10 || methodB(8);
	}
	
	public static void main(String[] args){
		methodA(0);
		System.out.println(j);
	}
}

解：考单或与双或的区别，| 都会执行，||检测到左边为真，则整个为真，不再检测右边

编译结果：4