Java基础部分

本文来源于公众号码农求职小助手，仅作为我个人的学习记录，如有侵权请联系删除，有做些排版和修改

JAVA基础

1.解释下什么是面向对象？面向对象和面向过程的区别？

面向对象是一种基于面向过程的编程思想，是向现实世界模型的自然延伸，这是一种“万物皆对象”的编程思想。由执行者变为指挥者，在现实生活中的任何物体都可以归为一类事物，而每一个个体都是一类事物的实例。面向对象的编程是以对象为中心，以消息为驱动。

区别:
（1）编程思路不同：面向过程以实现功能的函数开发为主，而面向对象要首先抽象出类、属性及其方法，然后通过实例化类、执行方法来完成功能。
（2）封装性：都具有封装性，但是面向过程是封装的是功能，而面向对象封装的是数据和功能。
（3）面向对象具有继承性和多态性，而面向过程没有继承性和多态性，所以面向对象优势很明显。

2.面向对象的三大特性？分别解释下？

（1）封装：通常认为封装是把数据和操作数据的方法封装起来，对数据的访问只能通过已定义的接口。
（2）继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类/基类），得到继承信息的被称为子类（派生类）。
（3）多态：分为编译时多态（方法重载）和运行时多态（方法重写）。要实现多态需要做两件事：一是子类继承父类并重写父类中的方法，二是用父类型引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为。

关于继承的几点补充：

（1）子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，只是拥有。因为在一个子类被创建的时候，首先会在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类的对象；
（2）子类可以拥有自己属性和方法；
（3）子类可以用自己的方式实现父类的方法。（重写）

3.JDK、JRE、JVM 三者之间的关系？

JDK（Java Development Kit）：是 Java 开发工具包，是整个 Java 的核心，包括了 Java 运行环境 JRE、Java 工具和 Java 基础类库。
JRE（ Java Runtime Environment）：是 Java 的运行环境，包含 JVM 标准实现及 Java 核心类库。
JVM（Java Virtual Machine）：是 Java 虚拟机，是整个 Java 实现跨平台的最核心的部分，能够运行以 Java 语言写作的软件程序。所有的 Java 程序会首先被编译为 .class 的类文件，这种类文件可以在虚拟机上执行。

4、重载和重写的区别？

（1）重载：编译时多态、同一个类中同名的方法具有不同的参数列表、不能根据返回类型进行区分【因为：函数调用时不能指定类型信息，编译器不知道你要调哪个函数】；
（2）重写（又名覆盖）：运行时多态、子类与父类之间、子类重写父类的方法具有相同的返回类型、更好的访问权限。

5、Java 中是否可以重写一个 private 或者 static 方法？

Java 中 static 方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的，而 static 方法是编译时静态绑定的。static 方法跟类的任何实例都不相关，所以概念上不适用。 Java 中也不可以覆盖 private 的方法，因为 private 修饰的变量和方法只能在当前类中使用， 如果是其他的类继承当前类是不能访问到 private 变量或方法的，当然也不能覆盖。

静态方法的补充

静态的方法可以被继承，但是不能重写。如果父类和子类中存在同样名称和参数的静态方法，那么该子类的方法会把原来继承过来的父类的方法隐藏，而不是重写。通俗的讲就是父类的方法和子类的方法是两个没有关系的方法，具体调用哪一个方法是看是哪个对象的引用；这种父子类方法也不在存在多态的性质。

6、构造器是否可以被重写？

在讲继承的时候我们就知道父类的私有属性和构造方法并不能被继承，所以 Constructor 也就不能被 Override（重写），但是可以 Overload（重载），所以你可以看到一个类中有多个构造函数的情况。

7、构造方法有哪些特性？

（1）名字与类名相同；
（2）没有返回值，但不能用 void 声明构造函数；
（3）成类的对象时自动执行，无需调用。

8、在 Java 中定义一个不做事且没有参数的构造方法有什么作用？

Java 程序在执行子类的构造方法之前，如果没有用 super() 来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 super() 来调用父类中特定的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是：在父类里加上一个不做事且没有参数的构造方法。

9、Java 中创建对象的几种方式？

1、使用 new 关键字；
2、使用 Class 类的 newInstance 方法，该方法调用无参的构造器创建对象（反射）：Class.forName.newInstance()；
3、使用 clone() 方法；
4、反序列化，比如调用 ObjectInputStream 类的 readObject() 方法。

10、抽象类和接口有什么区别？

（1）抽象类中可以定义构造函数，接口不能定义构造函数；
（2）抽象类中可以有抽象方法和具体方法，而接口中只能有抽象方法（public abstract）；
（3）抽象类中的成员权限可以是 public、默认、protected（抽象类中抽象方法就是为了重写，所以不能被 private 修饰），而接口中的成员只可以是 public（方法默认：public abstrat、成员变量默认：public static final）；
（4）抽象类中可以包含静态方法，而接口中不可以包含静态方法；

