关于java:2021年最新Java面试题及答案整理-基础篇一

1.什么是Java

Java是一门面向对象的高级编程语言，不仅排汇了C++语言的各种长处，比方继承了C++语言面向对象的技术外围。还摒弃了C++里难以了解的多继承、指针等概念，，同时也减少了垃圾回收机制，开释掉不被应用的内存空间，解决了治理内存空间的懊恼。

因而Java语言具备功能强大和简略易用两个特色。Java语言作为动态面向对象编程语言的代表，极好地实现了面向对象实践，容许程序员以优雅的思维形式进行简单的编程。

2. Java的特点有哪些

Java 语言是一种分布式的面向对象语言，具备面向对象、平台无关性、简略性、解释执行、多线程、安全性等很多特点，上面针对这些特点进行逐个介绍。

1. 面向对象

Java 是一种面向对象的语言，它对对象中的类、对象、继承、封装、多态、接口、包等均有很好的反对。为了简略起见，Java 只反对类之间的单继承，然而能够应用接口来实现多继承。应用 Java 语言开发程序，须要采纳面向对象的思维设计程序和编写代码。

2. 平台无关性

平台无关性的具体表现在于，Java 是“一次编写，到处运行（Write Once，Run any Where）”的语言，因而采纳 Java 语言编写的程序具备很好的可移植性，而保障这一点的正是 Java 的虚拟机机制。在引入虚拟机之后，Java 语言在不同的平台上运行不须要从新编译。

Java 语言应用 Java 虚拟机机制屏蔽了具体平台的相干信息，使得 Java 语言编译的程序只需生成虚拟机上的指标代码，就能够在多种平台上不加批改地运行。

3. 简略性

Java 语言的语法与 C 语言和 C++ 语言很相近，使得很多程序员学起来很容易。对 Java 来说，它舍弃了很多 C++ 中难以了解的个性，如操作符的重载和多继承等，而且 Java 语言不应用指针，退出了垃圾回收机制，解决了程序员须要治理内存的问题，使编程变得更加简略。

4. 解释执行

Java 程序在 Java 平台运行时会被编译成字节码文件，而后能够在有 Java 环境的操作系统上运行。在运行文件时，Java 的解释器对这些字节码进行解释执行，执行过程中须要退出的类在连贯阶段被载入到运行环境中。

5. 多线程

Java 语言是多线程的，这也是 Java 语言的一大个性，它必须由 Thread 类和它的子类来创立。Java 反对多个线程同时执行，并提供多线程之间的同步机制。任何一个线程都有本人的 run() 办法，要执行的办法就写在 run() 办法体内。

6. 分布式

Java 语言反对 Internet 利用的开发，在 Java 的根本利用编程接口中就有一个网络应用编程接口，它提供了网络应用编程的类库，包含 URL、URLConnection、Socket 等。Java 的 RIM 机制也是开发分布式应用的重要伎俩。

7. 健壮性

Java 的强类型机制、异样解决、垃圾回收机制等都是 Java 健壮性的重要保障。对指针的抛弃是 Java 的一大提高。另外，Java 的异样机制也是健壮性的一大体现。

8. 高性能

Java 的高性能次要是绝对其余高级脚本语言来说的，随着 JIT（Just in Time）的倒退，Java 的运行速度也越来越高。

9. 安全性

Java 通常被用在网络环境中，为此，Java 提供了一个平安机制以避免恶意代码的攻打。除了 Java 语言具备许多的平安个性以外，Java 还对通过网络下载的类减少一个平安防备机制，调配不同的名字空间以防代替本地的同名类，并蕴含平安管理机制。

Java 语言的泛滥个性使其在泛滥的编程语言中占有较大的市场份额，Java 语言对对象的反对和弱小的 API 使得编程工作变得更加容易和快捷，大大降低了程序的开发成本。Java 的“一次编写，到处执行”正是它吸引泛滥商家和编程人员的一大劣势。

24W字Java面试手册下载地址：https://shimo.im/docs/Wyj8QRp...

