Java面试八股文-java基础部分

资料是网络上搜集到的PDF上的,非原创,自己边敲边记忆

Java基础

面向对象

解释什么是面向过程、面向对象?

面向对象和面向过程,是两种不同的处理问题的角度

面向过程更注重事情的每一个步骤及顺序

比如：洗衣机洗衣服

面向过程会将任务拆解成一系列的步骤（函数）：

1.打开洗衣机 2.放衣服3.放洗衣粉4.清洗5.烘干衣服

面向对象会拆解出人和衣服两个对象：

人：打开洗衣机 放衣服 放洗衣粉

洗衣机： 清洗 烘干

从以上例子能看出，面向过程比较直接高效，面向过程更易于复用、拓展和维护

解释面向对象的三大特征

封装继承多态

封装：封装的意义，用于明确标识出允许外部使用的所有成员函数和数据项，内部细节对外部调用透明，外部调用无需修改和关心内部实现

举例：

1.javabean的属性私有，提供get和set方法对外访问，因为属性的赋值或者获取逻辑只能由javabean本身决定。而不能由外部胡乱修改

 2. orm框架

操作数据库，我们不需要关心链接是如何建立的，sql是如何执行的，只需要引入mybatis，调用方法即可

继承：继承基类的方法，并做出自己的改变和拓展

子类共性的方法或者属性直接使用父类的，而不需要自己再定义，只需扩展自己个性的内容

多态：基于对象所属类的不同，外部对同一个方法的调用，实际执行的逻辑不同。继承，方法重写，父类引用指向子类对象

 注意：父类无法调用子类特有的功能

JDK  JRE JVM

JDK： java Development Kit   ， java开发工具

JRE： java Runtime Environment   ， java运行环境

JVM： java Virtual Machine  ， java虚拟机

==和equals的比较

==对比的是栈中的值，基本数据类型是变量值，引用数据类型是栈中内存对象的地址

equals：object中默认也是采用==比较，通常会重写

Object

String 

 上述代码可以看出，String类中被复写的equals（）方法其实是比较两个字符串的内容

 hashCode与equals

hashCode介绍：

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

为什么要有hashCode：

以HashSet如何检查重复的例子来说明为什么要有hashCode；

对象加入HashSet时，HashSet会首先计算对象的hashcode值来判断对象加入的位置,看该位置是否有值,如果没有,HashSet就会假设对象没有重复出现,如果发现有值,这时会调用equals()方法来检查两个对象是否真的相同.如果两者相同,HashSet就不会让其加入操作成功.如果不同的话,就会重新散列到其他位置,这样就大大减少了equals的次数,相应大大提高了执行速度

• 如果两个对象相等,则hashcode的值也一定相同
• 两个对象相等,对两个对象分别调用equals方法都返回true
• 两个对象即便有相同的hashcode值,他们也不一定相等,

例如:长度14,key=x%11的散列表中,先放进去一个1 ,再放进去一个12

• 因此equals被覆盖过,则hashcode方法也必须被覆盖
• hashCode()的默认行为是对堆上的对象产生独特值.如果没有重写hashCode(),则该class的两个对象无论如何都不会相等(即使这两个对象指向相同的数据)

解释一下final的用法

最终的

• 修饰类:表示类不可被继承
• 修饰方法:表示方法不可被子类覆盖,但是可以重载
• 修饰变量:表示变量一旦被赋值就不可以更改

（1）修饰成员变量

• 如果final修饰的是类变量,只能在静态初始化快中决定初始值或者声明该变量时指定初始值
• 如果final修饰的是成员变量,可以在非静态初始化块、声明该变量或者构造其中执行初始值

（2）修饰局部变量

系统不会为局部变量进行初始化，局部变量必须由程序员显示初始化。因此使用final修饰局部变量时，即可以在定义时指定默认值（后面的代码不能对该变量再赋值），也可以不指定默认值，而在后面的代码中对final变量赋初值（仅一次）

（3）修饰基本类型数据和引用类型数据

• 如果是基本类型数据的变量，则其数值一旦在初始化之后便不能修改
• 如果是引用类型的数据，则在对齐初始化后便不能再指向另一个对象。但是引用的值是可变的 

 

为什么局部内部类和匿名内部类只能访局部final变量？ 

编译之后会生成两个class文件，Test.class Test1.class

首先要知道的一点是：内部类和外部类是处于同一级别的，内部类不会因为定义在方法中就会随着方法的执行完毕就被销毁。

这里就会产生问题，当外部类的方法结束时，局部变量就会被销毁了，但内部类对象可能还存在（只有没有人再引用它时，才会死亡）。这里就出现了一个矛盾：内部类对象访问了一个不存在的变量。为了解决这个问题，就讲局部变量复制了一份作为内部类的成员变量，这样当局部变量死亡后，内部类依然可以访问他，实际访问的是局部变量的copy。这样就好像就延长了局部变量的生命周期。