JDK8中的改变：

1、在 JDK1.8中，允许在接口中包含带有具体实现的方法，使用 default 修饰，这类方法就是默认方法。
2、抽象类中可以包含静态方法，在 JDK1.8 之前接口中不能包含静态方法，JDK1.8 以后可以包含。之前不能包含是因为，接口不可以实现方法，只可以定义方法，所以不能使用静态方法（因为静态方法必须实现）。现在可以包含了，只能直接用接口调用静态方法。JDK1.8 仍然不可以包含静态代码块。

11、静态变量和实例变量的区别？

静态变量：是被 static 修饰的变量，也称为类变量，它属于类，因此不管创建多少个对象，静态变量在内存中有且仅有一个拷贝；静态变量可以实现让多个对象共享内存。实例变量：属于某一实例，需要先创建对象，然后通过对象才能访问到它。

12、short s1 = 1；s1 = s1 + 1；有什么错？那么 short s1 = 1; s1 += 1；呢？有没有错误？

对于 short s1 = 1; s1 = s1 + 1; 来说，在 s1 + 1 运算时会自动提升表达式的类型为 int ，那么将 int 型值赋值给 short 型变量，s1 会出现类型转换错误。对于 short s1 = 1; s1 += 1; 来说，+= 是 Java 语言规定的运算符，Java 编译器会对它进行特殊处理，因此可以正确编译。

13、Integer 和 int 的区别？
（1）int 是 Java 的八种基本数据类型之一，而 Integer 是 Java 为 int 类型提供的封装类；
（2）int 型变量的默认值是 0，Integer 变量的默认值是 null，这一点说明 Integer 可以区分出未赋值和值为 0 的区分；
（3）Integer 变量必须实例化后才可以使用，而 int 不需要。

关于 Integer 和 int 的比较的延伸：

1、由于 Integer 变量实际上是对一个 Integer 对象的引用，所以两个通过 new 生成的 Integer 变量永远是不相等的，因为其内存地址是不同的；
2、Integer 变量和 int 变量比较时，只要两个变量的值是相等的，则结果为 true。因为包装类 Integer 和基本数据类型 int 类型进行比较时，Java 会自动拆包装类为 int，然后进行比较，实际上就是两个 int 型变量在进行比较；
3、非 new 生成的 Integer 变量和 new Integer() 生成的变量进行比较时，结果为 false。因为非 new 生成的 Integer 变量指向的是 Java 常量池中的对象，而 new Integer() 生成的变量指向堆中新建的对象，两者在内存中的地址不同；
4、对于两个非 new 生成的 Integer 对象进行比较时，如果两个变量的值在区间 [-128, 127] 之间，则比较结果为 true，否则为 false。Java 在编译 Integer i = 100 时，会编译成 Integer i = Integer.valueOf(100)，而 Integer 类型的 valueOf 的源码如下所示：

public static Integer valueOf(int var0) {    
        return var0 >= -128 && var0 <= Integer.IntegerCache.high ? Integer.IntegerCache.cache[var0 + 128] : new Integer(var0);}

从上面的代码中可以看出：Java 对于 [-128, 127] 之间的数会进行缓存，比如：Integer i = 127，会将 127 进行缓存，下次再写 Integer j = 127 的时候，就会直接从缓存中取出，而对于这个区间之外的数就需要 new 了。

包装类的缓存：

Boolean：全部缓存Byte：全部缓存Character：<= 127 缓存Short：-128 — 127 缓存Long：-128 — 127 缓存Integer：-128 — 127 缓存Float：没有缓存Doulbe：没有缓存

14、装箱和拆箱