3. JDK和JRE和JVM的区别

1. JDK

JDK（Java SE Development Kit），Java规范的开发包，提供了编译、运行Java程序所须要的各种工具和资源，包含了Java编译器、Java运行时环境、以及罕用的Java类库等。

2. JRE

JRE（Java Runtime Environment），Java运行时环境，用于解释执行Java的字节码文件。普通用户只须要装置JRE来运行Java程序即可，而作为一名程序员必须装置JDK，来编译、调试程序。

3. JVM

JVM（Java Virtual Mechinal），Java虚拟机，是JRE的一部分。它是整个Java实现跨平台的外围，负责解释执行字节码文件，是可运行Java字节码文件的虚构计算机。所有平台上的JVM向编译器提供雷同的接口，而编译器只须要面向虚拟机，生成虚拟机能辨认的代码，而后由虚拟机来解释执行。

当应用Java编译器编译Java程序时，生成的是与平台无关的字节码，这些字节码只面向JVM。也就是说JVM是运行Java字节码的虚拟机。

不同平台的JVM是不同的，然而他们都提供了雷同的接口。JVM是Java程序跨平台的要害局部，只有为不同平台实现了雷同的虚拟机，编译后的Java字节码就能够在该平台上运行。

为什么要采纳字节码：

在 Java 中，JVM 能够了解的代码就叫做字节码（即Java源代码通过虚拟机编译器编译后扩大名为 .class 的文件），它不面向任何特定的处理器，只面向虚拟机。Java 语言通过字节码的形式，在肯定水平上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比拟高效，而且，因为字节码并不针对一种特定的机器，因而，Java 程序毋庸从新编译便可在多种不同操作系统的计算机上运行。

什么是跨平台：

所谓跨平台性，是指java语言编写的程序，一次编译后，能够在多个零碎平台上运行。
实现原理：Java程序是通过java虚拟机在零碎平台上运行的，只有该零碎能够装置相应的java虚拟机，该零碎就能够运行java程序。

Java 程序从源代码到运行须要三步：

4. 总结

JDK 用于开发，JRE 用于运行java程序；如果只是运行Java程序，能够只装置JRE，无序装置JDK。
JDk蕴含JRE，JDK 和 JRE 中都蕴含 JVM。
JVM 是 Java 编程语言的外围并且具备平台独立性。

4. Oracle JDK 和 OpenJDK 的比照

Oracle JDK版本将每三年公布一次，而OpenJDK版本每三个月公布一次；
OpenJDK 是一个参考模型并且是齐全开源的，而Oracle JDK是OpenJDK的一个实现，并不是齐全开源的；
Oracle JDK 比 OpenJDK 更稳固。OpenJDK和Oracle JDK的代码简直雷同，但Oracle JDK有更多的类和一些谬误修复。因而，如果您想开发企业/商业软件，我建议您抉择Oracle JDK，因为它通过了彻底的测试和稳固。某些状况下，有些人提到在应用OpenJDK 可能会遇到了许多应用程序解体的问题，然而，只需切换到Oracle JDK就能够解决问题；
在响应性和JVM性能方面，Oracle JDK与OpenJDK相比提供了更好的性能；
Oracle JDK不会为行将公布的版本提供长期反对，用户每次都必须通过更新到最新版本取得反对来获取最新版本；
Oracle JDK依据二进制代码许可协定取得许可，而OpenJDK依据GPL v2许可取得许可。

5. Java有哪些数据类型

Java中有 8 种根本数据类型，别离为：

6 种数字类型（四个整数形，两个浮点型）：byte、short、int、long、float、double
1 种字符类型：char
1 种布尔型：boolean。

byte：

byte 数据类型是8位、有符号的，以二进制补码示意的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，次要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
例子：byte a = 100，byte b = -50。

short：

short 数据类型是 16 位、有符号的以二进制补码示意的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
Short 数据类型也能够像 byte 那样节俭空间。一个short变量是int型变量所占空间的二分之一；
默认值是 0；
例子：short s = 1000，short r = -20000。

int：

