基础语法

1. Java有哪些数据类型

定义： Java 语言是强类型语言，对于每一种数据都定义了明确的具体的数据类型，在内存中分配了不同大小的内存空间。细化的数据类型就是占用空间的基本元素。

分类：

基本数据类型

数值型
整数类型 (byte,short,int,long)

浮点类型 (float,double)

字符型(char)
布尔型(boolean)

引用数据类型

类(class) eg:String
接口(interface)
数组([])

1-24-8-4-2-1 空间大小对称记忆

2. switch 是否能作用在 byte 上，是否能作用在 long 上，是否能作用在 String 上

在 Java 5 以前， switch(expr) 中， expr 只能是 byte 、 short 、 char 、 int 。从 Java5 开始， Java 中引入了枚举类型，expr 也可以是 enum 类型，从 Java 7 开始， expr 还可以是字符串（ String ），但是长整型（long ）在目前所有的版本中都是不可以的。

3. 用最有效率的方法计算 2 乘以 8

2 << 3 （左移 3 位相当于乘以 2 的 3 次方，右移 3 位相当于除以 2 的 3 次方）。

    public static void main(String[] args) {
        System.out.println(2<<3);
    }

4. Math.round(11.5) 等于多少？Math.round(-11.5) 等于多少

Math.round(11.5) 的返回值是 12 ， Math.round(-11.5) 的返回值是 -11 。四舍五入的原理是在参数上加 0.5 然后进行下取整。四舍五入 >0.5统一加0.几, <0.5 统一减0.几。

5. float f=3.4;是否正确

不正确。 3.4 是双精度数，将双精度型（ double ）赋值给浮点型（ float ）属于下转型（ down-casting ，也称为窄化）会造成精度损失，因此需要强制类型转换float f =(float)3.4; 或者写成 float f =3.4F;

6. short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗

涉及Java的强制类型转换支持向上自动转型

