面试篇(JavaSE)：基础部分

# 重载和重写的区别（了解）

重载: 发生在同一个类中，方法名必须相同，参数类型不同，个数不同，顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。
重写: 发生在父子类中，方法名，参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能重写该方法。

# String 和 StringBuffer,StringBuilder 的区别是什么？String 为什么是不可变的

可变性

简单的来说：

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

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

StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是 AbstractStringBuilder 实现的，大家可以自行查阅源码。

AbstractStringBuilder.java
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 并没有对方法进行加同步锁，所以是非线程安全的。

性能

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

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

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

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

对于使用三者的总结:

操作少量的数据 => 使用String
单线程操作字符串缓冲区下操作大量数据 => 使用StringBuilder
多线程操作字符串缓冲区下操作大量数据 => 使用StringBuffer

# 自动装箱和拆箱 (了解)

装箱: 将基本类型用它们对应的引用类型包装起来；
拆箱: 将包装类型转换为基本数据类型；

# == 与 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 对象。

# 关于 final 关键字的一些总结

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

对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。
使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。

在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。

# 接口和抽象类的区别是什么(必会)

接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现），抽象类可以有非抽象的方法。
接口中的实例变量默认是 final 类型的，而抽象类中则不一定。
一个类可以实现多个接口，但最多只能实现一个抽象类。
一个类实现接口的话要实现接口的所有方法，而抽象类不一定。
接口不能用 new 实例化，但可以声明，但是必须引用一个实现该接口的对象从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。

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

Yu's Blog