int 数据类型是32位、有符号的以二进制补码示意的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
个别地整型变量默认为 int 类型；
默认值是 0 ；
例子：int a = 100000, int b = -200000。

long：

留神：Java 里应用 long 类型的数据肯定要在数值前面加上 L，否则将作为整型解析
long 数据类型是 64 位、有符号的以二进制补码示意的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型次要应用在须要比拟大整数的零碎上；
默认值是 0L；
例子： long a = 100000L，Long b = -200000L。
"L"实践上不分大小写，然而若写成"l"容易与数字"1"混同，不容易辩白。所以最好大写。

float：

float 数据类型是单精度、32位、合乎IEEE 754规范的浮点数；
float 在贮存大型浮点数组的时候可节俭内存空间；
默认值是 0.0f；
浮点数不能用来示意准确的值，如货币；
例子：float f1 = 234.5f。

double：

double 数据类型是双精度、64 位、合乎IEEE 754规范的浮点数；
浮点数的默认类型为double类型；
double类型同样不能示意准确的值，如货币；
默认值是 0.0d；
例子：double d1 = 123.4。

char：

char类型是一个繁多的 16 位 Unicode 字符；
最小值是 \u0000（即为 0）；
最大值是 \uffff（即为 65535）；
char 数据类型能够贮存任何字符；
例子：char letter = 'A';（单引号）

boolean：

boolean数据类型示意一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标记来记录 true/false 状况；
默认值是 false；
例子：boolean one = true。

这八种根本类型都有对应的包装类别离为：Byte、Short、Integer、Long、Float、Double、Character、Boolean

类型名称	字节、位数	最小值	最大值	默认值	例子
byte字节	1字节，8位	-128（-2^7）	127（2^7-1）	0	byte a = 100，byte b = -50
short短整型	2字节，16位	-32768（-2^15）	32767（2^15 - 1）	0	short s = 1000，short r = -20000
int整形	4字节，32位	-2,147,483,648（-2^31）	2,147,483,647（2^31 - 1）	0	int a = 100000, int b = -200000
lang长整型	8字节，64位	-9,223,372,036,854,775,808（-2^63）	9,223,372,036,854,775,807（2^63 -1）	0L	long a = 100000L，Long b = -200000L
double双精度	8字节，64位		double类型同样不能示意准确的值，如货币	0.0d	double d1 = 123.4
float单精度	4字节，32位	在贮存大型浮点数组的时候可节俭内存空间	不同统计精准的货币值	0.0f	float f1 = 234.5f
char字符	2字节，16位	\u0000（即为0）	\uffff（即为65,535）	能够贮存任何字符	char letter = 'A';
boolean布尔	返回true和false两个值	这种类型只作为一种标记来记录 true/false 状况；	只有两个取值：true 和 false；	false	boolean one = true

6. Java中援用数据类型有哪些，它们与根本数据类型有什么区别？

援用数据类型分3种：类，接口，数组；

简略来说,只有不是根本数据类型.都是援用数据类型。那他们有什么不同呢？

1、从概念方面来说

1,根本数据类型:变量名指向具体的数值

2,援用数据类型:变量名不是指向具体的数值,而是指向存数据的内存地址,.也及时hash值

2、从内存的构建方面来说(内存中,有堆内存和栈内存两者)

1,根本数据类型:被创立时,在栈内存中会被划分出肯定的内存,并将数值存储在该内存中.

2,援用数据类型:被创立时,首先会在栈内存中调配一块空间,而后在堆内存中也会调配一块具体的空间用来存储数据的具体信息,即hash值,而后由栈中援用指向堆中的对象地址.

举个例子

//根本数据类型作为办法参数被调用public class Main{    public static void main(String[] args){        //根本数据类型        int i = 1;        int j = 1;        double d = 1.2;         //援用数据类型        String str = "Hello";        String str1= "Hello";    }}

