1.面向对象可以解释下吗？都有哪些特性？

答：面向对象是一种思想，可以将复杂问题简单化，让我们从执行者变为了指挥者。面向对象的三大特性为：封装，继承与多态。

• 封装：将事物封装成一个类，减少耦合，隐藏细节。保留特定的接口与外界联系，当接口内部发生改变时，不会影响外部调用方。
• 继承：从一个已知的类中派生出一个新的类，新类可以拥有已知类的行为和属性，并且可以通过覆盖/重写来增强已知类的能力。
• 多态：多态的本质就是一个程序中存在多个同名的不同方法，主要通过三种方式来实现：
  • 通过子类对父类的覆盖来实现
  • 通过在一个类中对方法的重载来实现
  • 通过将子类对象作为父类对象使用来实现

关于继承：

我们需要注意Java中不支持多继承，即一个类只可以有一个直接父类存在。另外Java中的构造函数是不可以继承的，如果构造函数被private修饰，那么就是不明确的构造函数，该类是不可以被其它类继承的，具体原因我们可以先来看下Java中类的初始化顺序：

• 初始化父类中的静态成员变量和静态代码块
• 初始化子类中的静态成员变量和静态代码块
• 初始化父类中的普通成员变量和代码块，再执行父类的构造方法
• 初始化子类中的普通成员变量和代码块，再执行子类的构造方法

如果父类构造函数是私有（private）的，则初始化子类的时候不可以被执行，所以解释了为什么该类不可以被继承，也就是说其不允许有子类存在。我们知道，子类是由其父类派生产生的，那么子类有哪些特点呢？

• 子类拥有父类非private的属性和方法
• 子类可以添加自己的方法和属性，即对父类进行扩展
• 子类可以重新定义父类的方法，即方法的覆盖/重写

既然子类可以通过方法的覆盖/重写以及方法的重载来重新定义父类的方法，那么我们来看下什么是方法的覆盖/重写吧。（其实这也是一个高频的面试热身题目）
 

覆盖（@Override）：

覆盖也叫重写，是指子类和父类之间方法的一种关系，比如说父类拥有方法A，子类扩展了方法A并且添加了丰富的功能。那么我们就说子类覆盖或者重写了方法A，也就是说子类中的方法与父类中继承的方法有完全相同的返回值类型、方法名、参数个数以及参数类型。

重载：

重载是指在一个类中（包括父类）存在多个同名的不同方法，这些方法的参数个数，顺序以及类型不同均可以构成方法的重载。如果仅仅是修饰符、返回值、抛出的异常不同，那么这是2个相同的方法。

如果只有方法返回值不同，可以构成重载吗？

答：不可以。因为我们调用某个方法，有时候并不关心其返回值，这个时候编译器根据方法名和参数无法确定我们调用的是哪个方法。

举例：如果我们分别定义了如下的两个方法：

1 2	public String Test(String userName){ } public void Test(String userName){ }

在调用的时候，直接 Test(“XiaoMing”)； 那么就会存在歧义。

我们再来看看如何通过将子类对象作为父类对象使用来实现多态。

把不同的子类对象都当作父类对象来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。这样操作之后，父类的对象就可以根据当前赋值给它的子类对象的特性以不同的方式运作。

对象的引用型变量具有多态性，因为一个引用型变量可以指向不同形式的对象，即：子类的对象作为父类的对象来使用。在这里涉及到了向上转型和向下转型，我们分别介绍如下：
 

向上转型：
子类对象转为父类，父类可以是接口。
公式：Father f = new Son（）; Father是父类或接口，Son是子类。

向下转型：
父类对象转为子类。公式：Son s = (Son) f;

在向上转型的时候我们可以直接转，但是在向下转型的时候我们必须强制类型转换。并且，如案例中所述，该父类必须实际指向了一个子类对象才可强制类型向下转型，即其是以这种方式Father f = new Son（）创建的父类对象。若以Father f = new Father（）这种方式创建的父类对象，那么不可以转换向下转换为子类的Son对象，运行会报错，因为其本质还是一个Father对象。

JDK，JRE和JVM的区别与联系有哪些？

答：三者的基本概念可以概括如下：

• JDK（Java Development Kit）是一个开发工具包，是Java开发环境的核心组件，并且提供编译、调试和运行一个Java程序所需要的所有工具，可执行文件和二进制文件，是一个平台特定的软件
• JRE（Java Runtime Environment）是指Java运行时环境，是JVM的实现，提供了运行Java程序的平台。JRE包含了JVM，但是不包含Java编译器/调试器之类的开发工具
• JVM（Java Virtual Machine）是指Java虚拟机，当我们运行一个程序时，JVM负责将字节码转换为特定机器代码，JVM提供了内存管理/垃圾回收和安全机制等

