核心Java面试问题可帮助您准备基于Java的面试。无论您是新手还是经验丰富的专业人士，core Java在任何Java/JEE面试中都扮演着至关重要的角色。

核心Java是大多数面试中最受欢迎的领域，在决定面试结果的过程中起着至关重要的作用。

这篇文章直接来自我14年以上的Java编程经验和丰富的面试经验。Java 16最近发布了，我更新了这篇文章，包括了最新版本中的一些问题。

Java核心访谈问答

我已经为字符串、集合和多线程等特定主题写了很多关于Java面试问题 的文章。

1.JAVA字符串访谈Questions 2.JAVA线程访谈Questions 3.JAVA集合访谈Questions 4.JAVA异常访谈Questions

在这里，我提供了一些重要的Java面试核心问题以及您应该知道的答案。你可以把这篇文章加入书签，在去参加面试之前复习一下你的知识。

1.Java 14版本有哪些重要特性？

Java 14于2020年3月17日发布。这是一个非LTS版本。一些特定于开发人员的代码JAVA 14 Features]包括：

1.转换表达式--JEP 361 2.Instanceof运算符的模式匹配改进-预览功能，JEP 305 3.有用的NullPointerException消息--358年1月 4.文本块-第二次预览，368年1月 5.记录--数据类别，预览功能，359年1月。

2.Java 13版本有哪些重要特性？

Java 13于2019年9月17日发布。这是一个非LTS版本。一些特定于开发人员的代码JAVA 13 Features]包括：

1.文本块-预览功能，JEP 355 2.切换表达式-预览功能，JEP 354 3.重新实现Java套接字API--JEP 353 4.动态CDS档案--3月350日 5.FileSystems.newFileSystem()方法 6.支持命名空间的DOM和SAX工厂 7.Unicode 12.1支持 8.ZGC改进以返回未使用的内存--JEP 351

3. Java 12的一些重要特性？

Java 12于2019年3月19日发布。这是一个非LTS版本。其中一些JAVA 12 Features]是：

JVM更改- JEP 189、JEP 346、JEP 344和JEP 230。
Switch表达式
File mismatch（)方法 4.紧凑型数字电视
Stream API中的Teeing Collector
[New String类中的方法]（/community/tutorials/java-12-string-methods)
JEP 334：JVM常量API
JEP 305：instanceof的模式匹配 9.原始字符串文字从JDK 12中删除。

4.Java 11版本有哪些重要功能？

Java 11是继Java 8之后的第二个LTS版本。他们已经改变了许可和支持模式，这意味着如果你下载Java 11 Oracle JDK，它将为商业用途付费。如果你想使用免费版本，你可以从OpenJDK网站下载。

Java 11的一些重要功能包括：

我们可以通过java命令直接运行Java程序。源文件将被隐式编译和执行。它是JEP 330功能实现的一部分。
在字符串类中增加了6个新方法-isBlank()、Line()、strip()、stripLeding()、stripTraling()和Repeat()。你可以在我们关于Java字符串课程的文章中阅读到所有关于它们的文章。
Files类获得了两个读/写字符串数据的新方法--ReadString()和WriteString()。
我们可以在lambda expressions]中使用var。它是JEP 323实施的一部分。
Epsilon：适用于测试环境的无操作垃圾收集器。这是一个实验性的功能，也是JEP 318的一部分。
Java EE和CORBA模块已从标准JDK版本中删除。Nashorn JavaScript引擎也已被弃用。
新的HTTP客户端(JEP 321)和飞行记录器(JEP 328)

有关完整的概述，请阅读[Java 11功能]（/community/tutorials/java-11-features)。

5.Java 10版本有哪些重要功能？

Java 10是甲骨文公司每六个月发布一次的第一个版本，因此它不像以前的版本那样是一个主要版本。但是，Java 10的一些重要特性包括：

局部变量类型Inference
增强了java.util.Locale和相关API，以实现BCP 47语言标签的额外Unicode扩展。
使HotSpot VM能够在用户指定的替代内存设备(如NV-DIMM)上分配Java对象堆。
在JDK中提供一组默认的根证书颁发机构(CA)证书。