由上图可知，根本数据类型中会存在两个雷同的1，而援用型类型就不会存在雷同的数据。
如果"hello"的援用地址是xxxxx1，申明str变量并其赋值"hello"实际上就是让str变量援用了"hello"的内存地址，这个内存地址就存储在堆内存中，是不会扭转的，当再次申明变量str1也是赋值为"hello"时，此时就会在堆内存中查问是否有"hello"这个地址，如果堆内存中曾经存在这个地址了，就不会再次创立了，而是让str1变量也指向xxxxx1这个地址，如果没有的话，就会从新创立一个地址给str1变量。

7. 从应用方面来说

1,根本数据类型:判断数据是否相等，用==和!=判断。
2,援用数据类型:判断数据是否相等，用equals()办法,==和!=是比拟数值的。而equals()办法是比拟内存地址的。

补充：数据类型抉择的准则

如果要示意整数就应用int，示意小数就应用double；
如果要形容日期工夫数字或者示意文件（或内存）大小用long；
如果要实现内容传递或者编码转换应用byte；
如果要实现逻辑的管制，能够应用booleam；
如果要应用中文，应用char防止中文乱码；
如果依照保留范畴：byte < int < long < double;

24W字Java面试手册下载地址：https://shimo.im/docs/Wyj8QRp...

8. Java中的主动装箱与拆箱

什么是主动装箱拆箱？

从上面的代码中就能够看到装箱和拆箱的过程

//主动装箱Integer total = 99;//自定拆箱int totalprim = total;

装箱就是主动将根本数据类型转换为包装器类型；拆箱就是主动将包装器类型转换为根本数据类型。

在Java SE5之前，主动装箱要这样写：Integer i = new` `Integer(10``);

对于Java的主动装箱和拆箱，咱们看看源码编译后的class文件，其实装箱调用包装类的valueOf办法，拆箱调用的是Integer.Value办法，上面就是变编译后的代码：

常见面试一：

这段代码输入什么？

public class Main {    public static void main(String[] args) {                 Integer i1 = 100;        Integer i2 = 100;        Integer i3 = 200;        Integer i4 = 200;                 System.out.println(i1==i2);        System.out.println(i3==i4);    }}

答案是:

truefalse

为什么会呈现这样的后果？输入结果表明i1和i2指向的是同一个对象，而i3和i4指向的是不同的对象。此时只需一看源码便知到底，上面这段代码是Integer的valueOf办法的具体实现：

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

