黑马程序员--Java学习日记之面试问题汇总,感谢黑马论坛!

来源：互联网发布：商城网站怎么优化编辑：程序博客网时间：2024/05/02 00:05

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。

2、Java中有没有goto？

Java的保留字，现在没有在Java中使用。

3、&和&&的区别

&和&&都可以用作逻辑与的运算符，&还可以作为位运算符。
用作逻辑与运算符的时候，&&有短路功能，即如果第一个表达式为false，则不再计算第二个表达式。&没有短路功能。

4、在Java中如何跳出当前的多重嵌套循环？

在循环外面设标号，然后在循环里面使用带标号的break

ok: for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
System.out.println("i=" + i + ",j=" + j);
if (j == 5)
break ok;
}
}

另外一种是在外层循环添加条件表达式来达到跳出多重循环

int arr[][] = { { 1, 2, 3 }, { 4, 5, 6, 7 }, { 9 } };
boolean found = false;
for (int i = 0; i < arr.length && !found; i++) {
for (int j = 0; j < arr.length; j++) {
System.out.println("i=" + i + ",j=" + j);
if (arr[j] == 5) {
found = true;
break;
}
}
}

5、switch语句能否作用在byte上，能否作用在long上，能否作用在String上?

在switch（expr1）中，expr1只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型。
由于byte,short,char都可以隐含转换为int，所以这些类型以及这些类型的包装类型也是可以的。

由于long,String不能隐含转换为int，所以不能使用switch语句。

6、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

short s1 = 1; s1 = s1 + 1;有错。short s1 = 1; s1 += 1没错。
short s1 = 1; s1 = s1 + 1;有错是因为s1 + 1结果是int型，编译器将报告需要强制转换类型的错误。
short s1 = 1; s1 += 1没错是因为+=是Java语言规定的运算符，Java编译器会对它进行特殊处理，因此可以正确编译。

7、char型变量中能不能存贮一个中文汉字?为什么?

能。char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字。但是如果有一个特殊的汉字没有被包含在Unicode编码中，就不能存在char型变量中。
补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

8、用最有效率的方法算出2乘以8等於几?

2 << 3。因为将一个数左移n位，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可。而位运算cpu直接支持的，效率最高。

9、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

引用不能变，引用的变量还是可以变的。
final StringBuffer strBuffer =new StringBuffer("Hello");
执行如下语句将报告编译期错误：
strBuffer=new StringBuffer("");
但是，执行如下语句则可以通过编译：
strBuffer.append("world！");
所以，有人在定义方法的参数时，想采用如下形式来阻止方法内部修改传进来的参数对象：
public void method(final StringBuffer param) {
}
实际上，这是办不到的。因为仍然可以执行这样的代码：param.append("world！");

10、静态变量和实例变量的区别？

实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。
静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。

11、在静态方法中可以调用非静态的方法和变量吗？

不能！因为静态方法又称类方法，不需要创建具体的类的实例就可以直接调用，而非静态的方法和变量是需要创建类的具体实例才可以被使用的。试想一下我们直接通过类来调用一个静态方法，而这个静态方法里面又调用了一个非静态的方法或变量，结果会如何？那个非静态的方法或变量会说：“你给我一个类的实例，我就让你调用我，不然休想”。所以静态方法你里面不可以调用非静态的方法和变量。

12、抽象类和接口有什么区别？

抽象类和接口都不可以直接创建实例，抽象类必须被继承了才能创建实例，接口必须被实现了才能创建实例。区别如下：抽象类和接口都可以定义变量（接口中定义变量很少用），抽象类中变量的定义和普通类一样，接口中的变量默认是public static final类型的，并且只能是public static final类型的。

抽象类可以有构造方法，接口中不能有构造方法。
抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的。
抽象类中的抽象方法可以是public和protected，而接口中的抽象方法只能是public的。
一个类可以实现多个接口，但只能继承一个抽象类。

13、抽象方法能不能用static修饰

不能。static不能于abstract连用。因为abstract的语义就是说这个方法是多态方法，需要subclass的实现。而static方法则是在本类中实现的，编译期绑定，不具有多态行为。

14、下面程序的输出结果是多少？

import java.util.Date;
public class Test extends Date {
public static void main(String[] args) {
new Test().test();
}
public void test() {
System.out.println(super.getClass().getName());
}
}

答案是：Test。这道题是一道脑经急转弯题。如果是getClass.getName();你会毫不犹豫的说答案是Test，由于getClass()在Object类中定义成了final，子类不能覆盖该方法，所以，在test方法中调用getClass().getName()方法，其实就是在调用从父类继承的getClass()方法，等效于调用super.getClass().getName()方法，所以，super.getClass().getName()方法返回的也应该是Test。如果想得到父类的名称，应该用这个代码：getClass().getSuperClass().getName();

15、String str = “str01”; str = "str02"; 着两行代码执行之后，str一开始所指向的对象改变了没有？

没有。如果是一般的对象（比如说Student），那么指向的对象的值肯定改变了。但是这里的String虽然是引用类型，但是它是特殊的引用类型，String所指向的对象都存储在常量池里面，而常量池里面的常量是不可以改变的。所以，只是指针的指向改变了

16、String str = new String("xyz"); 创建了几个String Object？

