Java面试题-JavaSE基础1

一、Java 面向对象

1. 面向对象都有哪些特性以及你对这些特性的理解
   1）继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。

   2） 封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口。

   3） 多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当 A 系统访问 B 系统提供的服务时，B 系统有多种提供服务的方式，但一切对 A 系统来说都是透明的。方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：1. 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；2. 对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

   4）抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。
   注意：默认情况下面向对象有 3 大特性，封装、继承、多态，如果面试官问让说出 4 大特性，那么我们就把抽象加上去。

二、JavaSE 语法

1. Java 有没有 goto 语句？
   goto 是 Java 中的保留字，在目前版本的 Java 中没有使用。根据 James Gosling（Java 之父）编写的《The Java Programming Language》一书的附录中给出了一个 Java 关键字列表，其中有 goto 和 const，但是这两个是目前无法使用的关键字，因此有些地方将其称之为保留字，其实保留字这个词应该有更广泛的意义，因为熟悉 C 语言的程序员都知道，在系统类库中使用过的有特殊意义的单词或单词的组合都被视为保留字。
2. & 和 && 的区别
   &运算符有两种用法：(1)按位与；(2)逻辑与。
   &&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是true 整个表达式的值才是 true。
   &&之所以称为短路运算是因为，如果&&左边的表达式的值是 false，右边的表达式会被直接短路掉，不会进行运算。很多时候我们可能都需要用&&而不是&，例如在验证用户登录时判定用户名不是 null 而且不是空字符串，应当写为 username != null &&!username.equals("")，二者的顺序不能交换，更不能用&运算符，因为第一个条件如果不成立，根本不能进行字符串的 equals 比较，否则会产生 NullPointerException 异常。注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。
3. 在 Java 中，如何跳出当前的多重嵌套循环
   在最外层循环前加一个标记如 A，然后用 break A;可以跳出多重循环。（Java 中支持带标签的 break 和 continue 语句，作用有点类似于 C 和 C++中的 goto 语句，但是就像要避免使用 goto 一样，应该避免使用带标签的 break 和 continue，因为它不会让你的程序变得更优雅，很多时候甚至有相反的作用）。
4. 两个对象值相同 (x.equals(y) == true) ，但却可有不同的 hashCode，这句话对不对？
   不对，如果两个对象 x 和 y 满足 x.equals(y) == true，它们的哈希码（hashCode）应当相同。
   Java 对于 eqauls 方法和 hashCode 方法是这样规定的：(1)如果两个对象相同（equals 方法返回 true），那么它们的 hashCode 值一定要相同；(2)如果两个对象的 hashCode 相同，它们并不一定相同。当然，你未必要按照要求去做，但是如果你违背了上述原则就会发现在使用容器时，相同的对象可以出现在 Set 集合中，同时增加新元素的效率会大大下降（对于使用哈希存储的系统，如果哈希码频繁的冲突将会造成存取性能急剧下降）。
   关于 equals 和 hashCode 方法，很多 Java 程序员都知道，但很多人也就是仅仅知道而已，在 Joshua Bloch的大作《Effective Java》（很多软件公司，《Effective Java》、《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 方法的诀窍包括：1. 使用==操作符检查"参数是否为这个对象的引用"；2. 使用 instanceof 操作符检查"参数是否为正确的类型"；3. 对于类中的关键属性，检查参数传入对象的属性是否与之相匹配；4. 编写完 equals 方法后，问自己它是否满足对称性、传递性、一致性；5. 重写 equals 时总是要重写hashCode；6. 不要将 equals 方法参数中的 Object 对象替换为其他的类型，在重写时不要忘掉@Override 注解。
5. 是否可以继承 String ?
   String 类是 final 类，不可以被继承。
   继承 String 本身就是一个错误的行为，对 String 类型最好的重用方式是关联关系（Has-A）和依赖关系（UseA）而不是继承关系（Is-A）。
6. 当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
   是值传递,Java 语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时，参数的是值传递。Java 语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变，但对对象引用的改变是不会影响到调用者的。C++和 C#中可以通过传引用或传输出参数来改变传入的参数的值。说明：Java 中没有传引用实在是非常的不方便，这一点在 Java 8 中仍然没有得到改进，正是如此在 Java 编写的代码中才会出现大量的Wrapper 类（将需要通过方法调用修改的引用置于一个 Wrapper 类中，再将 Wrapper 对象传入方法），这样的做法只会让代码变得臃肿，尤其是让从 C 和 C++转型为 Java 程序员的开发者无法容忍。