如果你只是为了运行一下 Java 程序的话，那么你只需要安装 JRE 就可以了。如果你需要进行一些 Java 编程方面的工作，那么你就需要安装 JDK 了。但是，这不是绝对的。有时，即使您不打算在计算机上进行任何 Java 开发，仍然需要安装 JDK。例如，如果要使用 JSP 部署 Web 应用程序，那么从技术上讲，您只是在应用程序服务器中运行 Java 程序。那你为什么需要 JDK 呢？因为应用程序服务器会将 JSP 转换为 Java servlet，并且需要使用 JDK 来编译 servlet。

区别与联系：

• JDK是开发工具包，用来开发Java程序，而JRE是Java的运行时环境
• JDK和JRE中都包含了JVM
• JVM是Java编程的核心，独立于硬件和操作系统，具有平台无关性，而这也是Java程序可以一次编写，多处执行的原因

解析：

这也是一道Java面试中的基础题，因为我们学习Java都是从安装一个JDK开始的。上边有说Java程序具有平台无关性，可以做到一次编写，多处执行。那么Java的跨平台性是如何实现的呢？

我们知道，Java程序都是运行在Java虚拟机，即JVM之上。JVM屏蔽了底层操作系统和硬件的差异。我想大多数同学的Hello Word程序都是在文本文件中写的，然后我们通过javac来编译.java文件，生成了一个.class文件，最后再通过java命令来运行.class文件。其实这就是经历了一个先编译，再解释执行的过程，即先将java文件编译成了字节码.class文件，然后交给Java虚拟机解释成特定平台上的机器码。

另外一个与平台无关性的原因是，Java的语言规范中规定了基本数据类型的取值范围和行为在各个平台上是保持一致的。

我们做一个简单的总结：

Java语言的平台无关性是如何实现的？

• JVM屏蔽了操作系统和底层硬件的差异
• Java面向JVM编程，先编译生成字节码文件，然后交给JVM解释成机器码执行
• 通过规定基本数据类型的取值范围和行为

学习了上边的内容，聪明的你肯定可以回答面试官的如下问题了。

面试官：Java语言是编译型还是解释型语言？

答：Java的执行经历了编译和解释的过程，是一种先编译，后解释执行的语言，不可以单纯归到编译性或者解释性语言的类别中。高级编程语言按照程序的执行方式分为编译型和解释型两种。简单来说，编译型语言是指编译器针对特定的操作系统将源代码一次性翻译成可被该平台执行的机器码；解释型语言是指解释器对源程序逐行解释成特定平台的机器码并立即执行。

Java 语言既具有编译型语言的特征，也具有解释型语言的特征，因为 Java 程序要经过先编译，后解释两个步骤，由 Java 编写的程序需要先经过编译步骤，生成字节码（*.class 文件），这种字节码必须由 Java 解释器来解释执行。因此，我们可以认为 Java 语言编译与解释并存。

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

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

Java 程序从源代码到运行一般有下面 3 步：

我们需要格外注意的是 .class->机器码 这一步。在这一步 JVM 类加载器首先加载字节码文件，然后通过解释器逐行解释执行，这种方式的执行速度会相对比较慢。而且，有些方法和代码块是经常需要被调用的(也就是所谓的热点代码)，所以后面引进了 JIT 编译器，而 JIT 属于运行时编译。当 JIT 编译器完成第一次编译后，其会将字节码对应的机器码保存下来，下次可以直接使用。而我们知道，机器码的运行效率肯定是高于 Java 解释器的。这也解释了我们为什么经常会说 Java 是编译与解释共存的语言。

HotSpot 采用了惰性评估(Lazy Evaluation)的做法，根据二八定律，消耗大部分系统资源的只有那一小部分的代码（热点代码），而这也就是 JIT 所需要编译的部分。JVM 会根据代码每次被执行的情况收集信息并相应地做出一些优化，因此执行的次数越多，它的速度就越快。JDK 9 引入了一种新的编译模式 AOT(Ahead of Time Compilation)，它是直接将字节码编译成机器码，这样就避免了 JIT 预热等各方面的开销。JDK 支持分层编译和 AOT 协作使用。但是 ，AOT 编译器的编译质量是肯定比不上 JIT 编译器的。

Java 中的几种基本数据类型是什么？对应的包装类型是什么？各自占用多少字节呢？

Java 中有 8 种基本数据类型，分别为：

