第一部分 Java基础
第二部分 Java进阶

java基础语法面试题

 

1、String类可以被继承吗?

 

String类在声明时使用final关键字修饰,被final关键字修饰的类无法被继承。

接下来我们可以看一下String类的源代码片段:

 

public final class String
    implements java.io.Serializable, Comparable<String>,CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;

 

为什么Java语言的开发者,把String类定义为final的呢?

  • 因为只有当字符串是不可变的,字符串池才有可能实现。字符串池的实现可以在运行时节约很多heap空间,因为不同的字符串变量都指向池中的同一个字符串。但如果字符串是可变的,那么String interning将不能实现,因为这样的话,如果变量改变了它的值,那么其它指向这个值的变量的值也会一起改变。如果字符串是可变的,那么会引起很严重的安全问题。譬如,数据库的用户名、密码都是以字符串的形式传入来获得数据库的连接,或者在socket编程中,主机名和端口都是以字符串的形式传入。因为字符串是不可变的,所以它的值是不可改变的,否则黑客们可以钻到空子,改变字符串指向的对象的值,造成安全漏洞。
  • 因为字符串是不可变的,所以是多线程安全的,同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。
  • 因为字符串是不可变的,所以在它创建的时候HashCode就被缓存了,不需要重新计算。这就使得字符串很适合作为Map中的键,字符串的处理速度要快过其它的键对象。这就是HashMap中的键往往都使用字符串。

 

final关键字除了修饰类之外,还有哪些用法呢?

  • final修饰的变量,一旦赋值,不可重新赋值;
  • final修饰的方法无法被覆盖;
  • final修饰的实例变量,必须手动赋值,不能采用系统默认值;
  • final修饰的实例变量,一般和static联用,用来声明常量;

注意:final不能和abstract关键字联合使用。

总之,final表示最终的、不可变的。

 

 

2、& 和 && 的区别?

 

  • &运算符是:逻辑与;&&运算符是:短路与。
  • &和&&在程序中最终的运算结果是完全一致的,只不过&&存在短路现象,当&&运算符左边的表达式结果为false的时候,右边的表达式不执行,此时就发生了短路现象。如果是&运算符,那么不管左边的表达式是true还是false,右边表达式是一定会执行的。这就是他们俩的本质区别。
  • 当然,&运算符还可以使用在二进制位运算上,例如按位与操作。

 

 

 

3、两个对象值相同equals结果为true,但却可有不同的 hashCode,这句话对不对?

 

不对,如果两个对象x和y满足x.equals(y) == true,它们的哈希值(hashCode)应当相同。Java 对于equals方法和hashCode方法是这样规定的:

 

(1)如果两个对象相同(equals方法返回true),那么它们的hashCode值一定要相同;

 

(2)如果两个对象的 hashCode相同,它们并不一定相同。当然,你未必按照要求去做,但是如果你违背了上述原则就会发现在使用集合时,相同的对象可以出现在Set 集合中,同时增加新元素的效率会大大降低(对于使用哈希存储的系统,如果哈希码频繁的冲突将会造成存取性能急剧下降)。

 

关于equals和hashCode方法,很多Java程序员都知道,但很多人也就是仅仅了解而已,在Joshua Bloch的大作《Effective Java》(《Effective Java》在很多公司,是Java程序员必看书籍,如果你还没看过,那就赶紧去买一本吧)中是这样介绍 equals 方法的:

 

首先equals方法必须满足自反性(x.equals(x)必须返回true)、对称性(x.equals(y)返回true 时,y.equals(x)也必须返回true)、传递性(x.equals(y)和y.equals(z)都返回true时,x.equals(z)也必须返回true)和一致性(当x和y引用的对象信息没有被修改时,多次调用x.equals(y)应该得到同样的返回值),而且对于任何非null值的引用x,x.equals(null)必须返回false。实现高质量的equals方法的诀窍包括:

  • 使用==操作符检查"参数是否为这个对象的引用";
  • 使用 instanceof操作符检查"参数是否为正确的类型";
  • 对于类中的关键属性,检查参数传入对象的属性是否与之相匹配;
  • 编写完equals方法后,问自己它是否满足对称性、传递性、一致性;
  • 重写equals时总是要重写hashCode;
  • 不要将equals方法参数中的Object对象替换为其他的类型,在重写时不要忘掉@Override注解。

 

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