将局部变量复制为内部类的成员变量时，必须保证这两个变量是一样的，也就是如果我们在内部类中修改了成员变量，方法中的局部变量也得跟着改变，如何解决问题呢？

就讲局部变量设置为final，对它初始化后，我们就不让你再去修改这个变量，就保证了内部类的成员变量和方法的局部变量的一致性。这实际上也是一种拖鞋。使得局部变量与内部类内建立的copy一致。 

String、StringBuffer、StringBuilder三者的区别？

String是final修饰的，不可变，每次操作都会产生新的String对象

StringBuffer和StringBuilder都是在原对象上操作

StringBuffer是线程安全的，StringBuilder是线程不安全的

StringBuffer（）方法都是synchronized修饰的

性能：StringBuilder ＞ StringBuffer ＞ String

场景：经常需要改变字符串内容时使用后面两个

优先使用StringBuilder，多线程使用共享变量时使用StringBuffer

重载和重写的区别？

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

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

接口和抽象类的区别 ？

• 抽象类可以存在普通成员函数，而接口中只能存在public abstract方法
• 抽象类中的成员变量可以是任何类型的，而接口中的成员变量只能是public static final类型的
• 对类来说，抽象类只能继承一个，接口可以实现多个。

接口的设计目的，是对类的行为进行约束（更准确的说是一种“有”约束，因为就接口不能规定类不能有什么行为），也就是提供一种机制，可以强制要求不同的类具有相同的行为。它只约束了行为的有无，但不对具体实现行为进行限制。

抽象类的设计目的，是代码复用，当不同的类具有相同的行为（纪委行为集合A），且其中一部分行为的实现方式一致时（A的非真子集，记为B），可以让这些类都派生出一个抽象类。在这个类中实现了B，避免让所有的子类来实现B，这就达到了代码复用的目的，而A-B的部分，留给各个子类自己实现。正是因为A-B在这里没有实现，所以抽象类不允许实例化出来（否则当调用到A-B时，无法执行）

抽象类是对类本质的抽象，表达的是is a的关系，比如：BMW is a Car。抽象类包含并实现子类的通用特性，将子类存在差异化的特性进行抽象，交由子类去实现。

接口是对行为的抽象，表达的是like a 的关系。比如Bird like a Aircraft（像飞行棋一样可以飞），但其本质is a Bird。接口的核心是定义行为，即实现类可以做什么，至于实现类主题是谁，是如何实现的，接口并不关心。

使用场景：当你关注一个事务的本质的时候，用抽象类；当你关注一个操作的时候，用接口

抽象类的功能要远超过接口，但是，定义抽象类的代价很高。因为对高级语言来说（从实现设计上来说也是）每一个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述，而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度。

List和Set的区别？

List：有序，按对象进入的顺序保存对象，可重复，允许多个Null元素对象，可以使用Iterator取出所有元素，在逐一遍历，还可以使用get（int index）获取指定下标的元素

Set：无序，不可重复，最多允许有一个Null对象，取元素时只能用Iterator接口取出所有元素，在逐一遍历各个元素

ArrayList和LinkedList的区别？

ArrayList：基于动态数组，连续内存存储，适合下标访问（随机访问），扩容机制：因为数组长度固定，超出长度存数据时需要新建数组，然后将老数组的数拷贝到新数组中，如果不是尾部插入数据还会涉及到元素的移动（往后复制一份，插入新元素），使用尾插法并指定容量可以极大地提升性能、甚至是超过linkedList（需要创建大量的node对象）

LinkedList：基于链表，可以存储在分散的内存中，适合做数据插入及数据删除，不适合查询：需要逐一遍历。遍历LinkedList必须使用iterator不能使用for循环，因为每次循环体内通过get（i）取得某一元素时要对list重新进行遍历，性能消耗极大。另外不要试图使用indexOf等返回索引，并利用其进行遍历，使用indexOf对list进行遍历，当结果为空是会遍历整个列表

HashMap和HashTable有什么区别？其底层实现是什么？

区别：

（1）HashMap方法没有synchronized修饰，线程非安全，HashTable线程安全；

（2）HashMap允许key和value为null，而HashTable不允许

底层实现：数组+链表

jdk8开始当链表高度达到8、数组长度超过64，链表就会转变为红黑树，元素以内部类Node结点存在

• 计算key的hash值，二次hash然后对数组长度取模，对应到数组下标，
• 如果没有产生hash冲突（下标位置没有元素），则直接创建Node存入数组
• 如果产生hash冲突，先进行equal对比，相同则取代该元素，不同则判断链表高度插入链表，链表高度达到8，并且数组长度到64则转变为红黑树，长度低于6则从红黑树转变为链表
• key为null，存在下标0的位置

数组扩容

ConcurrentHashMap原理，jdk7和jdk8版本的区别？

jdk7：

数据结构：ReentrantLock+Segment+HashEntry，一个Segment中包含一个HashEntry数组，每个HashEntry又是一个链表结构

