面试题（基础篇）

1、你是怎样理解OOP面向对象的

面向对象是利于语言对现实事物进行抽象。面向对象具有以下特征：

（1）继承：继承是从已有类得到继承信息创建新类的过程

（2）封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。

（3）多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。

2、你是怎样理解多态的？什么地方用过？

同一个行为具有多个不同表现形式或形态的能力。

父类引用指向子类对象

例如List<String> list = new ArrayList<String>();就是典型的一种多态的体现形式。

1、多态：一种事物，有多种表现形式。
父类引用指向子类对象。
接口和接口的实现类。
接口实现类解释：
例如注入一个UserService接口  实际调用的是其实现类

3、重载与重写有什么区别?（上海）

1、重载发生在本类，重写发生在父类与子类之间；

2、重载的方法名必须相同，重写的方法名相同且返回值类型必须相同；

3、重载的参数列表不同，重写的参数列表必须相同。

4、重写的访问权限不能比父类中被重写的方法的访问权限更低。

5、构造方法不能被重写

4、接口与抽象类的区别（上海）

抽象类要被子类继承，接口要被类实现。

接口可多继承接口，但类只能单继承。

抽象类可以有构造器、接口不能有构造器

抽象类：除了不能实例化抽象类之外，它和普通Java类没有任何区别

抽象类：抽象方法可以有public、protected和default这些修饰符、接口：只能是public

抽象类：可以有成员变量；接口：只能声明常量

接口与抽象类的区别
接口：默认 public ，方法都是抽象的。1.8 默认方法，只有一个。多实现。
抽象类：只要有一个方法是抽象的，这个类就是抽象。可以非抽象方法。单继承。 

5、深拷贝与浅拷贝的理解（上海）

深拷贝和浅拷贝就是指对象的拷贝，一个对象中存在两种类型的属性，一种是基本数据类型，一种是实例对象的引用。

1.浅拷贝是指，只会拷贝基本数据类型的值，以及实例对象的引用地址，并不会复制一份引用地址所指向的对象，也就是浅拷贝出来的对象，内部的类属性指向的是同一个对象

2.深拷贝是指，既会拷贝基本数据类型的值，也会针对实例对象的引用地址所指向的对象进行复制，深拷贝出来的对象，内部的类执行指向的不是同一个对象

深拷贝与浅拷贝的理解  也叫 深克隆和浅克隆
深：地址不同，多个对象。
浅：引用有多个，地址相同。

6、举例说明封装和继承是怎么回事?

封装是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

例如：实体类的封装，下面代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问。

public class Person{ 
private String name; 
private int age; ​ 
public int getAge(){ return age; } ​
public String getName(){ return name; } ​
public void setAge(int age){ this.age = age; } ​ 
public void setName(String name){ this.name = name; } 
}

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

7、sleep和wait在线程里有什么区别？（上海）

sleep方法：

属于Thread类中的方法；会导致程序暂停执行指定的时间，让出cpu执行权给其他线程，但是他的监控状态依然保持着，当指定时间到了之后，又会自动恢复运行状态；在调用sleep方法的过程中，线程不会释放对象锁。（只会让出CPU，不会导致锁行为的改变）

wait方法：

属于Object类中的方法；在调用wait方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify方法后本线程才进入对象锁定池准备。获取对象锁进入运行状态。（不仅让出CPU，还释放已经占有的同步资源锁）

sleep和wait在线程里有什么区别？sleep：thread类提供的，有时间参数，不释放锁，释放线程执行权。时间到就醒。    wait：object类提供的，释放锁，释放，必须通过notify或notifyAll唤醒。

8、什么是自动拆装箱？ int和Integer有什么区别?以及以下程序运行结果。（北京）

基本数据类型，如int,float,double,boolean,char,byte,不具备对象的特征，不能调用方法。

装箱：将基本类型转换成包装类对象

拆箱：将包装类对象转换成基本类型的值

java为什么要引入自动装箱和拆箱的功能？主要是用于java集合中，List<Inteter> list=new ArrayList<Integer>();

list集合如果要放整数的话，只能放对象，不能放基本类型，因此需要将整数自动装箱成对象。

实现原理：javac编译器的语法糖，底层是通过Integer.valueOf()和Integer.intValue()方法实现。

区别：

（1）Integer是int的包装类，int则是java的一种基本数据类型