一个或两个。"xyz"对应一个对象，这个对象放在字符串常量缓冲区（也就是常量池），常量"xyz"不管出现多少遍，都是缓冲区中的那一个。如果以前没有用过"xyz"，那么就会创建一个丢进常量池，如果以前用过的话，常量池中就有了，不用在创建了。new String也创建出来一个对象。所以是一个或两个。

17、StringBuffer与StringBuilder的区别？

StringBuffer和StringBuilder都是可变长字符串，StringBuffer效率底，线程安全，StringBuilder效率高，线程不安全。如果要在一个方法里面定义可变长字符串，那么选取StringBuilder，因为只可能有一个线程访问它，不存在线程安不安全的问题。如果要定义类的成员变量，并且这个类的实例对象会在多线程环境下使用，那么最好用StringBuffer。

18、下面这条语句一共创建了多少个对象：String s="a"+"b"+"c"+"d";

1个。也许觉得很奇怪，为什么是一个呢？先看下面的一个例子：

String s1 = "a";
String s2 = s1 + "b";
String s3 = "a" + "b";
System.out.println(s2 == "ab");
System.out.println(s3 == "ab");

打印结果：

false

true

这说明：javac编译可以对字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。

也就是说：String s3 = "a" + "b";就相当于String s3 = "ab";

所以String s="a"+"b"+"c"+"d";就相当于String s="abcd";，只创建了一个对象。

public class Test {
public static void main(String[] args) {
System.out.println(test());
}
private static int test() {
try {
return 1;
} finally {
return 2;
}
}
}

答案：2。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中。

20、Java中父类和子类强转的问题

public class A {
public static void main(String[] args){
A a = new A();
B b = (B)a; //执行该语句会抛ClassCastException异常。

B b2 = new B();
a = (A)b2;
System.out.println("success");
}
}
class B extends A{
}
子类由于比父类拥有了更多的特性，所以当你想将父类强制转化为其一个子类的时候，编译没有错误，但在运行时就会抛异常。反之，则可以。
这就是所谓的向上转型，多态。

21、Java中父类和子类强转的问题

下面的程序
1. public class GC {
2.    private Object o;
3.    private void doSomethingElse(Object obj) { o = obj; }
4.    public void doSomething() {
5.       Object o = new Object();
6.       doSomethingElse(o);
7.       o = new Object();
8.       doSomethingElse(null);
9.       o = null;
10. }
11. }

请问，当调用doSomething的时候。执行到第几行，第5行生成的实例o就又成为了垃圾回收的可能对象。
A. Line 5
B. Line 6
C. Line 7
D. Line 8
E. Line 9
F. Line 10
答案：D。为什么不是C呢？因为第七行的o指的是局部变量o，不是成员变量o。

22、以下代码的执行结果是？

import java.util.*;
public class ArrayCompare {
public static void main(String[] args) {
      int[] array1 = new int[6];
      int[] array2 = new int[6];
      Arrays.fill(array1, 12);
      Arrays.fill(array2, 12);
      System.out.println(Arrays.equals(array1, array2));
      array2[3] = 11;
      System.out.println(Arrays.equals(array1, array2));
      String[] array3 = new String[5];
      Arrays.fill(array3, new String("Test"));
      String[] array4 = {"Test", "Test", "Test", "Test", "Test"};
      System.out.println(Arrays.equals(array3, array4));
}
}

A.true, true, true
B.true, false, true
C.true, false, false
D.false, false, false
答案：B。Arrays.equals是比较两个数组的个数是否相等，并且对应位置上的值是否相等（用equals比较）

23、有5行语句：

①char c1 = '1';
②char c2 = '2';
③char c3 = '1'+'2';
④char c4 = c1+c2;
⑤char c5 = (char)(c1+c2);
下列说法正确的是：
A：①②③④⑤编译、运行都不会出错
B：①②③⑤编译、运行都不会出错；④编译出错
C：①②⑤编译、运行都不会出错；③④编译出错
D：①②③⑤编译、运行都不会出错；④编译不会出错，但运行会出错
答案：B。'1'+'2'是在编译期间就可以确定的常量，所以能够确定是哪个char，从而自动转换为char。但是c1 + c2在编译期间确定不了它的值，只能在运行期间确定，所以需要强制转换，如果不强制转换，编译器就认为语句是错的。

24、下面一段代码是关于Integer的比较，打印结果是什么？

public class Test {
public static void main(String[] args) {
      Integer i1 = 127;
      Integer i2 = 127;
      Integer i3 = Integer.valueOf(127);
      System.out.println(i1 == i2);
      System.out.println(i1 == i3);
      System.out.println(i1.equals(i3));
      i1 = 128;
      i2 = 128;
      i3 = Integer.valueOf(128);
      System.out.println(i1 == i2);
      System.out.println(i1 == i3);
      System.out.println(i1.equals(i3));
}
}

答案：
true
true
true
false
false
true

解析：Integer i1 = 127;会被自动转成Integer i1 = Integer.valueOf(127); 看看valueOf的源码

public static Integer valueOf(int i) {
if (i < -128 || i > 127) {
      return new Integer(i);
}
return valueOfCache.CACHE [i+128];

}

可以看到根据值的不同，决定是否重新创建对象。

　　                          ——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

0 0