Java 10主要是一个维护版本，但我真的很喜欢局部变量类型推断功能。有关Java 10的详细概述，请参阅[Java 10 Features]（/community/tutorials/java-10-features)。

6.Java 9版本有哪些重要功能？

Java 9是一个重要的发行版，带来了很多特性。其中一些重要功能包括：

Java 9 REPL(JShell)
Java 9模块系统
不可变的List、Set、Map和Map.Entry的工厂方法
接口中的私有方法
反应性流
GC(垃圾收集器)改进

您可以在JAVA 9 Features.]上找到有关它们的更多详细信息

7.Java 8版本有哪些重要功能？

Java 8于2014年3月发布，因此它是Java面试问题中的热门话题之一。如果你清楚地回答这个问题，它将表明你喜欢让自己跟上最新的技术。

Java 8是继Java 5批注和泛型之后最大的发行版之一。Java 8的一些重要功能包括：

[使用默认和静态方法时接口会发生变化]（/community/tutorials/java-8-interface-changes-static-method-default-method)
[函数接口和Lambda表达式]（/community/tutorials/java-8-functional-interfaces)
[Java用于集合类的流API]（/community/tutorials/java-8-stream)
[Java Date Time API]（/community/tutorials/java-8-date-localdate-localdatetime-instant)

我强烈建议通过上面的链接来正确理解它们中的每一个，也可以阅读JAVA 8 Features.

8. Java中的OOPS概念

Java基于面向对象的编程概念，以下是Java编程中实现的一些OOP概念。

抽象
封装
多态性
继承
协会
聚集
组合物

在[OOPS Concepts in Java]（/community/tutorials/oops-concepts-java-example)中阅读更多关于它们的信息。

9.什么是Java的平台无关性？

平台独立性意味着您可以在任何操作系统上运行相同的Java程序。例如，您可以在Windows中编写Java程序，然后在Mac OS中运行它。

10.什么是JVM，是否与平台无关？

Java虚拟机(JVM)是Java编程语言的核心。JVM负责将字节码转换为机器可读代码。JVM不是平台独立的，这就是为什么不同的操作系统有不同的JVM。我们可以使用Java选项定制JVM，比如为JVM分配最小和最大内存。它之所以被称为虚拟，是因为它提供了一个不依赖于底层操作系统的界面。

11.JDK和JVM有什么区别？

Java开发工具包（JDK)是用于开发目的，JVM是其中执行Java程序的一部分。

JDK提供了编译、调试和执行Java程序所需的所有工具、可执行文件和二进制文件。执行部分由JVM处理，以提供机器无关性。

12.JVM和JRE有什么区别？

Java Runtime Environment(JRE)是JVM的实现。JRE由JVM和Java二进制文件以及其他类组成，可以成功地执行任何程序。JRE不包含任何开发工具，如Java编译器、调试器等。如果你想执行任何Java程序，你应该安装JRE。

13.哪个类是所有类中的超类？

java.lang.Object是所有Java类的根类，我们不需要扩展它。

14.为什么Java不支持多继承？

由于).中的多重继承

但是，接口中支持多个继承。一个接口可以扩展多个接口，因为它们只声明方法，而实现将出现在实现类中。因此，接口不存在钻石问题。

15.为什么Java不是一种纯面向对象的语言？

Java并不是纯粹面向对象的，因为它支持int、byte、Short、Long等基本类型。我相信它在编写代码时为语言带来了简单性。Java可以为原始类型提供包装器对象，但仅用于表示，它们不会提供任何好处。

正如我们所知道的，对于所有的原始类型，我们都有包装类，比如Integer、Long等，它们提供了一些额外的方法。

16.路径变量和类路径变量有什么区别？

PATH是操作系统用来定位可执行文件的环境变量。这就是为什么当我们安装Java或希望操作系统找到任何可执行文件时，我们需要在PATH变量中添加目录位置。如果你在Windows操作系统上工作，请阅读这篇文章以了解如何在Windows.上设置路径变量