1. 6 种数字类型 ：byte、short、int、long、float、double
2. 1 种字符类型：char
3. 1 种布尔型：boolean。

这 8 种基本数据类型的默认值以及所占空间的大小如下：

基本类型	位数	字节	默认值
int	32	4	0
short	16	2	0
long	64	8	0L
byte	8	1	0
char	16	2	'u0000'
float	32	4	0f
double	64	8	0d
boolean	1		false

另外，对于 boolean，官方文档未明确定义，它依赖于 JVM 厂商的具体实现。逻辑上理解是占用 1 位，但是实际中会考虑计算机高效存储因素。

注意：

1. Java 里使用 long 类型的数据一定要在数值后面加上 L，否则将作为整型解析。
2. char a = 'h'char :单引号，String a = "hello" :双引号。

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

包装类型不赋值就是 Null ，而基本类型有默认值且不是 Null。

另外，这个问题建议还可以先从 JVM 层面来分析。

基本数据类型直接存放在 Java 虚拟机栈中的局部变量表中，而包装类型属于对象类型，我们知道对象实例都存在于堆中。相比于对象类型， 基本数据类型占用的空间非常小。

Java 泛型了解么？什么是类型擦除？介绍一下常用的通配符？

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

Java 的泛型是伪泛型，这是因为 Java 在运行期间，所有的泛型信息都会被擦掉，这也就是通常所说类型擦除 。

List<Integer> list = new ArrayList<>();list.add(12);
//这里直接添加会报错
list.add("a");
Class<? extends List> clazz = list.getClass();
Method add = clazz.getDeclaredMethod("add", Object.class);
//但是通过反射添加，是可以的
add.invoke(list, "kl");System.out.println(list);

hashCode()与 equals()

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

1)hashCode()介绍:

hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个 int 整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode()定义在 JDK 的 Object 类中，这就意味着 Java 中的任何类都包含有 hashCode() 函数。另外需要注意的是： Object 的 hashcode 方法是本地方法，也就是用 c 语言或 c++ 实现的，该方法通常用来将对象的 内存地址 转换为整数之后返回。

public native int hashCode();Copy to clipboardErrorCopied

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

2)为什么要有 hashCode？

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

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

3)为什么重写 equals 时必须重写 hashCode 方法？

如果两个对象相等，则 hashcode 一定也是相同的。两个对象相等,对两个对象分别调用 equals 方法都返回 true。但是，两个对象有相同的 hashcode 值，它们也不一定是相等的 。因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖。

hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

4)为什么两个对象有相同的 hashcode 值，它们也不一定是相等的？

在这里解释一位小伙伴的问题。以下内容摘自《Head Fisrt Java》。

因为 hashCode() 所使用的哈希算法也许刚好会让多个对象传回相同的哈希值。越糟糕的哈希算法越容易碰撞，但这也与数据值域分布的特性有关（所谓碰撞也就是指的是不同的对象得到相同的 hashCode )。

我们刚刚也提到了 HashSet,如果 HashSet 在对比的时候，同样的 hashcode 有多个对象，它会使用 equals() 来判断是否真的相同。也就是说 hashcode 只是用来缩小查找成本。

更多关于 hashcode() 和 equals() 的内容可以查看：Java hashCode() 和 equals()的若干问题解答

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

答：抽象类和接口的主要区别可以总结如下。

• 抽象类中可以没有抽象方法，也可以抽象方法和非抽象方法共存
• 接口中的方法在JDK8之前只能是抽象的，JDK8版本开始提供了接口中方法的default实现
• 抽象类和类一样是单继承的；接口可以实现多个父接口
• 抽象类中可以存在普通的成员变量；接口中的变量必须是static final类型的，必须被初始化，接口中只有常量，没有变量

抽象类和接口应该如何选择？分别在什么情况下使用呢？

答：根据抽象类和接口的不同之处，当我们仅仅需要定义一些抽象方法而不需要其余额外的具体方法或者变量的时候，我们可以使用接口。反之，则需要使用抽象类，因为抽象类中可以有非抽象方法和变量

JDK8中为什么会出现默认方法呢？

答：使用接口，使得我们可以面向抽象编程，但是其有一个缺点就是当接口中有改动的时候，需要修改所有的实现类。在JDK8中，为了给已经存在的接口增加新的方法并且不影响已有的实现，所以引入了接口中的默认方法实现。

默认方法允许在不打破现有继承体系的基础上改进接口，解决了接口的修改与现有的实现不兼容的问题。该特性在官方库中的应用是：给java.util.Collection接口添加新方法，如stream()、parallelStream()、forEach()和removeIf()等等。在我们实际开发中，接口的默认方法应该谨慎使用，因为在复杂的继承体系中，默认方法可能引起歧义和编译错误。