private static class IntegerCache {        static final int high;        static final Integer cache[];        static {            final int low = -128;            // high value may be configured by property            int h = 127;            if (integerCacheHighPropValue != null) {                // Use Long.decode here to avoid invoking methods that                // require Integer's autoboxing cache to be initialized                int i = Long.decode(integerCacheHighPropValue).intValue();                i = Math.max(i, 127);                // Maximum array size is Integer.MAX_VALUE                h = Math.min(i, Integer.MAX_VALUE - -low);            }            high = h;            cache = new Integer[(high - low) + 1];            int j = low;            for(int k = 0; k < cache.length; k++)                cache[k] = new Integer(j++);        }        private IntegerCache() {}    }

从这2段代码能够看出，在通过valueOf办法创立Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中曾经存在的对象的援用；否则创立一个新的Integer对象。

下面的代码中i1和i2的数值为100，因而会间接从cache中取曾经存在的对象，所以i1和i2指向的是同一个对象，而i3和i4则是别离指向不同的对象。

常见面试二：

public class Main {    public static void main(String[] args) {                 Double i1 = 100.0;        Double i2 = 100.0;        Double i3 = 200.0;        Double i4 = 200.0;                 System.out.println(i1==i2);        System.out.println(i3==i4);    }}

输入后果为：

falsefalse

起因很简略，在某个范畴内的整型数值的个数是无限的，而浮点数却不是。

9. 为什么要有包装类型？

让根本数据类型也具备对象的特色

根本类型	包装器类型
boolean	Boolean
char	Character
int	Integer
byte	Byte
short	Short
long	Long
float	Float
double	Double

为了让根本类型也具备对象的特色，就呈现了包装类型（如咱们在应用汇合类型Collection时就肯定要应用包装类型而非根本类型）因为容器都是装object的，这是就须要这些根本类型的包装器类了。

主动装箱：new Integer(6);，底层调用:Integer.valueOf(6)

主动拆箱: int i = new Integer(6);，底层调用i.intValue();办法实现。

Integer i  = 6;Integer j = 6;System.out.println(i==j);

答案在上面这段代码中找：

public static Integer valueOf(int i) {    if (i >= IntegerCache.low && i <= IntegerCache.high)        return IntegerCache.cache[i + (-IntegerCache.low)];    return new Integer(i);}

二者的区别：

申明形式不同：根本类型不应用new关键字，而包装类型须要应用new关键字来在堆中调配存储空间；
存储形式及地位不同：根本类型是间接将变量值存储在栈中，而包装类型是将对象放在堆中，而后通过援用来应用；
初始值不同：根本类型的初始值如int为0，boolean为false，而包装类型的初始值为null；
应用形式不同：根本类型间接赋值间接应用就好，而包装类型在汇合如Collection、Map时会应用到。

24W字Java面试手册下载地址：https://shimo.im/docs/Wyj8QRp...

10. a=a+b与a+=b有什么区别吗?

+=操作符会进行隐式主动类型转换,此处a+=b隐式的将加操作的后果类型强制转换为持有后果的类型,而a=a+b则不会主动进行类型转换.如：

byte a = 127;byte b = 127;b = a + b; // 报编译谬误:cannot convert from int to byteb += a;

以下代码是否有错,有的话怎么改？

short s1= 1;s1 = s1 + 1;

有谬误.short类型在进行运算时会主动晋升为int类型,也就是说s1+1的运算后果是int类型,而s1是short类型,此时编译器会报错.

正确写法：

short s1= 1; s1 += 1;

+=操作符会对左边的表达式后果强转匹配右边的数据类型,所以没错.

11. 能将 int 强制转换为 byte 类型的变量吗？如果该值大于 byte 类型的范畴，将会呈现什么景象？

咱们能够做强制转换，然而 Java 中 int 是 32 位的，而 byte 是 8 位的，所以，如果强制转化，int 类型的高 24 位将会被抛弃，因为byte 类型的范畴是从 -128 到 127

12. Java程序是如何执行的

咱们日常的工作中都应用开发工具（IntelliJ IDEA 或 Eclipse 等）能够很不便的调试程序，或者是通过打包工具把我的项目打包成 jar 包或者 war 包，放入 Tomcat 等 Web 容器中就能够失常运行了，但你有没有想过 Java 程序外部是如何执行的？其实不论是在开发工具中运行还是在 Tomcat 中运行，Java 程序的执行流程根本都是雷同的，它的执行流程如下：

先把 Java 代码编译成字节码，也就是把 .java 类型的文件编译成 .class 类型的文件。这个过程的大抵执行流程：Java 源代码 -> 词法分析器 -> 语法分析器 -> 语义分析器 -> 字符码生成器 -> 最终生成字节码，其中任何一个节点执行失败就会造成编译失败；
把 class 文件搁置到 Java 虚拟机，这个虚拟机通常指的是 Oracle 官网自带的 Hotspot JVM；
Java 虚拟机应用类加载器（Class Loader）装载 class 文件；
类加载实现之后，会进行字节码效验，字节码效验通过之后 JVM 解释器会把字节码翻译成机器码交由操作系统执行。但不是所有代码都是解释执行的，JVM 对此做了优化，比方，以 Hotspot 虚拟机来说，它自身提供了 JIT（Just In Time）也就是咱们通常所说的动静编译器，它可能在运行时将热点代码编译为机器码，这个时候字节码就变成了编译执行。Java 程序执行流程图如下：

13. final 在 Java 中有什么作用？

final作为Java中的关键字能够用于三个中央。用于润饰类、类属性和类办法。

特色：但凡援用final关键字的中央皆不可批改！

(1)润饰类：示意该类不能被继承；

(2)润饰办法：示意办法不能被重写；

(3)润饰变量：示意变量只能一次赋值当前值不能被批改（常量）。

14. final有哪些用法?

final也是很多面试喜爱问的中央,但我感觉这个问题很无聊,通常能答复下以下5点就不错了:

被final润饰的类不能够被继承
被final润饰的办法不能够被重写
被final润饰的变量不能够被扭转.如果润饰援用,那么示意援用不可变,援用指向的内容可变.
被final润饰的办法,JVM会尝试将其内联,以进步运行效率
被final润饰的常量,在编译阶段会存入常量池中.

除此之外,编译器对final域要恪守的两个重排序规定更好:

在构造函数内对一个final域的写入,与随后把这个被结构对象的援用赋值给一个援用变量,这两个操作之间不能重排序首次读一个蕴含final域的对象的援用,与随后首次读这个final域,这两个操作之间不能重排序.

15. static都有哪些用法?

所有的人都晓得static关键字这两个根本的用法:动态变量和静态方法.也就是被static所润饰的变量/办法都属于类的动态资源,类实例所共享.

除了动态变量和静态方法之外,static也用于动态块,多用于初始化操作:

public calss PreCache{    static{        //执行相干操作    }}

此外static也多用于润饰外部类,此时称之为动态外部类.

最初一种用法就是动态导包,即import static.import static是在JDK 1.5之后引入的新个性,能够用来指定导入某个类中的动态资源,并且不须要应用类名,能够间接应用资源名,比方:

import static java.lang.Math.*; public class Test{     public static void main(String[] args){        //System.out.println(Math.sin(20));传统做法        System.out.println(sin(20));    }}

16. static和final区别

关键词	润饰物	影响
final	变量	调配到常量池中，程序不可扭转其值
final	办法	子类中将不能被重写
final	类	不能被继承
static	变量	调配在内存堆上，援用都会指向这一个地址而不会从新分配内存
static	办法块	虚拟机优先加载
static	类	能够间接通过类来调用而不须要new

17. 为什么有些java类要实现Serializable接口

为了网络进行传输或者长久化

什么是序列化

将对象的状态信息转换为能够存储或传输的模式的过程

除了实现Serializable接口还有什么序列化形式

Json序列化
FastJson序列化
ProtoBuff序列化

18. 什么是java序列化，如何实现java序列化？或者请解释Serializable接口的作用。

咱们有时候将一个java对象变成字节流的模式传出去或者从一个字节流中复原成一个java对象，例如，要将java对象存储到硬盘或者传送给网络上的其余计算机，这个过程咱们能够本人写代码去把一个java对象变成某个格局的字节流再传输。

然而，jre自身就提供了这种反对，咱们能够调用OutputStream的writeObject办法来做，如果要让java帮咱们做，要被传输的对象必须实现serializable接口，这样，javac编译时就会进行非凡解决，编译的类才能够被writeObject办法操作，这就是所谓的序列化。须要被序列化的类必须实现Serializable接口，该接口是一个mini接口，其中没有须要实现办法，implements Serializable只是为了标注该对象是可被序列化的。

例如，在web开发中，如果对象被保留在了Session中，tomcat在重启时要把Session对象序列化到硬盘，这个对象就必须实现Serializable接口。如果对象要通过分布式系统进行网络传输，被传输的对象就必须实现Serializable接口。

19. 什么是外部类？外部类的作用

外部类的定义

将一个类定义在另一个类外面或者一个办法外面，这样的类称为外部类。

外部类的作用：

1、成员外部类成员外部类能够无条件拜访外部类的所有成员属性和成员办法（包含private成员和动态成员）。当成员外部类领有和外部类同名的成员变量或者办法时，会产生暗藏景象，即默认状况下拜访的是成员外部类的成员。

2、部分外部类部分外部类是定义在一个办法或者一个作用域外面的类，它和成员外部类的区别在于部分外部类的拜访仅限于办法内或者该作用域内。

3、匿名外部类匿名外部类就是没有名字的外部类

4、动态外部类指被申明为static的外部类，他能够不依赖外部类而实例，而通常的外部类须要实例化外部类，从而实例化。动态外部类不能够有与外部类有雷同的类名。不能拜访外部类的一般成员变量，然而能够拜访动态成员变量和静态方法（包含公有类型）一个动态外部类去掉static 就是成员外部类，他能够自在的援用外部类的属性和办法，无论是动态还是非动态。然而不能够有动态属性和办法

24W字Java面试手册下载地址：https://shimo.im/docs/Wyj8QRp...

20. Excption与Error包构造

Java可抛出(Throwable)的构造分为三种类型：被查看的异样(CheckedException)，运行时异样(RuntimeException)，谬误(Error)。

1、运行时异样

定义：RuntimeException及其子类都被称为运行时异样。

特点：Java编译器不会查看它。也就是说，当程序中可能呈现这类异样时，假使既"没有通过throws申明抛出它"，也"没有用try-catch语句捕捉它"，还是会编译通过。例如，除数为零时产生的ArithmeticException异样，数组越界时产生的IndexOutOfBoundsException异样，fail-fast机制产生的ConcurrentModificationException异样（java.util包上面的所有的汇合类都是疾速失败的，“疾速失败”也就是fail-fast，它是Java汇合的一种谬误检测机制。当多个线程对汇合进行构造上的扭转的操作时，有可能会产生fail-fast机制。记住是有可能，而不是肯定。例如：假如存在两个线程（线程1、线程2），线程1通过Iterator在遍历汇合A中的元素，在某个时候线程2批改了汇合A的构造（是构造下面的批改，而不是简略的批改汇合元素的内容），那么这个时候程序就会抛出 ConcurrentModificationException 异样，从而产生fail-fast机制，这个错叫并发批改异样。Fail-safe，java.util.concurrent包上面的所有的类都是平安失败的，在遍历过程中，如果曾经遍历的数组上的内容变动了，迭代器不会抛出ConcurrentModificationException异样。如果未遍历的数组上的内容产生了变动，则有可能反映到迭代过程中。这就是ConcurrentHashMap迭代器弱统一的体现。ConcurrentHashMap的弱一致性次要是为了晋升效率，是一致性与效率之间的一种衡量。要成为强一致性，就失去处应用锁，甚至是全局锁，这就与Hashtable和同步的HashMap一样了。）等，都属于运行时异样。

常见的五种运行时异样：

ClassCastException（类转换异样）
IndexOutOfBoundsException（数组越界）
NullPointerException（空指针异样）
ArrayStoreException（数据存储异样，操作数组是类型不统一）
BufferOverflowException

2、被查看异样

定义：Exception类自身，以及Exception的子类中除了"运行时异样"之外的其它子类都属于被查看异样。

特点： Java编译器会查看它。此类异样，要么通过throws进行申明抛出，要么通过try-catch进行捕捉解决，否则不能通过编译。例如，CloneNotSupportedException就属于被查看异样。

当通过clone()接口去克隆一个对象，而该对象对应的类没有实现Cloneable接口，就会抛出CloneNotSupportedException异样。被查看异样通常都是能够复原的。如：

IOException

FileNotFoundException

SQLException

被查看的异样实用于那些不是因程序引起的谬误状况，比方：读取文件时文件不存在引发的FileNotFoundException。然而，不被查看的异样通常都是因为蹩脚的编程引起的，比方：在对象援用时没有确保对象非空而引起的NullPointerException。

3、谬误

定义 : Error类及其子类。

特点 : 和运行时异样一样，编译器也不会对谬误进行查看。

当资源有余、束缚失败、或是其它程序无奈持续运行的条件产生时，就产生谬误。程序自身无奈修复这些谬误的。例如，VirtualMachineError就属于谬误。呈现这种谬误会导致程序终止运行。OutOfMemoryError、ThreadDeath。

Java虚拟机标准规定JVM的内存分为了好几块，比方堆，栈，程序计数器，办法区等

24W字Java面试手册下载地址：https://shimo.im/docs/Wyj8QRp...