对于 short s1 = 1; s1 = s1 + 1; 由于 1 是 int 类型，因此 s1+1 运算结果也是 int 型，需要强制转换类型才能赋值给 short 型。而 short s1 = 1; s1 += 1; 可以正确编译，因为 s1+= 1; 相当于 s1 = (short(s1 + 1); 其中有隐含的强制类型转换。

7.注释

定义：用于解释说明程序的文字

分类

单行注释格式： // 注释文字

多行注释格式： /* 注释文字 */

文档注释格式： /** 注释文字 */

8. 访问修饰符 public,private,protected,以及不写（默认）时的区别

定义： Java 中，可以使用访问修饰符来保护对类、变量、方法和构造方法的访问。 Java 支持 4 种不同的

访问权限。

分类：

private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）

default ( 即缺省，什么也不写，不使用任何关键字） : 在同一包内可见，不使用任何修饰符。使用

对象：类、接口、变量、方法。

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部

类）。

public : 对所有类可见。使用对象：类、接口、变量、方法

9. final 有什么用？

用于修饰类、属性和方法；

被final修饰的类不可以被继承
被final修饰的方法不可以被重写
被final修饰的变量不可以被改变，被final修饰不可变的是变量的引用，而不是引用指向的内容，引
用指向的内容是可以改变的

10. final finally finalize区别

1. final 可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修

饰变量表示该变量是一个常量不能被重新赋值。

2. finally 一般作用在 try-catch 代码块中，在处理异常的时候，通常我们将一定要执行的代码方法

finally 代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代

码。

3. finalize 是一个方法，属于 Object 类的一个方法，而 Object 类是所有类的父类，该方法一般由垃圾

回收器来调用，当我们调用 System.gc() 方法的时候，由垃圾回收器调用 finalize() ，回收垃圾，一

个对象是否可回收的最后判断。

11. this与super的区别

super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）
this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）
super()和this()类似,区别是，super()在子类中调用父类的构造方法，this()在本类内调用本类的其它构造方法。
super()和this()均需放在构造方法内第一行。
尽管可以用this调用一个构造器，但却不能调用两个。
this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：
static变量,static方法，static语句块。
从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

12. static存在的主要意义

static 的主要意义是在于创建独立于具体对象的域变量或者方法。以致于即使没有创建对象，也能使用属性和调用方法！

static 关键字还有一个比较关键的作用就是用来形成静态代码块以优化程序性能。 static 块可以置于类中的任何地方，类中可以有多个static 块。在类初次被加载的时候，会按照 static 块的顺序来执行每个 static 块，并且只会执行一次。为什么说static 块可以用来优化程序性能，是因为它的特性 : 只会在类加载的时候执行一次。因此，很多时候会将一些只需要进行一次的初始化操作都放在static 代码块中进行。

因此比较常见的static应用场景有：

1 、修饰成员变量

2 、修饰成员方法

3 、静态代码块

4 、修饰类【只能修饰内部类也就是静态内部类】

5 、静态导包

static注意事项

1 、静态只能访问静态。 2 、非静态既可以访问非静态的，也可以访问静态的。

13. 抽象类和接口的对比

抽象类是用来捕捉子类的通用特性的。接口是抽象方法的集合。

从设计层面来说，抽象类是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。

相同点

接口和抽象类都不能实例化
都位于继承的顶端，用于被其他实现或继承
都包含抽象方法，其子类都必须覆写这些抽象方法

不同点

参数	抽象类	接口
声明	抽象类使用 abstract 关键字声明	接口使用 interface 关键字声明
实现	子类使用 extends 关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现	子类使用 implements 关键字来实现接口。它需要提供接口中所有声明的方法的实现
构造器	抽象类可以有构造器	接口不能有构造器
访问修饰符	抽象类中的方法可以是任意访问修饰符	接口方法默认修饰符是 public 。并且不允许定义为 private 或者 protected
多继承	一个类最多只能继承一个抽象类	一个类可以实现多个接口
字段声明	抽象类的字段声明可以是任意的	接口的字段默认都是 static 和 final 的

备注： Java8 中接口中引入默认方法和静态方法，以此来减少抽象类和接口之间的差异。

14. 抽象类能使用 final 修饰吗？

不能，定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承，这样彼此就会产生矛

盾，所以 final 不能修饰抽象类

15. 创建一个对象用什么关键字？对象实例与对象引用有何不同？

new 关键字， new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。一个对象引用可以指向0 个或 1 个对象（一根绳子可以不系气球，也可以系一个气球） ; 一个对象可以有n 个引用指向它（可以用 n 条绳子系住一个气球）

没有对象引用，丢失跟可达性就代表是可以回收的对象。

变量与方法

16. 成员变量与局部变量的区别有哪些

变量：在程序执行的过程中，在某个范围内其值可以发生改变的量。从本质上讲，变量其实是内存中的一小块区域

成员变量：方法外部，类内部定义的变量

局部变量：类的方法中的变量。成员变量和局部变量的区别。

作用域

成员变量：针对整个类有效。

局部变量：只在某个范围内有效。 ( 一般指的就是方法 , 语句体内 )

存储位置

成员变量：随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。

局部变量：在方法被调用，或者语句被执行的时候存在，存储在栈内存中。当方法调用完，或者语句结束后，就自动释放。

生命周期

成员变量：随着对象的创建而存在，随着对象的消失而消失。

局部变量：当方法调用完，或者语句结束后，就自动释放。

初始值

成员变量：有默认初始值。

局部变量：没有默认初始值，使用前必须赋值。

使用原则

在使用变量时需要遵循的原则为：就近原则首先在局部范围找，有就使用；接着在成员位置找。

17. 静态变量和实例变量区别

静态变量：静态变量由于不属于任何实例对象，属于类的，所以在内存中只会有一份，在类的加载过程中，JVM 只为静态变量分配一次内存空间。

实例变量：每次创建对象，都会为每个对象分配成员变量内存空间，实例变量是属于实例对象的，在内存中，创建几次对象，就有几份成员变量。

18 静态方法和实例方法有何不同？

静态方法和实例方法的区别主要体现在两个方面：

1. 在外部调用静态方法时，可以使用 " 类名 . 方法名 " 的方式，也可以使用 " 对象名 . 方法名 " 的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。

2. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制

19. 内部类的分类有哪些

内部类可以分为四种： 成员内部类、局部内部类、匿名内部类和静态内部类。

静态内部类

定义在类内部的静态类，就是静态内部类。

1 public class Outer {
2
3 private static int radius = 1;
4
5 static class StaticInner {
6 public void visit() {
7 System.out.println("visit outer static variable:" + radius);
8 }
9 }
10 }

静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；静态内部类的创建方式，new 外部类 . 静态内部类 () ，如下：

1 Outer.StaticInner inner = new Outer.StaticInner();
2 inner.visit

成员内部类

定义在类内部，成员位置上的非静态类，就是成员内部类。

1 public class Outer {
2
3 private static int radius = 1;
4 private int count =2;
5
6 class Inner {
7 public void visit() {
8 System.out.println("visit outer static variable:" + radius);
9 System.out.println("visit outer variable:" + count);
10 }
11 }
12 }

成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公有。成员内部类依赖于外部类的实例，它的创建方式外部类实例.new 内部类 () ，如下：

1 Outer outer = new Outer();
2 Outer.Inner inner = outer.new Inner();
3 inner.visit();

局部内部类

定义在方法中的内部类，就是局部内部类

1 public class Outer {
2
3 private int out_a = 1;
4 private static int STATIC_b = 2;
5
6 public void testFunctionClass(){
7 int inner_c =3;
8 class Inner {
9 private void fun(){
10 System.out.println(out_a);
11 System.out.println(STATIC_b);
12 System.out.println(inner_c);
13 }
14 }
15 Inner inner = new Inner();
16 inner.fun();
17 }
18 public static void testStaticFunctionClass(){
19 int d =3;
20 class Inner {
21 private void fun(){
22 // System.out.println(out_a); 编译错误，定义在静态方法中的局部类不可以访问外
部类的实例变量
23 System.out.println(STATIC_b);
24 System.out.println(d);
25 }
26 }
27 Inner inner = new Inner();
28 inner.fun();
29 }
30 }

定义在实例方法中的局部类可以访问外部类的所有变量和方法，定义在静态方法中的局部类只能访问外部类的静态变量和方法。局部内部类的创建方式，在对应方法内，new 内部类 () ，如下：

1 public static void testStaticFunctionClass(){
2 class Inner {
3 }
4 Inner inner = new Inner();
5 }

匿名内部类

匿名内部类就是没有名字的内部类，日常开发中使用的比较多。

1 public class Outer {
2
3 private void test(final int i) {
4 new Service() {
5 public void method() {
6 for (int j = 0; j < i; j++) {
7 System.out.println("匿名内部类" );
8 }
9 }
10 }.method();
11 }
12 }
13 //匿名内部类必须继承或实现一个已有的接口
14 interface Service{
15 void method();
16 }

除了没有名字，匿名内部类还有以下特点：

匿名内部类必须继承一个抽象类或者实现一个接口。
匿名内部类不能定义任何静态成员和静态方法。
当所在的方法的形参需要被匿名内部类使用时，必须声明为 final。
匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

匿名内部类创建方式：

1 new 类/接口{
2 //匿名内部类实现部分
3 }

内部类的优点

我们为什么要使用内部类呢？因为它有以下优点：
一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据！
内部类不为同一包的其他类所见，具有很好的封装性；
内部类有效实现了“多重继承”，优化 java 单继承的缺陷。
匿名内部类可以很方便的定义回调。

20. 重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分？

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

重载：发生在同一个类中，方法名相同参数列表不同（参数类型不同、个数不同、顺序不同），与方法返回值和访问修饰符无关，即重载的方法不能根据返回类型进行区分

重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类（里氏代换原则）；如果父类方法访问修饰符为private 则子类中就不是重写。

21. == 和 equals 的区别是什么

== : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。(基本数据类型 == 比较的是值，引用数据类型 == 比较的是内存地址)

equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：情况 1 ：类没有覆盖

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

情况 2 ：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来两个对象的内容相等；若它们的内容相等，则返回 true ( 即，认为这两个对象相等 ) 。

举个例子：

1 public class test1 {
2 public static void main(String[] args) {
3 String a = new String("ab"); // a 为一个引用
4 String b = new String("ab"); // b为另一个引用,对象的内容一样
5 String aa = "ab"; // 放在常量池中
6 String bb = "ab"; // 从常量池中查找
7 if (aa == bb) // true
8 System.out.println("aa==bb");
9 if (a == b) // false，非同一对象
10 System.out.println("a==b");
11 if (a.equals(b)) // true
12 System.out.println("aEQb");
13 if (42 == 42.0) { // true
14 System.out.println("true");
15 }
16 }
17 }

说明：

String中的equals方法是被重写过的，因为object的equals方法是比较的对象的内存地址，而 String的equals方法比较的是对象的值。
当创建String类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个String对象。

22. hashCode 与 equals (重要)

HashSet如何检查重复

两个对象的 hashCode() 相同，则 equals() 也一定为 true ，对吗？

hashCode 和 equals 方法的关系

面试官可能会问你： “ 你重写过 hashcode 和 equals 么，为什么重写 equals 时必须重写 hashCode 方法？

hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个 int 整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在 JDK 的 Object.java 中，这就意味着 Java 中的任何类都包含有hashCode() 函数。

散列表存储的是键值对 (key-value) ，它的特点是：能根据 “ 键 ” 快速的检索出对应的 “ 值 ” 。这其中就利用到了散列码！（可以快速找到所需要的对象）

为什么要有 hashCode

我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：

当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals()方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。