（2）Integer变量必须实例化后才能使用，而int变量不需要

（3）Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值

（4）Integer的默认值是null，int的默认值是0

1.package com.atguigu.interview.chapter03;  
2.  public class Test01 {  
3.    public static void main(String[] args){  
4.        Integer a = 127;  
5.        Integer b = 127;  
6.        Integer c = 128;  
7.        Integer d = 128;  
8.        System.out.println(a==b); //true  System.out.println(c==d); //false
10.    }  
11.}  

9、==和equals区别

（1） = =

如果比较的是基本数据类型，那么比较的是变量的值

如果比较的是引用数据类型，那么比较的是地址值（两个对象是否指向同一块内存）

(2) equals

如果没重写equals方法比较的是两个对象的地址值

如果重写了equals方法后我们往往比较的是对象中的属性的内容

equals方法是从Object类中继承的，默认的实现就是使用==

==：基本类型比较的是值，引用类型比较地址。equals：
object方法，默认和==一样。如果重写了 按照你自己重写的规则来。
String类型 先比较地址是否相同，如果不同则比较类型，类型相同比较长度，长度相同则比较内容

10、String能被继承吗？为什么用final修饰？（北京）

不能被继承，因为String类有final修饰符，而final修饰的类是不能被继承的。

• String 类是最常用的类之一，为了效率，禁止被继承和重写。

• 为了安全。String 类中有native关键字修饰的调用系统级别的本地方法，调用了操作系统的 API，如果方法可以重写，可能被植入恶意代码，破坏程序。Java 的安全性也体现在这里。

  native关键字：调用系统本地资源的。

11、String buffer和String builder区别

（1）StringBuffer 与 StringBuilder 中的方法和功能完全是等价的，

（2）只是StringBuffer 中的方法大都采用了 synchronized 关键字进行修饰，因此是线程安全的，而 StringBuilder 没有这个修饰，可以被认为是线程不安全的。

（3）在单线程程序下，StringBuilder效率更快，因为它不需要加锁，不具备多线程安全而StringBuffer则每次都需要判断锁，效率相对更低

作用一样，字符串缓冲区。做拼接。线程：buffer安全，加锁了  builder不安全，没加上。效率：buffer低  builder高。buffer  a= “abc”;a.append("d").append("e");a.append("f");
问a的值是什么 都有 做拼接

12、final、finally、finalize

final：修饰符（关键字）有三种用法：修饰类、变量和方法。修饰类时，意味着它不能再派生出新的子类，即不能被继承，因此它和abstract是反义词。修饰变量时，该变量使用中不被改变，必须在声明时给定初值，在引用中只能读取不可修改，即为常量。修饰方法时，也同样只能使用，不能在子类中被重写。

finally：通常放在try…catch的后面构造最终执行代码块，这就意味着程序无论正常执行还是发生异常，这里的代码只要JVM不关闭都能执行，可以将释放外部资源的代码写在finally块中。

finalize：Object类中定义的方法，Java中允许使用finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的，通过重写finalize() 方法可以整理系统资源或者执行其他清理工作。

    finally：必须和try结合使用，不能单独和catch使用，最终要执行的代码 放到finally块中。finalize ：一个方法，object的，垃圾回收调用。

13、Object中有哪些方法

（1）protected Object clone()--->创建并返回此对象的一个副本。

（2）boolean equals(Object obj)--->指示某个其他对象是否与此对象“相等”。

（3）protected void finalize()--->当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

（4）Class<? extendsObject> getClass()--->返回一个对象的运行时类。

（5）int hashCode()--->返回该对象的哈希码值。

（6）void notify()--->唤醒在此对象监视器上等待的单个线程。

（7）void notifyAll()--->唤醒在此对象监视器上等待的所有线程。

（8）String toString()--->返回该对象的字符串表示。

（9）void wait()--->导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。

void wait(long timeout)--->导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll()方法，或者超过指定的时间量。

void wait(long timeout, int nanos)--->导致当前的线程等待，直到其他线程调用此对象的 notify()

14、说一下集合体系？ArrarList和LinkedList区别

简单体系：

ArrarList和LinkedList区别：

（1）ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

（2）对于随机访问get和set，ArrayList效率优于LinkedList，因为LinkedList要移动指针。

（3）对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据。 这一点要看实际情况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。

15、HashMap底层源码，数据结构(常问)