7. 重载（overload）和重写（override）的区别？重载的方法能否根据返回类型进行区分？
   方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求。
   方法重载的规则：
   1.方法名一致，参数列表中参数的顺序，类型，个数不同。
   2.重载与方法的返回值无关，存在于父类和子类，同类中。
   3.可以抛出不同的异常，可以有不同修饰符。
   方法重写的规则：
   1.参数列表必须完全与被重写方法的一致，返回类型必须完全与被重写方法的返回类型一致。
   2.构造方法不能被重写，声明为 final 的方法不能被重写，声明为 static 的方法不能被重写，但是能够被再次声明。
   3.访问权限不能比父类中被重写的方法的访问权限更低。
   4.重写的方法能够抛出任何非强制异常（UncheckedException，也叫非运行时异常），无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
8. 为什么函数不能根据返回类型来区分重载？
   该道题来自华为面试题。
   因为调用时不能指定类型信息，编译器不知道你要调用哪个函数。
   例如：
   1．float max(int a, int b);
   2．int max(int a, int b);
   当调用 max(1, 2);时无法确定调用的是哪个，单从这一点上来说，仅返回值类型不同的重载是不应该允许的。
   再比如对下面这两个方法来说，虽然它们有同样的名字和自变量，但其实是很容易区分的：
   1．void f() {}
   2．int f() {}
   若编译器可根据上下文（语境）明确判断出含义，比如在 int x=f()中，那么这样做完全没有问题。然而，我们也可能调用一个方法，同时忽略返回值；我们通常把这称为“为它的副作用去调用一个方法”，因为我们关心的不是返回值，而是方法调用的其他效果。所以假如我们像下面这样调用方法： f(); Java 怎样判断 f()的具体调用方式呢？而且别人如何识别并理解代码呢？由于存在这一类的问题，所以不能。
   函数的返回值只是作为函数运行之后的一个“状态”，他是保持方法的调用者与被调用者进行通信的关键。并不能作为某个方法的“标识”。
9. char 型变量中能不能存储一个中文汉字，为什么？
   char 类型可以存储一个中文汉字，因为 Java 中使用的编码是 Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个 char 类型占 2 个字节（16 比特），所以放一个中文是没问题的。
   补充：使用 Unicode 意味着字符在 JVM 内部和外部有不同的表现形式，在 JVM 内部都是 Unicode，当这个字符被从 JVM 内部转移到外部时（例如存入文件系统中），需要进行编码转换。所以 Java 中有字节流和字符流，以及在字符流和字节流之间进行转换的转换流，如 InputStreamReader 和OutputStreamReader，这两个类是字节流和字符流之间的适配器类，承担了编码转换的任务；对于 C 程序员来说，要完成这样的编码转换恐怕要依赖于union（联合体/共用体）共享内存的特征来实现了。
10. 抽象类(abstract class)和接口(interface)有什么异同？（2017-11-16-wl）
    不同：
    抽象类：
    1.抽象类中可以定义构造器
    2.可以有抽象方法和具体方法
    3.接口中的成员全都是 public 的
    4.抽象类中可以定义成员变量
    5.有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法
    6.抽象类中可以包含静态方法
    7.一个类只能继承一个抽象类
    接口：
    1.接口中不能定义构造器
    2.方法全部都是抽象方法
    3.抽象类中的成员可以是 private、默认、protected、public
    4.接口中定义的成员变量实际上都是常量
    5.接口中不能有静态方法
    6.一个类可以实现多个接口
    相同：
    1.不能够实例化
    2.可以将抽象类和接口类型作为引用类型
    3.一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。
11. 抽象的(abstract)方法是否可同时是静态的(static), 是否可同时是本地方法
    (native)，是否可同时被 synchronized
    都不能。抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的。本地方法是由本地代码（如 C 代码）实现的方法，而抽象方法是没有实现的，也是矛盾的。synchronized 和方法的实现细节有关，抽象方法不涉及实现细节，因此也是相互矛盾的。
12. 阐述静态变量和实例变量的区别？
    静态变量: 是被 static 修饰符修饰的变量，也称为类变量，它属于类，不属于类的任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个拷贝；
    实例变量: 必须依存于某一实例，需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对象共享内存。
13. ==和 equals 的区别？（面试时问的频率很高）
    equals 和== 最大的区别是一个是方法一个是运算符。
    ==：如果比较的对象是基本数据类型，则比较的是数值是否相等；如果比较的是引用数据类型，则比较的是对象的地址值是否相等。
    equals()：用来比较方法两个对象的内容是否相等。
    注意：equals 方法不能用于基本数据类型的变量，如果没有对 equals 方法进行重写，则比较的是引用类型的变量所指向的对象的地址。