Java中的元注解有哪些？

答：Java中提供了4个元注解，元注解的作用是负责注解其它注解。

• @Target：说明注解所修饰的对象范围
• @Retention：（保留策略）保留策略定义了该注解被保留的时间长短SOURCE：表示在源文件中有效（即源文件保留）；CLASS：表示在class文件中有效（即class保留）RUNTIME：表示在运行时有效（即运行时保留）。例如@Retention(RetentionPolicy.RUNTIME)标注表示该注解在运行时有效。
• @Documented：该注解用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被javadoc此类的工具文档化。Documented是一个标记注解，没有成员。关键源码如下：
• @Inherited：该注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类

注解的作用：

代替繁杂的配置文件，简化开发。

当定义一个注解之后，还需要一个注解处理器来执行注解的内部逻辑。注解处理器定义了注解的处理逻辑，涉及到反射机制和线程机制等

说说Java中反射机制？

答： 反射机制是指在运行中，对于任意一个类，都能够知道这个类的所有属性和方法。对于任意一个对象，都能够调用它的任意一个方法和属性。即动态获取信息和动态调用对象方法的功能称为反射机制。

与反射相关的类：

• Class：表示类，用于获取类的相关信息
• Field：表示成员变量，用于获取实例变量和静态变量等
• Method：表示方法，用于获取类中的方法参数和方法类型等
• Constructor：表示构造器，用于获取构造器的相关参数和类型等

这里我们讲述下如何获取Class类吧，获取Class类有三种基本方式：

（1）通过类名称.class来获取Class类对象：

1 2 3

Class c = int.class； Class c = int[ ].class； Class c = String.class

（2）通过对象.getClass( )方法来获取Class类对象：

1	Class c = obj.getClass( );

（3）通过类名称加载类Class.forName( )，只要有类名称就可以得到Class：

1	Class c = Class.forName(“cn.ywq.Demo”);

反射机制优缺点

• 优点 ： 可以让咱们的代码更加灵活、为各种框架提供开箱即用的功能提供了便利
• 缺点 ：让我们在运行时有了分析操作类的能力，这同样也增加了安全问题。比如可以无视泛型参数的安全检查（泛型参数的安全检查发生在编译时）。另外，反射的性能也要稍差点，不过，对于框架来说实际是影响不大的。Java Reflection: Why is it so slow?

在一个静态方法内调用一个非静态成员为什么是非法的?

这个需要结合 JVM 的相关知识，静态方法是属于类的，在类加载的时候就会分配内存，可以通过类名直接访问。而非静态成员属于实例对象，只有在对象实例化之后才存在，然后通过类的实例对象去访问。在类的非静态成员不存在的时候静态成员就已经存在了，此时调用在内存中还不存在的非静态成员，属于非法操作。

深拷贝 vs 浅拷贝

1. 浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。
2. 深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。

String StringBuffer 和 StringBuilder 的区别是什么? String 为什么是不可变的?

可变性

简单的来说：String 类中使用 final 关键字修饰字符数组来保存字符串，private final char value[]，所以String 对象是不可变的。

在 Java 9 之后，String 、StringBuilder 与 StringBuffer 的实现改用 byte 数组存储字符串 private final byte[] value

而 StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串char[]value 但是没有用 final 关键字修饰，所以这两种对象都是可变的。

StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是AbstractStringBuilder 实现的，大家可以自行查阅源码。

AbstractStringBuilder.java