HashMap的底层结构在jdk1.7中由数组+链表实现，在jdk1.8中由数组+链表+红黑树实现，以数组+链表的结构为例。

数据结构：1.8 数组node<K,V>数组+链表+红黑树1、初始化长度：16  负载因子 0.75  可以自己指定。扩容 长度*负载因子=扩容点。2、put方法流程3、扩容。4、hash碰撞：形成链表的条件5、什么时候变成树：数组长度大于64并且链表长度大于86、树转链表：树的高度小于6 转链表。7、为什么要转树？ 当链表长度大于8 查询效率低于红黑树了。

注意：可以结合百度hashmap源码解析进行更深入的了解。

https://blog.csdn.net/v123411739/article/details/78996181

16、你说HashMap底层是 数组+链表+红黑树，为什么要用这几类结构呢？（深圳）

数组Node<K,V>[] table ,哈希表，根据对象的key的hash值进行在数组里面是哪个节点

链表的作用是解决hash冲突，将hash值取模之后的对象存在一个链表放在hash值对应的槽位

红黑树JDK8使用红黑树来替代超过8个节点的链表，主要是查询性能的提升，从原来的O(n)到O(logn),

通过hash碰撞，让HashMap不断产生碰撞，那么相同的key的位置的链表就会不断增长，当对这个Hashmap的相应位置进行查询的时候，就会循环遍历这个超级大的链表，性能就会下降，所以改用红黑树

17、HashMap和HashTable区别

（1）线程安全性不同

HashMap是线程不安全的，HashTable是线程安全的，其中的方法是Synchronize的，在多线程并发的情况下，可以直接使用HashTabl，但是使用HashMap时必须自己增加同步处理。

（2）是否提供contains方法

HashMap只有containsValue和containsKey方法；HashTable有contains、containsKey和containsValue三个方法，其中contains和containsValue方法功能相同。

（3）key和value是否允许null值

Hashtable中，key和value都不允许出现null值。HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。

（4）数组初始化和扩容机制

HashTable在不指定容量的情况下的默认容量为11，而HashMap为16，Hashtable不要求底层数组的容量一定要为2的整数次幂，而HashMap则要求一定为2的整数次幂。

Hashtable扩容时，将容量变为原来的2倍加1，而HashMap扩容时，将容量变为原来的2倍。

HashMap：线程不安全，效率高，可以存null的key，只能有一个，null值，可以多个。没有contains方法  contains 的key  和value的方法。初始化长度 默认16，扩容  2的整数倍，2倍扩容
HashTable：线程安全，效率低，不可以存null的key，null值。有contains方法  contains 的key  和value的方法默认 11，没要求2的整数倍，2倍+1

18、线程的创建方式

1）继承Thread类创建线程

2）实现Runnable接口创建线程

3）使用Callable和Future创建线程

4）使用线程池创建线程

19、线程的状态转换有什么？（生命周期）

(1)新建状态(New) ：线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。
（2）就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。
（3）运行状态(Running)：线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。
（4）阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

• 等待阻塞 -- 通过调用线程的wait()方法，让线程等待某工作的完成。

• 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。

• 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join(）等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

（5）死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

20、Java 中有几种类型的流

21、请写出你最常见的5个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 数据类型转换异常。

22、谈谈你对反射的理解

（1）反射机制:

所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。

Java的反射机制的实现要借助于4个类：class，Constructor，Field，Method;

其中class代表的时类对 象，Constructor－类的构造器对象，Field－类的属性对象，Method－类的方法对象。通过这四个对象我们可以粗略的看到一个类的各个组 成部分。

（2）Java反射的作用：

在Java运行时环境中，对于任意一个类，可以知道这个类有哪些属性和方法。对于任意一个对象，可以调用它的任意一个方法。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Reflection）机制。

（3）Java 反射机制提供功能

在运行时判断任意一个对象所属的类。

在运行时构造任意一个类的对象。

在运行时判断任意一个类所具有的成员变量和方法。

在运行时调用任意一个对象的方法

23、什么是 java 序列化，如何实现 java 序列化？（北京）

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化的实现：将需要被序列化的类实现Serializable 接 口 ， 该 接 口 没 有 需 要 实 现 的 方 法 ， implements Serializable 只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用 ObjectOutputStream 对象的 writeObject(Object obj)方法就可以将参数为 obj 的对象写出(即保存其状态)，要恢复的话则用输入流。