常见面试题整理（一）之Java基础

1.重载和重写的区别

重载： 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时

重写： 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能重写该方法

2. String和 StringBuffer、StringBuilder的区别是什么？String为什么是不可变的？

可变性

简单的来说：String 类中使用 final 关键字字符数组保存字符串，private final char value[] ，所以 String对象是不可变的

StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder中也是使用字符数组保存字符串 char[]value 但是没有用 final 关键字修饰，所以这两种对象都是可变的

StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是 AbstractStringBuilder 实现的

abstract class AbstractStringBuilder implements Appendable, CharSequence { 
    char[] value; 
    int count; 
    AbstractStringBuilder() { 
    }
    AbstractStringBuilder(int capacity) { 
        value = new char[capacity]; 
    }

线程安全性

String 中的对象是不可变的，也就可以理解为常量，线程安全

AbstractStringBuilder 是 StringBuilder 与StringBuffer 的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf 等公共方法

StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的

StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的

性能

每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象

StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用

相同情况下使用StirngBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险

对于三者使用的总结：

1） 操作少量的数据 = String

2）单线程操作字符串缓冲区下操作大量数据 = StringBuilder

3）多线程操作字符串缓冲区下操作大量数据 = StringBuffer

3. == 与 equals

== : 它的作用是判断两个对象的地址是不是相等

equals() : 它的作用也是判断两个对象是否相等

但它一般有两种使用情况：

1）类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象

2）类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来两个对象的内容相等；若它们的内容相

等，则返回 true (即，认为这两个对象相等)

举例：

public class test1 { 
    
    public static void main(String[] args) { 
        
        String a = new String("ab"); // a 为一个引用 
        String b = new String("ab"); // b为另一个引用,对象的内容一样 
        String aa = "ab"; // 放在常量池中 
        String bb = "ab"; // 从常量池中查找 
        if (aa == bb) // true 
            System.out.println("aa==bb"); 
        if (a == b) // false，非同一对象 
            System.out.println("a==b"); 
        if (a.equals(b)) // true 
            System.out.println("aEQb"); 
        if (42 == 42.0) { // true 
            System.out.println("true"); 
        } 
    } 
}

String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的equals 方法比较的是对象的值

当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象

4.关于final

final关键字主要用在三个地方：变量、方法、类

1） 对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；

如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象

2）当用final修饰一个类时，表明这个类不能被继承

final类中的所有成员方法都会被隐式地指定为final方法

3）使用final方法的原因有两个

a）把方法锁定，以防任何继承类修改它的含义

b）效率

在早期的Java实现版本中，会将final方法转为内嵌调用

但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）

类中所有的private方法都隐式地指定为final

5.Object类的常见方法

//native方法，用于返回当前运行时对象的Class对象，使用了 final关键字修饰，故不允许子类重写
public final native Class<?> getClass() 
    
//native方法，用于返回对象的哈希码，主要使用在哈希表中，比如JDK中的HashMap    
public native int hashCode() 
    
//用于比较2个对象的内存地址是否相等，String类对该方法进行了重写用户 比较字符串的值是否相等    
public boolean equals(Object obj)

//naitive方法，用于创建并返回 当前对象的一份拷贝
//一般情况下，对于任何对象 x，表达式 x.clone() != x 为true，x.clone().getClass() == x.getClass() 为true
//Object本身没有实现Cloneable接口，所以不重写clone方法并且进行调用的话会发生 CloneNotSupportedException异常     
protected native Object clone() throws CloneNotSupportedException

//返回类的名字@实例的哈希码的16进制的字符串。建议Object所有的子类都重写这个方法    
public String toString()

//native方法，并且不能重写。唤醒一个在此对象监视器上等待的线程(监视 器相当于就是锁的概念)
//如果有多个线程在等待只会任意唤醒一个    
public final native void notify()
    
//native方法，并且不能重写,跟notify一样，唯一的区别就是会唤醒 在此对象监视器上等待的所有线程，而不是一个线程
public final native void notifyAll()
    
//native方法，并且不能重写。暂停线程的执行
//注意：sleep方法没有释放锁，而wait方法释放了锁 。timeout是等待时间
public final native void wait(long timeout) throws InterruptedException

//多了nanos参数，这个参数表示额外时间（以毫微秒为单位，范围是0-999999）
//所以超时的时间还需要加上nanos毫秒
public final void wait(long timeout, int nanos) throws InterruptedException

//跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间这个概念   
public final void wait() throws InterruptedException

//实例被垃圾回收器回收的时候触发的操作
protected void finalize() throws Throwable {}

6. Java中的异常处理

Java异常类层次结构图：

在Java中Throwable是所有异常的祖先类

Throwable有两个重要的子类：

Exception（异常）和Error（错误）

Error：

是程序无法处理的错误，表示运行应用程序中较严重问题

大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题

例如，Java虚拟机运行错误（Virtual MachineError），当JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止，这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（VirtualMachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述

Exception：

是程序本身可以处理的异常，Exception 类有一个重要的子类 RuntimeException，RuntimeException 异常由Java虚拟机抛出

NullPointerException（要访问的变量没有引用任何对象时，抛出该异常）

ArithmeticException（算术运算异常，一个整数除以0时，抛出该异常）和ArrayIndexOutOfBoundsException （下标越界异常）

注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理

Throwable类常用方法：

public string getMessage():返回异常发生时的详细信息

public string toString():返回异常发生时的简要描述

public string getLocalizedMessage():返回异常对象的本地化信息

使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同

public void printStackTrace():在控制台上打印Throwable对象封装的异常信息

异常处理总结：

try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块

catch 块：用于处理try捕获到的异常

finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行

在以下4种情况finally块不会被执行

1）在finally语句块中发生了异常

2）在前面的代码中用了System.exit()退出程序

3）程序所在的线程死亡

4）关闭CPU

7.接口和抽象类的区别是什么

1）接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现），抽象类可以

有非抽象的方法

2） 接口中的实例变量默认是 fifinal 类型的，而抽象类中则不一定

3）一个类可以实现多个接口，但最多只能实现一个抽象类

4）一个类实现接口的话要实现接口的所有方法，而抽象类不一定

5）接口不能用 new 实例化，但可以声明，但是必须引用一个实现该接口的对象 从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范

备注:在JDK8中接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。如果同时实现两个接口，接口中定义了一样的默认方法，必须重写，不然会报错

此处整理来自JavaGuide