abstract class AbstractStringBuilder implements Appendable, CharSequence {/*** The value is used for character storage.*/char[] value;

线程安全性

String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。

性能

每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。

对于三者使用的总结：

1. 操作少量的数据: 适用 String
2. 单线程操作字符串缓冲区下操作大量数据: 适用 StringBuilder
3. 多线程操作字符串缓冲区下操作大量数据: 适用 StringBuffer

try-catch-finally

• try块： 用于捕获异常。其后可接零个或多个 catch 块，如果没有 catch 块，则必须跟一个 finally 块。
• catch块： 用于处理 try 捕获到的异常。
• finally 块： 无论是否捕获或处理异常，finally 块里的语句都会被执行。当在 try 块或 catch 块中遇到 return 语句时，finally 语句块将在方法返回之前被执行。

在以下 3 种特殊情况下，finally 块不会被执行：

1. 在 try 或 finally块中用了 System.exit(int)退出程序。但是，如果 System.exit(int) 在异常语句之后，finally 还是会被执行
2. 程序所在的线程死亡。
3. 关闭 CPU。

注意： 当 try 语句和 finally 语句中都有 return 语句时，在方法返回之前，finally 语句的内容将被执行，并且 finally 语句的返回值将会覆盖原始的返回值

使用 try-with-resources 来代替try-catch-finally

1. 适用范围（资源的定义）： 任何实现 java.lang.AutoCloseable或者 java.io.Closeable 的对象
2. 关闭资源和 finally 块的执行顺序： 在 try-with-resources 语句中，任何 catch 或 finally 块在声明的资源关闭后运行

《Effecitve Java》中明确指出：

面对必须要关闭的资源，我们总是应该优先使用 try-with-resources 而不是try-finally。随之产生的代码更简短，更清晰，产生的异常对我们也更有用。try-with-resources语句让我们更容易编写必须要关闭的资源的代码，若采用try-finally则几乎做不到这点。

Java 中类似于InputStream、OutputStream 、Scanner 、PrintWriter等的资源都需要我们调用close()方法来手动关闭，一般情况下我们都是通过try-catch-finally语句来实现这个需求，如下：

        //读取文本文件的内容Scanner scanner = null;try {scanner = new Scanner(new File("D://read.txt"));while (scanner.hasNext()) {System.out.println(scanner.nextLine());}} catch (FileNotFoundException e) {e.printStackTrace();} finally {if (scanner != null) {scanner.close();}}Copy to clipboardErrorCopied

使用 Java 7 之后的 try-with-resources 语句改造上面的代码:

try (Scanner scanner = new Scanner(new File("test.txt"))) {while (scanner.hasNext()) {System.out.println(scanner.nextLine());}
} catch (FileNotFoundException fnfe) {fnfe.printStackTrace();
}Copy to clipboardErrorCopied

当然多个资源需要关闭的时候，使用 try-with-resources 实现起来也非常简单，如果你还是用try-catch-finally可能会带来很多问题。

通过使用分号分隔，可以在try-with-resources块中声明多个资源。

try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")))) {int b;while ((b = bin.read()) != -1) {bout.write(b);}}catch (IOException e) {e.printStackTrace();}

既然有了字节流,为什么还要有字符流?

问题本质想问：不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？

回答：字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还算是非常耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。所以， I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。

逃逸分析：

逃逸分析的基本行为就是分析对象动态作用域，当一个对象在方法中被定义后，它可能被外部方法所引用，例如作为调用参数传递到其他地方中，称为方法逃逸。JIT编译器的优化包括如下：

• 同布省略：也就是锁消除，当JIT编译器判断不会产生并发问题，那么会将同步synchronized去掉
• 标量替换

标量替换

简单地说，就是用标量替换聚合量。这样做的好处是如果创建的对象并未用到其中的全部变量，则可以节省一定的内存。对于代码执行而言，无需去找对象的引用，也会更快一些

1. 标量是指不可分割的量，如java中基本数据类型和reference类型，相对的一个数据可以继续分解，称为聚合量；

2. 如果把一个对象拆散，将其成员变量恢复到基本类型来访问就叫做标量替换；

3. 如果逃逸分析发现一个对象不会被外部访问，并且该对象可以被拆散，那么经过优化之后，并不直接生成该对象，而是在栈上创建若干个成员变量；

通过-XX:+EliminateAllocations可以开启标量替换， -XX:+PrintEliminateAllocations查看标量替换情况。

我们先来解释下标量和聚合量的基本概念。

• 标量（Scalar）是指一个无法再分解成更小的数据的数据。Java中的原始数据类型就是标量。

• 聚合量（Aggregate）是还可以分解的数据。Java中的对象就是聚合量，因为他可以分解成其他聚合量和标量。

在JIT阶段，如果经过逃逸分析，发现一个对象不会被外界访问的话，那么经过JIT优化，就会把这个对象拆解成若干个其中包含的若干个成员变量来代替。这个过程就是标量替换。标量替换的好处就是对象可以不在堆内存进行分配，为栈上分配提供了良好的基础。

 

那么逃逸分析技术存在哪些缺点呢？

    技术不是特别成熟，分析的过程也很耗时，如果没有一个对象是不逃逸的，那么就得不偿失了。

对象分配流程：

Java对象内存分配流程_夕灬颜的博客-CSDN博客_java 对象内存分配过程

Java对象分配简要流程 - SegmentFault 思否https://segmentfault.com/a/1190000004606059

java中的伪共享？如何解决：

Java中的伪共享(false sharing) - 简书 (jianshu.com)