类路径是特定于Java的，Java可执行程序使用它来定位类文件。我们可以在运行Java应用程序时提供类路径位置，它可以是目录、ZIP文件、JAR文件等。

17.main方法在Java中的重要性是什么？

main（)方法是任何独立Java应用程序的入口点。main方法的语法是public static void main（String args[])。

Java的main方法是公共的和静态的，因此Java运行时可以访问它而无需初始化类。输入参数是一个String数组，我们可以通过它将运行时参数传递给Java程序。查看这篇文章来学习[如何编译和运行java程序]（/community/tutorials/java-hello-world-program)。

18.什么是Java中的重载和覆盖？

当一个类中有多个同名的方法，但参数不同时，则称为方法重载。

当我们有两个具有相同签名的方法，一个在父类中，另一个在子类中时，最重要的概念就会出现在继承的画面中。我们可以在被覆盖的子类方法中使用@Override注释，以确保父类方法是否更改，子类是否也更改。

19.可以重载main()方法吗？

是的，我们可以在一个类中有多个名为)`。

20.一个Java源文件中可以有多个公有类吗？

在单个Java源文件中不能有多个公共类。单个源文件可以有多个非公共类。

21.什么是Java包？默认情况下导入哪个包？

Java包是通过分组来组织Java类的机制。分组逻辑可以基于功能或基于模块。一个java类的完全分类名包含包名和类名。例如，java.lang.Object是java.lang包中Object类的完全分类名称。

默认情况下会导入java.lang包，我们不需要从该包显式导入任何类。

22.Java中的访问修饰符是什么？

Java通过PUBLIC、PRIVATE和PROTECTED访问修饰符关键字提供访问控制。当所有这些都不使用时，它被称为默认访问修饰符。

Java类只能有public或default访问修饰符。阅读[Java Access Modifiers]（/community/tutorials/java-access-modifiers)来详细了解这些。

23.最后一个关键字是什么？

FINAL关键字与Class一起使用，以确保没有其他类可以扩展它。例如，字符串类是最终的，我们不能扩展它。

我们可以在方法中使用FINAL关键字，以确保子类不能覆盖它。

Java的FINAL关键字可以与变量一起使用，以确保它只能赋值一次。然而，变量的状态可以更改，例如，我们只能将最终变量赋给对象一次，但对象变量可以在以后更改。

默认情况下，Java接口变量是最终的和静态的。

24.什么是静态关键字？

Static关键字可以与类级变量一起使用，以使其成为全局变量，即所有对象将共享相同的变量。

我们也可以在方法中使用静态关键字。静态方法只能访问类的静态变量，只能调用类的静态方法。

有关更多详细信息，请访问Java Static keyword.

25.在Java中什么是最终的和最终的？

finally块与try-catch一起使用，以始终执行您希望执行的代码，即使try-catch块引发异常也是如此。finally块主要用于释放try块中创建的资源。

Finalize()是Object类中的一种特殊方法，我们可以在类中覆盖它。当对象被垃圾回收时，垃圾回收器将调用此方法。当对象被垃圾回收时，此方法通常被重写以释放系统资源。

26.我们可以将类声明为静态类吗？

我们不能将顶级类声明为静态类，但是内部类可以声明为静态类。如果内部类被声明为静态类，则称为静态嵌套类。

静态嵌套类与任何其他顶级类相同，嵌套只是为了方便打包。

阅读有关内部类的更多信息，请访问Java内部class.

27.什么是静态导入？

如果我们必须使用任何静态变量或来自其他类的方法，通常我们导入类，然后使用带有类名的方法/变量。

1import java.lang.Math;
2
3//inside class
4double test = Math.PI * 5;

我们可以做同样的事情，只导入静态方法或变量，然后在类中使用它，就像它属于它一样。

1import static java.lang.Math.PI;
2
3//no need to refer class now
4double test = PI * 5;

使用静态导入可能会引起混淆，因此最好避免使用。过度使用静态导入会使程序不可读和不可维护。

28.什么是Java中的Try-with-Resources？

Java 7的特性之一是用于自动资源管理的Try-With-Resources语句。在Java 7之前，没有自动资源管理，我们应该显式关闭资源。通常，它是在try-Catch语句的finally块中完成的。当我们忘记关闭资源时，这种方法会导致内存泄漏。

从Java 7开始，我们可以在try块中创建资源并使用它。Java负责在try-catch块完成后立即关闭它。更多信息请访问[Java自动资源管理]（/community/tutorials/java-try-with-resources)。

29.什么是Java中的多捕捉块？

Java 7的改进之一是多捕获块，在该块中我们可以在单个捕获块中捕获多个异常。当每个Catch块都有类似的代码时，这会使我们的代码更短、更干净。

如果CATCH块处理多个异常，则可以使用竖线(|)分隔它们，在本例中，异常参数(Ex)是最终的，因此不能更改它。

有关更多信息，请访问JAVA MULTI CATCH block.

30.什么是静态块？

JAVA静态块是在JAVAClassLoader.将类装载到内存中时执行的一组语句用于初始化类的静态变量。大多数情况下，它用于在加载类时创建静态资源。

31.什么是接口？

接口是Java编程语言的核心概念，不仅在JDK中被大量使用，而且在Java设计模式、大多数框架和工具中都被大量使用。接口提供了一种在Java中实现抽象的方法，并用于定义子类要实现的约定。

接口是定义类型和在代码中创建顶层层次结构的良好起点。由于一个java类可以实现多个接口，所以在大多数情况下最好使用接口作为超类。在[java interface]（/community/tutorials/interface-in-java)阅读更多内容。

32.什么是抽象类？

抽象类在Java中用来为子类创建具有某些默认方法实现的类。抽象类可以有一个没有正文的抽象方法，也可以有有实现的方法。

abstract关键字用于创建抽象类。抽象类不能实例化，主要用于为子类提供基础，以扩展和实现抽象方法，并覆盖或使用抽象类中的已实现方法。在[java abstract class]（/community/tutorials/abstract-class-in-java)阅读关于抽象类的要点。

33.抽象类和接口有什么不同？

抽象关键字用于创建抽象类，而接口是接口的关键字。
抽象类可以有方法实现，而接口不能。
一个类只能扩展一个抽象类，但可以实现多个接口。
如果抽象类有main()方法，我们可以运行它，而我们不能运行接口。

还有更多细节上的区别抽象类和Interface.之间的区别

34.一个接口可以实现或扩展另一个接口吗？

接口不实现另一个接口，它们对其进行扩展。因为接口不能有方法实现，所以不存在菱形问题。这就是为什么我们在接口中有多个继承，即一个接口可以扩展多个接口。

从Java 8开始，接口可以有默认的方法实现。因此，当一个通用的默认方法出现在多个接口中时，要处理菱形问题，必须在实现它们的类中提供方法的实现。有关示例的更多详细信息，请阅读JAVA 8接口changes.

35.什么是标记界面？

标记接口是没有任何方法的空接口，用于强制Java实现类的某些功能。一些众所周知的标记接口是可串行化和可克隆的。

36.什么是包装器类？

Java包装类是Java中八种基本类型的对象表示。Java中的所有包装类都是不可变的和最终的。Java 5自动装箱和取消装箱允许在原始类型和它们对应的包装类之间轻松转换。

更多信息请访问[Java中的Wrapper classes]（/community/tutorials/wrapper-class-in-java)。

37.Java中的Enum是什么？

Enum是在Java 1.5中引入的一种新类型，其字段由一组固定的常量组成。例如，在Java中，我们可以将Direction创建为带有固定字段的枚举，如East、West、North、South。

enum是创建一个枚举类型和类类似的关键字。枚举常量是隐式静态和final的。请在[java enum]（/community/tutorials/java-enum)阅读更多详细信息。

38.什么是Java批注？

Java注释提供了关于代码的信息，它们对它们注释的代码没有直接影响。注释是在Java 5中引入的。注释是关于嵌入在程序本身中的程序的元数据。它可以由注释解析工具或编译器解析。我们还可以指定注释的可用性为仅编译时或直到运行时。Java内置的注释是@ decreated，@Deprecated和@ suppressencounter。更多信息请访问[java annotations]（/community/tutorials/java-annotations)。

39.什么是Java Reflection API，为什么它如此重要？

Java反射API提供了检查和修改Java应用程序运行时行为的能力。我们可以检查Java类、接口、枚举，并获得它们的方法和字段详细信息。反射API是一个高级主题，我们应该在正常编程中避免它。反射API的使用可能会通过调用私有构造函数(即违反访问修饰符的规则)来破坏设计模式，如Singleton模式。

即使我们在正常编程中不使用反射API，拥有反射API也是非常重要的。没有反射API，我们就不能有任何框架，如Spring、Hibernate或服务器，如Tomcat、JBoss。它们通过反射API调用适当的方法和实例化类，并将其大量用于其他处理。

请阅读[JAVA反射接口]以深入了解反射Tutorial](/community/tutorials/java-reflection-example-tutorial)。

40.什么是Java中的组合？

组合是在类中实现Has-a关系的设计技术。我们可以使用对象组合来实现代码重用。

Java组合是通过使用引用其他对象的实例变量来实现的。使用组合的好处是我们可以控制其他对象对客户端类的可见性，并且只重用我们需要的对象。阅读更多有关示例的内容，请参阅JAVA Composition示例。

41.合成比继承有什么好处？

Java编程的最佳实践之一是倾向于组合而不是继承。其中一些可能的原因是：

超类中的任何更改都可能影响子类，即使我们可能没有使用超类方法。例如，如果我们在子类中有一个test()方法，而突然有人在超类中引入了一个test()方法，我们将在子类中得到编译错误。组合永远不会面临这个问题，因为我们只使用我们需要的方法。
继承将所有超类方法和变量暴露给客户端，如果我们在设计超类时没有控制权，可能会导致安全漏洞。组合允许我们提供对方法的受限访问，因此更安全。
我们可以在组合中获得运行时绑定，其中继承在编译时绑定类。因此，组合为方法调用提供了灵活性。

您可以在上阅读有关组合相对于继承的上述好处的更多信息Java组合与inheritance.

42.如何在Java中对定制对象的集合进行排序？

我们需要实现可比较的接口来支持对集合中的自定义对象进行排序。可比较接口具有由排序方法使用的CompareTo(T Obj)方法，通过提供此方法实现，我们可以提供对自定义对象集合进行排序的默认方法。

但是，如果您想要基于不同的标准进行排序，例如根据工资或年龄对Employees集合进行排序，那么我们可以创建比较器实例并将其作为排序方法传递。有关更多详细信息，请阅读JAVA可比较和Comparator.

43.Java中的内部类是什么？

我们可以在类中定义一个类，它们被称为嵌套类。任何非静态嵌套类都称为内部类。内部类与类的对象相关联，它们可以访问外部类的所有变量和方法。因为内部类与实例相关联，所以我们不能在它们中包含任何静态变量。

我们可以在类中有局部内部类或匿名内部类。有关更多详细信息，请阅读Java内部class.

44.什么是匿名内部类？

没有名称的本地内部类称为匿名内部类。匿名类在单个语句中定义和实例化。匿名内部类总是扩展类或实现接口。

由于匿名类没有名称，因此无法为匿名类定义构造函数。匿名内部类只能在定义它的地方访问。

45.什么是Java中的ClassLoader？

Java ClassLoader是当我们想要访问任何类时将字节码程序加载到内存中的程序。我们可以通过扩展ClassLoader类和覆盖loadClass(字符串名)方法来创建我们自己的类加载器。要了解更多信息，请访问Java classloader.

46.有哪些不同类型的类加载器？

Java中有三种类型的内置类加载器。

1.Bootstrap ClassLoader-它加载JDK内部类，通常加载rt.jar和其他核心类。 2.扩展类加载器-它从JDK扩展目录加载类，通常是$JAVA_HOME/lib/ext目录。 3.系统类加载器-它从当前类路径加载类，可以在使用-cp或-classpath命令行选项调用程序时设置这些类路径。

47.Java中的三进制运算符是什么？

Java三进制运算符是唯一接受三个操作数的条件运算符。它是If-Then-Else语句的单行替换，并在Java编程中大量使用。我们可以使用三元运算符If-Else条件，甚至可以使用嵌套的三元运算符的Switch条件。有关示例，请参阅Java Three ary operator.

48.超级关键词能做什么？

当您重写子类中的方法时，可以使用SUPERR关键字访问超类方法。

我们可以在子类构造函数中使用Super关键字来调用超类构造函数，但在本例中，它应该是构造函数方法中的第一个语句。

 1package com.journaldev.access;
 2
 3public class SuperClass {
 4
 5    public SuperClass(){
 6    }
 7    
 8    public SuperClass(int i){}
 9    
10    public void test(){
11    	System.out.println("super class test method");
12    }
13}

超级关键字的使用可以在下面的子类实现中看到。

 1package com.journaldev.access;
 2
 3public class ChildClass extends SuperClass {
 4
 5    public ChildClass(String str){
 6    	//access super class constructor with super keyword
 7    	super();
 8    	
 9    	//access child class method
10    	test();
11    	
12    	//use super to access super class method
13    	super.test();
14    }
15    
16    @Override
17    public void test(){
18    	System.out.println("child class test method");
19    }
20}

49.什么是Break and Continue语句？

我们可以使用BREAK语句来终止FOR、WHILE或DO-WHILE循环。我们可以在Switch语句中使用Break语句来退出Switch用例。您可以在Java break.]中查看Break语句的示例我们可以使用标签的Break来终止嵌套循环。

continue语句跳过for、while或do-while循环的当前迭代。我们可以使用带有标签的continue语句来跳过最外层循环的当前迭代。

50.这个关键字在Java中是什么？

该关键字提供对当前对象的引用，主要用于确保使用的是对象变量，而不是同名的局部变量。

1//constructor
2public Point(int x, int y) {
3    this.x = x;
4    this.y = y;
5}

我们还可以使用该关键字从构造函数中调用其他构造函数。

 1public Rectangle() {
 2    this(0, 0, 0, 0);
 3}
 4public Rectangle(int width, int height) {
 5    this(0, 0, width, height);
 6}
 7public Rectangle(int x, int y, int width, int height) {
 8    this.x = x;
 9    this.y = y;
10    this.width = width;
11    this.height = height;
12}

51.什么是默认构造函数？

类的任何参数构造函数都不称为默认构造函数。当我们没有为类定义任何构造函数时，Java编译器会自动为类创建默认的无参数构造函数。如果定义了其他构造函数，则编译器不会为我们创建默认构造函数。

52.我们能不能试一试而不用挡板？

是的，我们可以使用Try-Finally语句，从而避免CATCH块。

53.什么是垃圾收集？

垃圾收集是查看堆内存、识别哪些对象正在使用、哪些对象未使用以及删除未使用对象的过程。在Java中，释放内存的过程由垃圾回收器自动处理。

运行垃圾回收器时，可以使用代码Runime.getRuntime().gc()，也可以使用实用方法System.gc()。有关堆内存和垃圾收集的详细分析，请阅读JAVA垃圾Collection.

54.什么是序列化和反序列化？

我们可以将Java对象转换为称为序列化的流。将对象转换为Stream后，可以将其保存到文件或通过网络发送，或在套接字连接中使用。

该对象应该实现一个Serializable接口，我们可以使用java.io.ObjectOutputStream将对象写入文件或任何OutputStream对象。更多信息请访问[Java Serialization]（/community/tutorials/objectoutputstream-java-write-object-file)。

将通过序列化创建的流数据转换为对象的过程称为反序列化。有关更多信息，请访问JAVA Deserialization.

55.如何通过命令提示符运行JAR文件？

我们可以使用Java命令运行JAR文件，但它需要JAR清单文件中的Main-Class条目。Main-Class是JAR的入口点，Java命令使用它来执行类。请访问Java JAR文件了解更多信息。

56.系统类有什么用处？

Java系统类是其核心类之一。记录信息以进行调试的最简单方法之一是System.out.print()方法。

系统类是最终的，因此我们不能通过继承来子类化和覆盖它的行为。系统类不提供任何公共构造函数，所以我们不能实例化这个类，这就是为什么它的所有方法都是静态的。

系统类的一些实用方法是用于数组复制、获取当前时间、读取环境变量。有关更多信息，请访问JAVA System Class.

57.什么是instanceof关键字？

我们可以使用instanceof关键字来检查对象是否属于某个类。我们应该尽量避免它的使用。示例用法为：

 1public static void main(String args[]){
 2    Object str = new String("abc");
 3    	
 4    if(str instanceof String){
 5    	System.out.println("String value:"+str);
 6    }
 7    	
 8    if(str instanceof Integer){
 9    	System.out.println("Integer value:"+str);
10    }
11}

由于str在运行时是字符串类型，因此第一个if语句的计算结果为True，第二个语句的计算结果为False。

58。我们可以用带开关盒的细绳吗？

Java 7的一个特性是对允许字符串的大小写进行了改进。因此，如果您使用的是Java 7或更高版本，则可以在Switch-Case语句中使用字符串。有关更多信息，请访问JAVA Switch-Case字符串example.

59.Java是按值传递还是按引用传递？

这是一个非常令人困惑的问题，我们知道对象变量包含对堆空间中对象的引用。当我们调用任何方法时，这些变量的副本被传递并存储在该方法的堆栈内存中。我们可以通过一个简单的泛型交换方法测试任何语言，无论它是按引用传递还是按值传递，以了解更多可读性Java是按值传递而不是按Reference.传递

60.堆内存和堆栈内存有什么不同？

堆内存和堆栈内存之间的主要区别如下：

堆内存由应用程序的所有部分使用，而堆栈内存仅由一个执行线程使用。
每当创建对象时，它总是存储在堆空间中，堆栈内存包含对它的引用。堆栈内存只包含局部原语变量和对堆空间中对象的引用变量。
堆栈中的内存管理以后进先出的方式完成，而堆内存中的内存管理更复杂，因为它是全局使用的。

有关示例程序的详细说明，请阅读Java Heap vs Stack Memory.

61.Java编译器存储在JDK、JRE还是JVM中？

Java编译器的任务是将Java程序转换成字节码，为此我们有一个javac可执行文件。所以它必须存储在JDK中，我们在JRE中不需要它，而JVM只是规范。

62.以下程序的输出将是什么？

上下文：类中的静态方法

 1package com.journaldev.util;
 2
 3public class Test {
 4
 5    public static String toString(){
 6    	System.out.println("Test toString called");
 7    	return "";
 8    }
 9    
10    public static void main(String args[]){
11    	System.out.println(toString());
12    }
13}

答案：代码不能编译，因为我们不能有带有Static关键字的对象类方法。请注意，Object类有一个toString()方法。您将得到一个编译时错误，因为)更改为超类Object中不存在的其他名称，则不会出现此错误。

上下文：静态方法调用

 1package com.journaldev.util;
 2
 3public class Test {
 4
 5    public static String foo(){
 6    	System.out.println("Test foo called");
 7    	return "";
 8    }
 9    
10    public static void main(String args[]){
11    	Test obj = null;
12    	System.out.println(obj.foo());
13    }
14}

答案：这是一个奇怪的情况。当我们在为空的对象上调用方法时，我们都看到过NullPointerException错误。但在这里，这个程序将工作并打印测试foo调用。

其原因是Java编译器代码优化。当Java代码被编译成生成的字节代码时，它会发现foo()是一个静态方法，应该使用类来调用。所以它将方法调用obj.foo()改为Test.foo()，因此没有NullPointerException。

我必须承认，这是一个非常棘手的问题，如果你正在面试的人，这将打击他的头脑了。🙂

这就是Java面试的核心问题和答案。我会继续在列表中添加更多的问题，如果你认为我错过了任何重要的问题，请通过评论让我知道。

顶级 100+ 核心 Java 面试问题