14. break 和 continue 的区别？
    break 和 continue 都是用来控制循环的语句。
    break 用于完全结束一个循环，跳出循环体执行循环后面的语句。
    continue 用于跳过本次循环，执行下次循环。
15. String s = “Hello”;s = s + " world!";这两行代码执行后，原始的 String 对象
    中的内容到底变了没有？
    没有。因为 String 被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s 原先指向一个 String 对象，内容是 “Hello”，然后我们对 s 进行了“+”操作，那么 s 所指向的那个对象是否发生了改变呢？
    答案是没有。这时，s 不指向原来那个对象了，而指向了另一个 String 对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是 s 这个引用变量不再指向它了。
    通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用 String 来代表字符串的话会引起很大的内存开销。因为 String 对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个 String 对象来表示。这时，应该考虑使用StringBuffer 类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都 new 一个 String。例如我们要在构造器中对一个名叫 s 的 String 引用变量进行初始化，把它设置为初始值，应当这样做：
    1．public class Demo {
    2． private String s;
    3． …
    4． s = “Initial Value”;
    5． …
    6．}
    而非
    1．s = new String(“Initial Value”);
    后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为 String 对象不可改变，所以对于内容相同的字符串，只要一个 String 对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的 String 类型属性 s 都指向同一个对象。
    上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java 认为它们代表同一个 String 对象。而用关键字 new 调用构造器，总是会创建一个新的对象，无论内容是否相同。 至于为什么要把 String 类设计成不可变类，是它的用途决定的。其实不只 String，很多 Java 标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以 Java 标准类库还提供了一个可变版本，即 StringBuffer。

三、Java 中的多态

1. Java 中实现多态的机制是什么？
   靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

四、Java 的异常处理

1. Java 中异常分为哪些种类
   1）按照异常需要处理的时机分为编译时异常（也叫强制性异常）也叫CheckedException 和运行时异常（也叫非强制性异常）也叫RuntimeException。只有 java 语言提供了 Checked 异常，Java 认为 Checked异常都是可以被处理的异常，所以 Java 程序必须显式处理 Checked 异常。如果程序没有处理 Checked 异常，该程序在编译时就会发生错误无法编译。这体现了 Java 的设计哲学：没有完善错误处理的代码根本没有机会被执行。对 Checked 异常处理方法有两种：
   1 当前方法知道如何处理该异常，则用 try…catch 块来处理该异常。
   2 当前方法不知道如何处理，则在定义该方法是声明抛出该异常。
   运行时异常只有当代码在运行时才发行的异常，编译时不需要 try catch。Runtime 如除数是 0 和数组下标越界等，其产生频繁，处理麻烦，若显示申明或者捕获将会对程序的可读性和运行效率影响很大。所以由系统自动检测并将它们交给缺省的异常处理程序。当然如果你有处理要求也可以显示捕获它们。
2. error 和 exception 的区别？
   Error 类和 Exception 类的父类都是 Throwable 类，他们的区别如下。
   Error 类一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢出等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。
   Exception 类表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。Exception 类又分为运行时异常（Runtime Exception）和受检查的异常(Checked Exception )，运行时异常IllegalArgumentException，编译能通过，但是一运行就终止了，程序不会处理运行时异常，出现这类异常，程序会终止。而受检查的异常，要么用 try。。。catch 捕获，要么用 throws 字句声明抛出，交给它的父类处理，否则编译不会通过。
3. java 异常处理机制（2017-2-23）
   Java 对异常进行了分类，不同类型的异常分别用不同的 Java 类表示，所有异常的根类为 java.lang.Throwable，Throwable 下面又派生了两个子类：Error 和 Exception，Error 表示应用程序本身无法克服和恢复的一种严重问题。Exception 表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常，系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常
   （NullPointerException）、类转换异常（ClassCastException）；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。
   java 为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须 try…catch 处理或用 throws 声明继续抛给上层调用方法处理，所以普通异常也称为 checked 异常，而系统异常可以处理也可以不处理，所以，编译器不强制用 try…catch 处理或用 throws 声明，所以系统异常也称为 unchecked 异常。
4. 请写出你最常见的 5 个 RuntimeException
   下面列举几个常见的 RuntimeException。
   1）java.lang.NullPointerException 空指针异常；出现原因：调用了未经初始化的对象或者是不存在的对象。
   2）java.lang.ClassNotFoundException 指定的类找不到；出现原因：类的名称和路径加载错误；通常都是程序
   试图通过字符串来加载某个类时可能引发异常。
   3）java.lang.NumberFormatException 字符串转换为数字异常；出现原因：字符型数据中包含非数字型字符。
   4）java.lang.IndexOutOfBoundsException 数组角标越界异常，常见于操作数组对象时发生。
   5）java.lang.IllegalArgumentException 方法传递参数错误。
   6）java.lang.ClassCastException 数据类型转换异常。
   7）java.lang.NoClassDefFoundException 未找到类定义错误。
   8）SQLException SQL 异常，常见于操作数据库时的 SQL 语句错误。
   9）java.lang.InstantiationException 实例化异常。
   10）java.lang.NoSuchMethodException 方法不存在异常。