自动装箱是 Java 编译器在基本数据类型和对应得包装类之间做的一个转化。比如：把 int 转化成 Integer，double 转化成 Double 等等。反之就是自动拆箱。
原始类型(基本数据类型）：boolean、char、byte、short、int、long、float、double封装类型：Boolean、Character、Byte、Short、Integer、Long、Float、Double

15、switch 语句能否作用在 byte 上，能否作用在 long 上，能否作用在 String 上？

在 switch(expr 1) 中，expr1 只能是一个整数表达式或者枚举常量。而整数表达式可以是 int 基本数据类型或者 Integer 包装类型。由于，byte、short、char 都可以隐式转换为 int，所以，这些类型以及这些类型的包装类型也都是可以的。而 long 和 String 类型都不符合 switch 的语法规定，并且不能被隐式的转换为 int 类型，所以，它们不能作用于 switch 语句中。不过，需要注意的是在 JDK1.7 版本之后 switch 就可以作用在 String 上了。

16、字节和字符的区别？

字节是存储容量的基本单位；字符是数字、字母、汉字以及其他语言的各种符号；1 字节 = 8 个二进制单位，一个字符由一个字节或多个字节的二进制单位组成。

17、String 为什么要设计为不可变类？

在 Java 中将 String 设计成不可变的是综合考虑到各种因素的结果。主要的原因主要有以下三点：
（1）字符串常量池的需要：字符串常量池是 Java 堆内存中一个特殊的存储区域, 当创建一个 String 对象时，假如此字符串值已经存在于常量池中，则不会创建一个新的对象，而是引用已经存在的对象；
（2）允许 String 对象缓存 HashCode：Java 中 String 对象的哈希码被频繁地使用, 比如在 HashMap 等容器中。字符串不变性保证了 hash 码的唯一性，因此可以放心地进行缓存。这也是一种性能优化手段，意味着不必每次都去计算新的哈希码；
（2）String 被许多的 Java 类(库)用来当做参数，例如：网络连接地址 URL、文件路径 path、还有反射机制所需要的 String 参数等, 假若 String 不是固定不变的，将会引起各种安全隐患。

18、String、StringBuilder、StringBuffer 的区别？

String：用于字符串操作，属于不可变类；【补充：String 不是基本数据类型，是引用类型，底层用 char 数组实现的】StringBuilder：与 StringBuffer 类似，都是字符串缓冲区，但线程不安全；StringBuffer：也用于字符串操作，不同之处是 StringBuffer 属于可变类，对方法加了同步锁，线程安全。

StringBuffer的补充：

说明：StringBuffer 中并不是所有方法都使用了 Synchronized 修饰来实现同步：

@Overridepublic StringBuffer insert(int dstOffset, CharSequence s) { 
 // Note, synchronization achieved via invocations of other StringBuffer methods 
  // after narrowing of s to specific type 
   // Ditto for toStringCache clearing  super.insert(dstOffset, s); 
    return this;
}

执行效率：StringBuilder > StringBuffer > String

19、String 字符串修改实现的原理？

当用 String 类型来对字符串进行修改时，其实现方法是首先创建一个 StringBuffer，其次调用 StringBuffer 的 append() 方法，最后调用 StringBuffer 的 toString() 方法把结果返回。

19.String、StringBuilder、StringBuffer 的区别？
20.String str = “i” 与 String str = new String(“i”) 一样吗？
21.String 类的常用方法都有那些？
22.final 修饰 StringBuffer 后还可以 append 吗？
23.Object 的常用方法有哪些？
24.为什么 wait/notify 方法放在 Object 类中而不是 Thread 类中？
25.final、finally、finalize 的区别？
26.finally 块中的代码什么时候被执行？finally 是不是一定会被执行到？
27.try-catch-finally 中哪个部分可以省略？
28.try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？
29.static 关键字的作用？
30.super 关键字的作用？
31.transient关键字的作用？
32.== 和 equals 的区别？
33.两个对象的 hashCode() 相同，则 equals() 也一定为 true 吗？
34.为什么重写 equals() 就一定要重写 hashCode() 方法？
35.& 和 && 的区别？
36.Java 中的参数传递时传值呢？还是传引用？
37.Java 中的 Math.round(-1.5) 等于多少？
38.两个数的异或结果是什么？
39.error 和 exception 的区别？
40.throw 和 throws 的区别？
41.常见的异常类有哪些？
42.运行时异常与受检异常有何异同？
43.主线程可以捕获到子线程的异常吗？
44.Java 的泛型是如何工作的 ? 什么是类型擦除 ?
45.什么是泛型中的限定通配符和非限定通配符 ?
46.List<? extends T> 和 List <? super T> 之间有什么区别 ?
47.如何实现对象的克隆？
48.深克隆和浅克隆的区别？
49.什么是 Java 的序列化，如何实现 Java 的序列化？
50.Java 中的反射是什么意思？有哪些应用场景？
51.反射的优缺点？
52.Java 中的动态代理是什么？有哪些应用？
53.怎么实现动态代理？
54.Java 中的 IO 流的分类？说出几个你熟悉的实现类？
55.字节流和字符流有什么区别？
56.BIO、NIO、AIO 有什么区别？

Java集合类

59.Java 中常用的容器有哪些？
60.ArrayList 和 LinkedList 的区别？
61.ArrayList 的扩容机制？
62.Array 和 ArrayList 有何区别？什么时候更适合用 Array？
63.HashMap 的实现原理/底层数据结构？JDK1.7 和 JDK1.8
64.HashMap 的 get、put、resize 方法的过程？
65.HashMap 的 size 为什么必须是 2 的整数次方？
66.HashMap 多线程死循环问题？
67.HashMap 的 get 方法能否判断某个元素是否在 Map 中？
68.HashMap 与 HashTable/ConcurrentHashMap 的区别是什么?
69.HashTable 和 ConcurrentHashMap 的区别是什么?
70.ConcurrentHashMap 的实现原理是什么？
71.HashSet 的实现原理？怎么保证元素不重复的？
72.LinkedHashMap 的实现原理?
73.Iterator 怎么使用？有什么特点？
74.Iterator 和 Enumeration 接口的区别？
75.fail-fast 与 fail-safe 有什么区别？
76.Collection 和 Collections 有什么区别？

Java并发

79.并行和并发有什么区别？
80.线程和进程的区别？
81.守护线程是什么？
82.创建线程的几种方式？
83.runnable 和 callable 有什么区别？
84.线程状态及转换？
85.sleep() 和 wait() 的区别？
86.线程的 run() 和 start() 有什么区别？
87.在 Java 程序中怎么保证多线程的运行安全？
88.Java 线程同步的几种方法？
89.Thread.interrupt() 方法的工作原理是什么？
90.谈谈对 ThreadLocal 的理解？
91.多线程并行运行，主线程怎么收集子线程的信息？
92.说一说自己对于 synchronized 关键字的了解？项目中怎么使用的？
93.说说 JDK1.6 之后的 synchronized 关键字底层做了哪些优化，可以详细介绍一下这些优化吗？
94.谈谈 synchronized 和 ReenTrantLock 的区别？
95.synchronized 和 volatile 的区别是什么？
96.简单介绍下 volatile？volatile 的底层原理是什么？内存屏障是如何实现的？
97.说下对 ReentrantReadWriteLock 的理解？
98.说下对悲观锁和乐观锁的理解？
99.乐观锁常见的两种实现方式是什么？分别有什么问题？
100.CAS 和 synchronized 的使用场景？
101.什么是 CAS，内部怎么实现的？
102.简单说下对 Java 中的原子类的理解？atomic 的原理是什么？
103.说下对同步器 AQS 的理解？
104.说下对信号量 Semaphore 的理解？
105.CountDownLatch 和 CyclicBarrier 有什么区别？
106.说下对线程池的理解？为什么要使用线程池？
107.实现 Runnable 接口和 Callable 接口的区别？
108.执行 execute() 方法和 submit() 方法的区别是什么呢？
109.如何创建线程池？
110.创建线程池的参数有哪些？
111.线程池中的的线程数一般怎么设置？需要考虑哪些问题？
112.说下对 Fork/Join 并行计算框架的理解？
113.JDK 中提供了哪些并发容器？
114.谈谈对 CopyOnWriteArrayList 的理解？
115.谈谈对 ConcurrentLinkedQueue 的理解？
116.谈谈对 ConcurrentSkipListMap 的理解？
117.谈谈对 BlockingQueue 的理解？分别有哪些实现类？

Java虚拟机

120.说一下 Jvm 的主要组成部分？及其作用？
121.谈谈对运行时数据区的理解？
122.谈谈对堆和栈的理解？堆中存什么？栈中存什么？
123.为什么要把堆和栈区分出来呢？栈中不是也可以存储数据吗？
124.Java 中的参数传递时传值呢？还是传引用？
125.Java 对象的大小是怎么计算的？
126.对象的访问定位的两种方式？
127.判断垃圾可以回收的方法有哪些？有什么优缺点？
128.被标记为垃圾的对象一定会被回收吗？
129.谈谈对 Java 中引用的了解？
130.谈谈对内存泄漏的理解？举几个内存泄漏的案例？
131.常用的垃圾收集算法有哪些？各自的优缺点是什么？
132.为什么要采用分代收集算法？
133.什么是浮动垃圾？
134.常用的垃圾收集器有哪些？
135.谈谈 CMS 和 G1 的区别？
136.谈谈对 G1 收集器的理解？
137.详细说下垃圾回收策略？
138.谈谈你对内存分配的理解？大对象怎么分配？空间分配担保？
139.说下你用过的 JVM 监控工具？
140.谈谈你对 JVM 调优的理解？有过工程调优经验吗？
141.JVM 设置最大堆的参数是什么？
142.谈谈你对类文件结构的理解？有哪些部分组成？
143.谈谈你对类加载机制的了解？
144.类加载各阶段的作用分别是什么？
145.有哪些类加载器？分别有什么作用？
146.怎么实现一个自定义的类加载器？需要注意什么？
147.谈谈你对双亲委派模型的理解？工作过程？为什么要使用？
148.怎么打破双亲委派模型？有哪些实际场景是需要打破双亲委派模型的？
149.谈谈你对编译期优化和运行期优化的理解？
150.谈谈你对词法分析和语法分析的理解？
151.为何 HotSpot 虚拟机要使用解释器与编译器并存的架构？
152.编译优化技术有哪些？
153.说下你对 Java 内存模型的理解？
154.内存间的交互操作有哪些？需要满足什么规则？