元素查询：二次Hash，第一次Hash定位到Segment，第二次Hash定位到元素所在的链表的头部

锁：Segment分段锁 Segment继承了ReentrantLock，锁定操作的Segment，其他的Segrnt不受影响，并发度为Segment的个数，可以通过构造函数指定，数组扩容不影响其他的Segment

get方法无需枷锁，volatile保证

jdk8：

数据结构：synchronized+CAS+Node+红黑树，Node的val和next都用volatile修饰，保证可见性查找，替换，赋值操作都是用CAS

锁：锁链表的head结点，不影响其他元素的写入，锁粒度更细，效率更高，扩容时，阻塞所有的读写操作，并发扩容

读操作无锁：

Node的的val和next使用volatile修饰，读写线程对该变量互相可见

数组用volatile修饰，保证扩容时被读线程感知

什么是字节码？采用字节码的好处是什么？

java中的编译器和解码器：

java中引入虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个共同的接口

编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由解释器来将虚拟机代码转换为特定系统的机器码执行。在java 中，这种虚拟机理解的代码称为字节码（即扩展名为.class的文件），它不免向任何特定的处理器，只面向虚拟机。

每一个平台的解释器是不同的，但是实现的虚拟机是相同的。java源程序经过编译器编译后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码，然后在特定的机器上运行。这也就解释了java 的编译与解释并存的特点。

java源代码--＞编译器--＞jvm可执行的java字节码（即虚拟指令）--＞jvm--＞jvm中的解释器--＞机器可执行的二进制机器码--＞机器执行

采用字节码的好处?

java语言通过字节码的方式,在一定程度上解决而传统解释型语言执行效率低的问题,同时又保留了解释型语言可一直的特点,所以java程序运行时比较搞笑,而且由于字节码并以专对一种特定的机器,因此,java程序无需重洗编译便可在多种不同的计算机上运行

Java中的异常体系

java中的所有异常都来自顶级父类Throwable

Throwable下有两个子类Exception和ERror

Error是程序无法处理的错误，一旦出现这个错误，则程序将被迫性质运行

Exception不会导致程序停止，又分为RunTimeException运行时异常和CheckedException检查异常

RunTimeException常常发生在程序运行过程中，会导致程序当前线程执行失败CheckedException尝尝发生在程序编译过程中会导致程序编译不通过

Java类加载器

JDK自带有三个类加载器：Bootstrap ClassLoader、ExtClassLoader、AppClassLoader

BootStrapClassLoader是ExtClassLoader的父类加载器,默认负责加载%JAVA_HOME%/lib下的jar包和class文件

ExtClassLoader是AppClassLoader的父类加载器,负责加载%JAVA_HOME%/lib/ext下的jar包和class类

AppClassLoader是自定义类加载器的父类,负责加载classpath下的类文件.系统类加载器,线程上下文加载器

继承ClassLoader实现自定义类加载器

双亲委托模式

 双亲委派模型的好处:

• 主要是为了安全性,避免用户自己编写的类动态替换java的一些核心类,比如String
• 同时避免了类的重复加载,因为JVM中区分不同类,不仅仅是根据类名,相同的class文件被不同的ClassLoader加载就是两个不同的类

GC如何判断对象可以被回收?

• 引用计数法:每个对象有一个引用计数属性,新增一个引用时计数加1,引用释放时计数-1,技术为0时可以回收
• 可达性分析法:从GC Roots开始向下搜索,搜索所走过的路径称为引用链.当一个对象到GC Roots没有任何链相连时,则证明此对象是不可用的,你们虚拟机就判断是可回收对象

引用计数法,可能会出现A引用了B,B又引用了A,这时候就算他们都不再使用了,但因为相互引用计数器=1,永远无法被回收

GC Roots的对象有:

• 虚拟机栈(栈帧中的本地变量表)中引用的对象
• 方法区中静态属性引用的对象
• 方法区中常量引用的对象
• 本地方发展中JNI(即一般说的Native方法)引用的对象

可达性算法汇总的不可达对象不是立即死亡的,对象拥有一次自我拯救的机会.对象被系统宣告死亡至少要经历两次标记过程:第一次是经过可达性分析发现没有与GC Roots相连接的引用链,第二次是在由虚拟机自动建立的Finalizer队列中判断是否需要执行finalize()方法

当对象变成(GC Roots)不可达时,GC会判断该对象是否覆盖了finalize方法,若未覆盖,则直接将其回收.否则,若对象未执行过finalizer方法,将其放入F-Queue对象,由第一季优先级线程执行该队列中对象的finalize方法.执行finalize方法完毕后,GC会再次判断该对象是否可达,若不可达,则进行回收,否则对象复活

每个对象只能触发一次finalize()方法

由于finalize()方法运行代价高昂,不确定性大,无法保证各个对象的调用顺序,不推荐大家使用,建议遗忘.