5. throw 和 throws 的区别（2017-11-22-wzz）
   throw：
   1）throw 语句用在方法体内，表示抛出异常，由方法体内的语句处理。
   2）throw 是具体向外抛出异常的动作，所以它抛出的是一个异常实例，执行 throw 一定是抛出了某种异常。
   throws：
   1）throws 语句是用在方法声明后面，表示如果抛出异常，由该方法的调用者来进行异常的处理。
   2）throws 主要是声明这个方法会抛出某种类型的异常，让它的使用者要知道需要捕获的异常的类型。
   3）throws 表示出现异常的一种可能性，并不一定会发生这种异常。
6. final、finally、finalize 的区别？（2017-11-23-wzz）
   1）final：用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，被其修饰的类不可继承。
   2）finally：异常处理语句结构的一部分，表示总是执行。
   3）finalize：Object 类的一个方法，在垃圾回收器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。该方法更像是一个对象生命周期的临终方法，当该方法被系统调用则代表该对象即将“死亡”，但是需要注意的是，我们主动行为上去调用该方法并不会导致该对象“死亡”，这是一个被动的方法（其实就是回调方法），不需要我们调用。

五、JavaSE 常用 API

1. Math.round(11.5)等于多少？Math.round(- 11.5) 又等于多少?、
   Math.round(11.5)的返回值是 12，Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加 0.5然后进行取整。
2. switch 是否能作用在 byte 上，是否能作用在 long 上，是否能作用在 String上?
   Java5 以前 switch(expr)中，expr 只能是 byte、short、char、int。从 Java 5 开始，Java 中引入了枚举类型，expr 也可以是 enum 类型。从 Java 7 开始，expr 还可以是字符串（String），但是长整型（long）在目前所有的版本中都是不可以的。
3. 数组有没有 length() 方法？String 有没有 length() 方法？
   数组没有 length()方法，而是有 length 的属性。String 有 length()方法JavaScript 中，获得字符串的长度是通过 length 属性得到的，这一点容易和 Java 混淆。
4. String 、StringBuilder 、StringBuffer 的区别？
   Java 平台提供了两种类型的字符串：String 和 StringBuffer/StringBuilder，它们都可以储存和操作字符串，区别如下。
   1）String 是只读字符串，也就意味着 String 引用的字符串内容是不能被改变的。初学者可能会有这样的误解：
   String str = “abc”；
   str = “bcd”;
   如上，字符串 str 明明是可以改变的呀！其实不然，str 仅仅是一个引用对象，它指向一个字符串对象“abc”。第二行代码的含义是让 str 重新指向了一个新的字符串“bcd”对象，而“abc”对象并没有任何改变，只不过该对象已经成为一个不可及对象罢了。
   2）StringBuffer/StringBuilder 表示的字符串对象可以直接进行修改。
   3）StringBuilder 是 Java5 中引入的，它和 StringBuffer 的方法完全相同，区别在于它是在单线程环境下使用的，因为它的所有方法都没有被 synchronized 修饰，因此它的效率理论上也比 StringBuffer 要高。
5. Java 中的日期和时间
   5.1 如何取得年月日、小时分钟秒？
   1. public class DateTimeTest {
      2. public static void main(String[] args) {
         3. Calendar cal = Calendar.getInstance();
         4. System.out.println(cal.get(Calendar.YEAR));
         5. System.out.println(cal.get(Calendar.MONTH)); // 0 - 11
         6. System.out.println(cal.get(Calendar.DATE));
         7. System.out.println(cal.get(Calendar.HOUR_OF_DAY));
         8. System.out.println(cal.get(Calendar.MINUTE));
         9. System.out.println(cal.get(Calendar.SECOND));
         10. // Java 8
         11. LocalDateTime dt = LocalDateTime.now();
         12. System.out.println(dt.getYear());
         13. System.out.println(dt.getMonthValue()); // 1 - 12
         14. System.out.println(dt.getDayOfMonth());
         15. System.out.println(dt.getHour());
         16. System.out.println(dt.getMinute());
         17. System.out.println(dt.getSecond());
   2. }
   3. }