在最外层循环前加一个标记如outfor,然后用break outfor;可以跳出多重循环。例如以下代码:

 

public class TestBreak {
    public static void main(String[] args) {
        outfor: for (int i = 0; i < 10; i++){
            for (int j = 0; j < 10; j++){
                if (j == 5){
                    break outfor;
                }
                System.out.println("j = " + j);
            }
        }
    }
}

 

运行结果如下所示:

j = 0

j = 1

j = 2

j = 3

j = 4

 

5、重载(overload)和重写(override)的区别?重载的方法能否根据返回类型进行区分?

方法的重载和重写都是实现多态的方式,区别在于前者实现的是编译时的多态性,而后者实现的是运行时的多态性。

 

重载发生在一个类中,同名的方法如果有不同的参数列表(类型不同、个数不同、顺序不同)则视为重载。

 

重写发生在子类与父类之间,重写要求子类重写之后的方法与父类被重写方法有相同的返回类型,比父类被重写方法更好访问,不能比父类被重写方法声明更多的异常(里氏代换原则)。重载对返回类型没有特殊的要求。

 

方法重载的规则:

  • 方法名一致,参数列表中参数的顺序,类型,个数不同。
  • 重载与方法的返回值无关,存在于父类和子类,同类中。
  • 可以抛出不同的异常,可以有不同修饰符。

 

方法重写的规则:

  • 参数列表、方法名、返回值类型必须完全一致;
  • 构造方法不能被重写;
  • 声明为 final 的方法不能被重写;
  • 声明为 static 的方法不存在重写(重写和多态联合才有意义);
  • 访问权限不能比父类更低;
  • 重写之后的方法不能抛出更宽泛的异常;

 

6、当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里是值传递还是引用传递?

是值传递。Java 语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时,参数的值就是对该对象的内存地址。这个值(内存地址)被传递后,同一个内存地址指向堆内存当中的同一个对象,所以通过哪个引用去操作这个对象,对象的属性都是改变的。

 

7、为什么方法不能根据返回类型来区分重载?

我们来看以下的代码:

 

public void testMethod(){
    doSome();
}
public void doSome(){
    
}
public int doSome(){
    return 1;
}

 

在Java语言中,调用一个方法,即使这个方法有返回值,我们也可以不接收这个返回值,例如以上两个方法doSome(),在testMethod()中调用的时候,Java编译器无法区分调用的具体是哪个方法。所以对于编译器来说,doSome()方法不是重载而是重复了,编译器报错。所以区分这两个方法不能依靠方法的返回值类型。

 

8、抽象类(abstract class)和接口(interface)有什么异同?

 

都不能。

  • 抽象方法需要子类重写,而静态的方法是无法被重写的,因此二者是矛盾的。
  • 本地方法是由本地代码(如 C++ 代码)实现的方法,而抽象方法是没有实现的,也是矛盾的。
  • synchronized 和方法的实现细节有关,抽象方法不涉及实现细节,因此也是相互矛盾的。

 

9、char 型变量中能不能存储一个中文汉字,为什么?

char 类型可以存储一个中文汉字,因为Java中使用的编码是Unicode(不选择任何特定的编码,直接使用字符在字符集中的编号,这是统一的唯一方法),一个char 类型占2个字节(16 比特),所以放一个中文是没问题的。

 

补充:使用Unicode 意味着字符在JVM内部和外部有不同的表现形式,在JVM内部都是 Unicode,当这个字符被从JVM内部转移到外部时(例如存入文件系统中),需要进行编码转换。所以 Java 中有字节流和字符流,以及在字符流和字节流之间进行转换的转换流,如 InputStreamReader和OutputStreamReader,这两个类是字节流和字符流之间的适配器类,承担了编码转换的任务。

 

10、抽象的(abstract)方法是否可同时是静态的(static), 是否可同时是本地方法(native),是否可同时被 synchronized?

 

都不能。

  • 抽象方法需要子类重写,而静态的方法是无法被重写的,因此二者是矛盾的。
  • 本地方法是由本地代码(如 C++ 代码)实现的方法,而抽象方法是没有实现的,也是矛盾的。
  • synchronized 和方法的实现细节有关,抽象方法不涉及实现细节,因此也是相互矛盾的。

 

11、==和equals的区别?

equals和==最大的区别是一个是方法一个是运算符。

  • ==:如果比较的对象是基本数据类型,则比较的是数值是否相等;如果比较的是引用数据类型,则比较的是对象的地址值是否相等。
  • equals():用来比较方法两个对象的内容是否相等。equals方法不能用于基本数据类型的变量,如果没有对equals方法进行重写,则比较的是引用类型的变量所指向的对象的地址。

 

12、阐述静态变量和实例变量的区别?

不管创建多少个对象,静态变量在内存中有且仅有一个;实例变量必须依存于某一实例,需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对象共享内存。

 

13、break和continue的区别?

  • break和continue 都是用来控制循环的语句。
  • break 用于完全结束一个循环,跳出循环体执行循环后面的语句。

continue 用于跳过本次循环,继续下次循环。

 

14、String s = "Hello";s = s + " world!";这两行代码执行后,原始的 String 对象中的内容变了没有?

没有。

因为 String被设计成不可变类,所以它的所有对象都是不可变对象。

 

在这段代码中,s原先指向一个 String 对象,内容是 "Hello",然后我们对 s 进行了“+”操作,那么 s 所指向的那个对象是否发生了改变呢?

 

答案是没有。这时s不指向原来那个对象了,而指向了另一个 String 对象,内容为"Hello world!",原来那个对象还存在于内存之中,只是 s 这个引用变量不再指向它了。

 

通过上面的说明,我们很容易导出另一个结论,如果经常对字符串进行各种各样的修改,或者说,不可预见的修改,那么使用 String 来代表字符串的话会引起很大的内存开销。因为 String 对象建立之后不能再改变,所以对于每一个不同的字符串,都需要一个 String 对象来表示。这时,应该考虑使用 StringBuffer/StringBuilder类,它允许修改,而不是每个不同的字符串都要生成一个新的对象。并且,这两种类的对象转换十分容易。同时,我们还可以知道,如果要使用内容相同的字符串,不必每次都 new 一个 String。例如我们要在构造器中对一个名叫 s 的 String 引用变量进行初始化,把它设置为初始值,应当这样做:

s = new String("动力节点,口口相传的Java黄埔军校");

而不是这样做:

  s = new String("动力节点,口口相传的Java黄埔军校");

后者每次都会调用构造器,生成新对象,性能低下且内存开销大,并且没有意义,因为 String 对象不可改变,所以对于内容相同的字符串,只要一个 String 对象来表示就可以了。也就说,多次调用上面的构造器创建多个对象,他们的 String 类型属性 s 都指向同一个对象。

 

上面的结论还基于这样一个事实:对于字符串常量,如果内容相同,Java 认为它们代表同一个 String 对象。而用关键字 new 调用构造器,总是会创建一个新的对象,无论内容是否相同。

 

至于为什么要把 String 类设计成不可变类,是它的用途决定的。其实不只String,很多 Java 标准类库中的类都是不可变的。在开发一个系统的时候,我们有时候也需要设计不可变类,来传递一组相关的值,这也是面向对象思想的体现。不可变类有一些优点,比如因为它的对象是只读的,所以多线程并发访问也不会有任何问题。当然也有一些缺点,比如每个不同的状态都要一个对象来代表,可能会造成性能上的问题。所以 Java 标准类库还提供了一个可变版本,即 StringBuffer。

全部教程