300 个 Core Java 面试问题和答案

2025 年 4 月 21 日 | 阅读 46 分钟

90% 的面试问题保证

这里列出了 300 个 Core Java 面试问题。如果您曾被问到任何 Core Java 面试问题，请在提问区发布。我们保证您能在这里找到 90% 的常见面试问题和答案。

Core Java 面试问题的答案简洁明了。Core Java 面试问题分为 Java 基础面试问题、OOPs 面试问题、字符串处理面试问题、多线程面试问题、集合面试问题、JDBC 面试问题等。

Core Java：Java 基础面试问题

1) 什么是 Java？

Java 是一种高级、面向对象、健壮、安全、平台独立、高性能、多线程和可移植的编程语言。它由 James Gosling 及其团队于 1991 年 6 月在 Sun Microsystems 开发。它也可以被称为平台，因为它提供了自己的 JRE 和 API。Java 旨在具有通用性、安全性和可移植性，允许开发人员编写可在各种平台上运行而无需修改的代码。

了解更多信息：Java 教程

2) C++ 和 Java 有什么区别？

C++ 和 Java 的区别如下表所示。

方面	C++	Java
平台无关	C++ 是平台相关的。	Java 是平台独立的。
用于	C++ 主要用于系统编程。	Java 主要用于应用程序编程。它广泛用于 Windows、基于 Web、企业和移动应用程序。
设计目标	C++ 专为系统和应用程序编程而设计。它是 C 编程语言的扩展。	Java 最初是为打印系统设计的解释器，但后来扩展为支持网络计算。它的设计目标是易于使用，并能被更广泛的受众所接受。
Goto 语句	C++ 支持 goto 语句。	Java 不支持 goto 语句。
多重继承	C++ 支持多重继承。	Java 不通过类支持多重继承。可以通过 Java 中的接口来实现。
运算符重载	C++ 支持运算符重载。	Java 不支持运算符重载。
指针	C++ 支持指针。我们可以用 C++ 编写指针程序。	Java 内部支持指针。但是，我们不能用 Java 编写指针程序。这意味着 Java 对指针的支持是受限制的。
编译器和解释器	C++ 只使用编译器。C++ 使用编译器进行编译和运行，编译器将源代码转换为机器代码，因此 C++ 是平台相关的。	Java 使用编译器和解释器。Java 源代码在编译时被转换为字节码。解释器在运行时执行此字节码并生成输出。Java 是解释型语言，这就是它平台独立的原因。
按值调用和按引用调用	C++ 支持按值调用和按引用调用。	Java 只支持按值调用。Java 中没有按引用调用。
结构和联合	C++ 支持结构和联合。	Java 不支持结构和联合。
线程支持	C++ 没有内置的线程支持。它依赖第三方库来实现线程支持。	Java 内置线程支持。
文档注释	C++ 不支持文档注释。	Java 支持文档注释 (/** ... */) 来为 Java 源代码创建文档。
virtual 关键字	C++ 支持 virtual 关键字，因此我们可以决定是否重写函数。	Java 没有 virtual 关键字。默认情况下，我们可以重写所有非静态方法。换句话说，非静态方法默认是虚拟的。
无符号右移 >>>	C++ 不支持 >>> 运算符。	Java 支持无符号右移 >>> 运算符，它对于负数会在顶部填充零。对于正数，它的工作方式与 >> 运算符相同。
继承树	C++ 每次都会创建一个新的继承树。	Java 始终使用单个继承树，因为 Java 中的所有类都是 Object 类的子类。Object 类是 Java 中继承树的根。
硬件	C++ 更接近硬件。	Java 与硬件的交互性不那么强。
面向对象	C++ 是一种面向对象语言。然而，在 C 语言中，不可能实现单一根层次结构。	Java 也是一种面向对象语言。然而，Java 中除基本类型外的一切都是对象。它是一个单一的根层次结构，因为所有东西都派生自 java.lang.Object。
内存管理	使用 new 和 delete 关键字进行手动内存管理。	通过垃圾回收进行自动内存管理。
异常处理	支持 try、throw 和 catch 进行异常处理。	也使用 try、throw 和 catch 进行异常处理。
标准库	标准模板库 (STL) 用于数据结构和算法。	Java 标准版 (SE) 库用于各种实用程序和功能。
App开发	通常用于桌面应用程序。	广泛用于 Web、企业和移动应用程序。
运行时环境	更接近机器，性能可能更好。	Java 虚拟机 (JVM) 提供了一层抽象，牺牲了一些性能以换取可移植性。
垃圾回收	手动内存管理，没有内置垃圾回收。	自动垃圾回收以管理内存。

了解更多信息：C++ 与 Java 的区别

3) 列出 Java 编程语言的特性。

Java 编程语言具有以下特性。
简单：Java 易于学习。Java 的语法基于 C++，这使得用它编写程序更容易。
面向对象编程 (OOP)：Java 遵循面向对象范式，这允许我们将代码维护为包含数据和行为的不同类型对象的组合。Java 中的一切都被视为对象，从而提高了模块化和代码重用性。
可移植：Java 支持一次编写，随处运行的方法。我们可以在每台机器上执行 Java 程序。Java 程序 (.java) 被转换为字节码 (.class)，可以在每台机器上轻松运行。
平台独立：Java 是一种平台独立的编程语言。它与其他编程语言（如 C 和 C++）不同，后者需要平台才能执行。Java 拥有自己的平台，其代码在此平台上执行。Java 不依赖操作系统来执行。
安全：Java 是安全的，因为它不使用显式指针。Java 还提供了字节码和异常处理的概念，这使其更加安全。Java 运行时环境 (JRE) 包含一个安全管理器和一组 API，用于控制对资源的访问并防止恶意活动。
健壮：Java 是一种强大的编程语言，因为它使用强大的内存管理。自动垃圾回收、异常处理等概念使其更加健壮。
架构中立：Java 是架构中立的，因为它不依赖于架构。在 C 中，数据类型的大小可能会根据架构（32 位或 64 位）而变化，这在 Java 中不存在。
解释型：Java 使用即时 (JIT) 解释器以及编译器进行程序执行。
高性能：Java 比其他传统的解释型编程语言更快，因为 Java 字节码“接近”本机代码。它仍然比编译型语言（例如 C++）慢一点。虽然是解释型语言，但 Java 的即时 (JIT) 编译将字节码转换为机器代码以提高性能。
多线程：我们可以通过定义多个线程来编写同时处理许多任务的 Java 程序。多线程的主要优点是它不占用每个线程的内存。它共享一个公共内存区域。线程对于多媒体、Web 应用程序等很重要。Java 的字节码可以在任何具有 JVM 的设备上执行，从而确保跨不同平台的可移植性。
分布式：Java 是分布式的，因为它方便用户用 Java 创建分布式应用程序。RMI 和 EJB 用于创建分布式应用程序。Java 的此功能使我们能够通过从互联网上的任何机器调用方法来访问文件。
动态：Java 是一种动态语言。它支持类的动态加载。这意味着类按需加载。它还支持其本机语言（即 C 和 C++）的函数。

了解更多信息：Java 的特性

300 Core Java Interview Questions and Answers

4) 您对 Java 虚拟机 (JVM) 有何理解？

Java 虚拟机是一种虚拟机器，使计算机能够运行 Java 程序。它是一个虚拟化执行环境，允许 Java 程序在任何具有兼容 JVM 的设备上运行。JVM 是必须在计算机系统中实现的规范。它解释 Java 字节码并将其转换为底层硬件的机器代码。

了解更多信息：Java 虚拟机 (JVM)

5) JDK、JRE 和 JVM 有什么区别？

特性	JDK	JRE	JVM
定义	Java 开发工具包 (JDK) 是一种用于开发 Java 应用程序的软件开发工具包。	Java 运行时环境 (JRE) 是一种软件包，提供 Java 虚拟机 (JVM)、类库和其他组件以运行 Java 应用程序。	Java 虚拟机 (JVM) 是一种抽象机器，提供 Java 字节码的执行环境。
函数	提供用于开发 Java 应用程序的工具。它包括编译器 (javac)、JRE 和调试工具。	它提供了一个用于执行 Java 应用程序的环境。它包括 JVM 和运行 Java 程序所需的库，但不包括开发工具。	运行编译器生成的字节码的虚拟机。它是 JRE 的一部分，并且是平台相关的，但提供了平台独立的执行环境。
用例	供开发人员编写、编译和调试 Java 程序。	供最终用户执行 Java 应用程序，而无需开发工具。	将字节码转换为机器代码并在底层硬件上执行。
平台依赖性	它是平台相关的。	它是平台相关的。	它是平台相关的。
实施	JDK = JRE + 开发工具	JRE = JVM + 类库	JVM = 提供运行时环境。

了解更多信息：JDK、JRE 和 JVM 的区别

6) JVM 分配了多少种内存区域？

类（方法）区： 类区存储每个类的结构，例如运行时常量池、字段、方法数据和方法的代码。

堆：它是运行时数据区，其中为对象分配内存。

栈： Java 栈存储栈帧。保存局部变量和部分结果，支持方法执行。每个线程都有一个私有 JVM 栈，与线程同时创建。每次调用方法时都会创建一个新栈帧。当方法调用完成时，栈帧被销毁。

PC 寄存器（非堆）： 跟踪每个线程的当前执行位置。

本地方法栈（非堆）： 它包含本地方法信息并支持本地代码执行。

了解更多信息：Java 中的内存管理

7) 什么是 JIT 编译器？

即时 (JIT) 编译器： 它用于提高性能。该编译器是 Java 运行时环境 (JRE) 的一部分。

它在运行时将 Java 字节码翻译成本机机器代码。因此，减少了编译所需的时间。

这里，“编译器”一词指的是从 Java 虚拟机 (JVM) 的指令集到特定 CPU 的指令集的翻译器。

了解更多信息：Java 中的 JIT

8) 什么是平台？

平台指的是程序运行的硬件和软件的组合。在 Java 的上下文中，平台包括操作系统和 Java 虚拟机 (JVM)。

平台有两种类型

基于软件的
基于硬件的

9) Java 平台与其他平台的主要区别是什么？

Java 平台与其他平台之间存在以下差异。

Java 由于其“一次编写，随处运行”的特性而平台独立。
其他平台可能需要为每个目标环境编写特定于平台的代码和编译。

10) 是什么赋予了 Java “一次编写，随处运行”的特性？

Java 编译器将 Java 程序转换为类文件（字节码），字节码是源代码和机器代码之间的中间语言。代码被编译成字节码，字节码是平台独立的，JVM 在任何具有兼容 JVM 的设备上执行此字节码。

了解更多信息：Java 编译器

11) 什么是类加载器？

类加载器是 JVM 的一个子系统，用于加载类文件。它在运行时将 Java 类加载到内存中。负责查找和加载 Java 程序所需的类文件。

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

引导类加载器：这是第一个类加载器，它是扩展类加载器的超类。它加载包含所有 Java 标准版类文件（如 java.lang 包类、java.net 包类、java.util 包类、java.io 包类、java.sql 包类等）的 jar 文件。
扩展类加载器：它是引导类加载器的子类加载器，也是系统类加载器的父类加载器。它加载位于 $JAVA_HOME/jre/lib/ext 内的 jar 文件。
系统/应用程序类加载器：它是扩展类加载器的子类加载器。它从 classpath 加载类文件。默认情况下，classpath 设置为当前目录。您可以使用 "-cp" 或 "-classpath" 开关更改 classpath。它也称为应用程序类加载器。

了解更多信息：Java 中的类加载器

12) 空的 .java 文件名是否是有效的源文件名？

是的，在 Java 中，源文件可以以 .java 扩展名保存，然后可以使用 javac 命令后跟文件名（包括 .java 扩展名）进行编译。最后，可以使用 Java 命令后跟包含 main() 方法的类的名称来执行程序。

让我们举一个简单的例子

//save by .java only  
class Main {  
public static void main(String args[]){  
System.out.println("Hello Java");  
}  
}  

使用 javac 命令编译代码
javac Main.java

使用 java 命令运行程序
java Main

13) delete、next、main、exit 或 null 是 Java 中的关键字吗？

不是，在 Java 中，delete、next、main、exit 和 null 都不是关键字。

14) 如果我在命令行上没有提供任何参数，那么传递给 main() 方法的 String 数组中存储的值是空的还是 NULL？

它是空的，但不是 null。如果在运行 Java 程序时没有提供任何命令行参数，传递给 main() 方法的 String 数组将是一个空数组，而不是 null。main() 方法的 args 参数是一个字符串数组，即使没有提供命令行参数，它也总是由 Java 初始化。

15) 如果我们写 static public void 而不是 public static void 会怎样？

程序编译并运行正确，因为在 Java 中修饰符的顺序无关紧要。

在 Java 中，访问修饰符（public、private、protected）和其他修饰符（static、final 等）在返回类型（本例中为 void）之前的放置是灵活的。public static void 和 static public void 都被接受并被认为是正确的语法。

以下是 main() 方法的两种等效的有效声明

public static void main(String[] args) {
    // Code goes here
}
static public void main(String[] args) {
    // Code goes here
}

了解更多信息：Java main() 方法

16) 局部变量的默认值是什么？

在 Java 中，局部变量不会被编译器分配默认值。它们必须在使用前显式初始化，否则将发生编译错误。

public class Main {  
    public static void main(String[] args) {  
        int x;  
        System.out.println(x); // Compilation error: The local variable x may not have been initialized  
    }  
}  

了解更多信息：Java 变量

17) Java 中有哪些访问修饰符？

在 Java 中，访问修饰符是用于定义方法、类或变量的访问范围的关键字。Java 中有两种类型的修饰符：访问修饰符和非访问修饰符。

访问说明符

public： 被定义为 public 的公共类、方法或变量可以被任何类或方法访问。

protected： 被保护的类、方法或变量可以被同一包中的类、此类的子类或在同一类中访问。

private： 被定义为 private 的私有类、方法或变量只能在类中访问。

default（包私有）： 如果没有使用访问修饰符，则被视为包私有。具有默认访问权限的成员只能在同一包中访问。

非访问修饰符

它包括 static、synchronized、abstract、native、volatile、transient。

了解更多信息：Java 访问修饰符

18) 静态方法和变量的目的是什么？

定义为静态的方法或变量在类的所有对象之间共享。静态是类的一部分，而不是对象的一部分。Java 中的静态方法和变量与类关联，而不是与类的实例关联。因此，当我们定义所有类对象共有的变量或方法时，使用静态。

例如，在模拟大学学生集合的类中，大学名称是所有学生的共同属性。因此，大学名称将定义为静态。

类级别访问： 静态成员属于类本身，而不属于类的实例。这意味着它们可以使用类名访问，而无需创建类的实例。

常量： 静态变量通常用于在类中定义常量。这些值在类的所有实例之间共享，并且可以使用类名访问。

了解更多信息：Java 中的静态方法

19) Java 中包的优点是什么？

Java 中的包提供了一种将类和接口组织和构建成层次结构的方法。它们提供了几个优点

包避免了名称冲突。
包提供了更简单的访问控制。
我们还可以拥有在包外部不可见且由包使用的隐藏类。
更容易找到相关的类。

了解更多信息：Java 中包的优点

20) 以下 Java 程序的输出是什么？

示例

class Test 
{
	public static void main (String args[]) 
	{
		System.out.println(10 + 20 + "Tpointtech"); 
		System.out.println("Tpointtech" + 10 + 20);
	}
}

编译并运行

输出

30Tpointtech
Tpointtech1020

说明

在第一种情况下，10 和 20 被视为数字并相加得到 30。现在，它们的和 30 被视为字符串并与字符串 Tpointtech 拼接。因此，输出将是 30Tpointtech。

在第二种情况下，字符串 Tpointtech 与 10 拼接成字符串 Tpointtech10，然后与 20 拼接成 Tpointtech1020。

了解更多信息：Java 程序

21) 以下 Java 程序的输出是什么？

示例

class Test 
{
	public static void main (String args[]) 
	{
		System.out.println(10 * 20 + "Tpointtech"); 
		System.out.println("Tpointtech" + 10 * 20);
	}
}

编译并运行

输出

200Tpointtech
Tpointtech200

说明

在第一种情况下，数字 10 和 20 将首先相乘，然后结果 200 被视为字符串并与字符串 Tpointtech 拼接以生成输出 200Tpointtech。

在第二种情况下，数字 10 和 20 将首先相乘得到 200，因为乘法的优先级高于加法。结果 200 将被视为字符串并与字符串 Tpointtech 拼接以生成输出为 Tpointtech200。

22) 以下 Java 程序的输出是什么？

class Test 
{
	public static void main (String args[]) 
	{
		for(int i=0; 0; i++) 
		{
			System.out.println("Hello Tpointtech");
		}
	}
}

由于 for 循环的第二部分中的非布尔表达式，上面的代码将导致编译错误，并且给定的是一个整数值，即 0。

Core Java - 面向对象概念：初始面向对象面试问题

这里给出了 50 多个 OOP（面向对象编程和系统）面试问题。但是，为了更好地理解，它们被分为许多部分，例如构造函数面试问题、静态面试问题、继承面试问题、抽象面试问题、多态面试问题等。

23) 什么是面向对象范式？

它是一种基于对象的编程范式，对象在其所属的类中定义了数据和方法。面向对象范式的关键原则包括封装、继承和多态，为以模拟现实世界实体并促进代码重用和可维护性的方式设计和构建软件提供了框架。对象是类的实例，它们相互交互以设计应用程序和程序。

面向对象范式具有以下特性。

面向对象遵循程序设计中的自下而上方法。
关注数据以及操作对象数据的方法
包括封装和抽象等概念，它们向用户隐藏复杂性，只显示功能。
实现继承、抽象等实时方法。

面向对象范式的例子有 C++、Simula、Smalltalk、Python、C# 等。

了解更多信息：Java 中的面向对象编程 (OOPs) 概念

24) 什么是对象？

对象是具有某些状态和行为的实时实体。在 Java 中，对象是类的实例，它将实例变量作为对象的状态，将方法作为对象的行为。可以使用 new 关键字创建类的对象。

例如，如果我们有一个名为 Car 的类，该类的一个对象可以表示一辆具有颜色、型号、年份等属性以及 startEngine() 或 drive() 等方法的特定汽车。Car 类的每个实例都将是一个具有自己独特状态的不同对象。

了解更多信息：Java 类和对象

25) 面向对象编程语言和基于对象的编程语言有什么区别？

面向对象语言和基于对象的语言之间存在以下基本区别。

面向对象语言遵循面向对象的所有概念，而基于对象的语言不遵循面向对象的所有概念，例如继承和多态。它允许创建类和对象，并支持在这些类中定义和实现方法。

面向对象语言没有内置对象，而基于对象的语言有内置对象；例如，JavaScript 有 window 对象。它允许创建对象和封装数据，但它可能不提供与完整面向对象相关联的完整功能集。

面向对象编程的例子有 Java、C#、Smalltalk 等，而基于对象的语言的例子有 JavaScript、VBScript 等。

26) 定义为实例变量的对象引用的初始值是什么？

在 Java 中，当一个对象引用被声明为实例变量（类的成员变量）时。它默认会自动初始化为 null。这适用于所有对象引用，无论类类型如何。

Core Java - 面向对象概念：构造函数面试问题

27) 什么是构造函数？

构造函数可以定义为一种特殊类型的方法，用于初始化对象的状态。它在实例化类时被调用，并为对象分配内存。每次使用 new 关键字创建对象时，都会调用类的默认构造函数。构造函数的名称必须与类名相似。构造函数不能有显式返回类型。

了解更多信息：Java 中的构造函数

28) Java 中使用多少种类型的构造函数？

根据构造函数中传递的参数，Java 中有两种类型的构造函数。

默认构造函数： 默认构造函数是不接受任何值的构造函数。默认构造函数主要用于使用默认值初始化实例变量。默认构造函数将实例变量初始化为其默认值（数字类型为 0，布尔值为 false，对象引用为 null）。如果类中没有定义任何构造函数，则编译器会隐式调用默认构造函数。

public class Main {  
    // Default constructor (automatically provided if not defined explicitly)  
}  

带参数的构造函数： 带参数的构造函数是可以用给定值初始化实例变量的构造函数。它允许我们在对象创建过程中使用特定值初始化对象。换句话说，我们可以说接受参数的构造函数称为带参数的构造函数。

public class Main {  
    // Parameterized constructor  
    public Example(int value) {  
        // Initialization logic here  
    }  
}

29) 默认构造函数的目的是什么？

Java 中的默认构造函数是没有参数的构造函数。默认构造函数的目的是为对象分配默认值。如果类中没有定义任何显式构造函数，Java 编译器会自动提供它。

示例

class Main {  
int id;  
String name;  
void display(){System.out.println(id+" "+name);}  
public static void main(String args[]){  
Main m1=new Main ();  
Main m2=new Main();  
m1.display();  
m2.display();  
}  
}  

编译并运行

输出

0 null
0 null

解释：在上面的类中，您没有创建任何构造函数，因此编译器会为您提供一个默认构造函数。这里，0 和 null 值是由默认构造函数提供的。

30) 构造函数会返回任何值吗？

是的，在 Java 中，构造函数没有返回类型，甚至没有 void。构造函数的目的是初始化对象的状态并为使用做好准备。构造函数隐式返回类的当前实例（我们不能将显式返回类型与构造函数一起使用）。

31) 构造函数是否可以继承？

不，构造函数不能继承。可以通过在子类构造函数的第一行使用关键字 super 并传递适当的参数来调用超类构造函数，以设置超类的私有实例变量。

32) 您可以将构造函数设为 final 吗？

不，在 Java 中，构造函数不能声明为 final。final 关键字用于指示类、方法或变量不能进一步子类化、重写或修改。但是，它不适用于构造函数。

33) 我们可以重载构造函数吗？

是的，可以通过更改构造函数接受的参数数量或更改参数的数据类型来重载构造函数。

每个构造函数提供了一种不同的方式来初始化类的对象。调用哪个构造函数的选择基于在对象创建期间传递的参数。

请看以下示例。

示例

class Test 
{
	int i; 
	public Test(int k)
	{
	    i=k;
	}
	public Test(int k, int m)
	{
	    System.out.println("Hi I am assigning the value max(k, m) to i");
	    if(k>m)
	    {
	        i=k; 
	    }
	    else 
	    {
	        i=m;
	    }
	}
}
public class Main 
{
	public static void main (String args[]) 
	{
		Test test1 = new Test(10);
		Test test2 = new Test(12, 15);
		System.out.println(test1.i);
		System.out.println(test2.i);
	}
}

编译并运行

输出

Hi I am assigning the value max(k, m) to i
10
15

在上面的程序中，构造函数 Test 被另一个构造函数重载。在第一次调用构造函数时，调用具有一个参数的构造函数，并且 i 将初始化为值 10。但是，在第二次调用构造函数时，调用具有两个参数的构造函数，并且 i 将初始化为值 15。

34) 您对 Java 中的复制构造函数有何理解？

Java 中没有复制构造函数。但是，我们可以将一个对象的值复制到另一个对象，就像 C++ 中的复制构造函数一样。

在 Java 中，有多种方法可以将一个对象的值复制到另一个对象。它们是

通过使用构造函数
通过将一个对象的值分配给另一个对象
通过使用 Object.clone() 方法

在此示例中，我们将使用 Java 构造函数将一个对象的值复制到另一个对象。

示例

public class Main {  
    int id;  
    String name;  
    // Constructor to initialize integer and string  
    Main(int id, String name) {  
        this.id = id;  
        this.name = name;  
    }  
    // Copy constructor  
    Main(Main s) {  
        this.id = s.id;  
        this.name = s.name;  
    }  
    void display() {  
        System.out.println(id + " " + name);  
    }  
    public static void main(String[] args) {  
        Main obj1 = new Main(111, "Karan");  
        Main obj2 = new Main(obj1);  
        obj1.display();  
        obj2.display();  
    }  
}

编译并运行

输出

111 Karan
111 Karan

复制构造函数在需要复制现有对象的状态而不直接引用相同数据的情况下很有用。它们不像其他一些语言那样内置于 Java 语言中，但我们可以根据需要在类中定义它们。

了解更多信息：Java 中的复制构造函数

35) 构造函数和方法之间有什么区别？

构造函数和方法之间有许多区别。

Java 构造函数	Java 方法
构造函数用于初始化对象的状态。	方法用于公开对象的行为。
构造函数不能有返回类型。	方法必须有返回类型。
构造函数是隐式调用的。	方法是显式调用的。
如果一个类中没有构造函数，Java 编译器会提供一个默认构造函数。	编译器在任何情况下都不会提供方法。
构造函数的名称必须与类名相同。	方法名称可能与类名相同，也可能不同。

了解更多信息：Java 中构造函数和方法的区别

36) 以下 Java 程序的输出是什么？

示例

public class Main  
{  
    Main(int a, int b)  
    {  
        System.out.println("a = "+a+" b = "+b);  
    }  
    Main(int a, float b)  
    {  
        System.out.println("a = "+a+" b = "+b);  
    }  
    public static void main (String args[])  
    {  
        byte a = 10;   
        byte b = 15;  
        Main obj = new Main(a,b);  
    }  
}  

编译并运行

输出

a = 10 b = 15

这里，变量 a 和 b 的数据类型（即 byte）被提升为 int，并且调用了具有两个整数参数的第一个带参数的构造函数。

37) 以下 Java 程序的输出是什么？

示例

class Test 
{
	int i; 
}
public class Main 
{
	public static void main (String args[]) 
	{
		Test test = new Test(); 
		System.out.println(test.i);
	}
}

编译并运行

输出

程序的输出是 0，因为变量 i 内部初始化为 0。正如我们所知，如果类中没有构造函数，则会隐式调用默认构造函数，因此变量 i 初始化为 0，因为类中没有构造函数。

38) 以下 Java 程序的输出是什么？

class Test 
{
	int test_a, test_b;
	Test(int a, int b) 
	{
	test_a = a; 
	test_b = b; 
	}
	public static void main (String args[]) 
	{
		Test test = new Test(); 
		System.out.println(test.test_a+" "+test.test_b);
	}
}

输出

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
        The constructor Test() is undefined

程序中存在编译错误，因为主方法中调用了默认构造函数，但类中不存在。但是，类 Test 中只有一个带参数的构造函数。因此，构造函数不会隐式调用任何默认构造函数。

Core Java - 面向对象概念：static 关键字面试问题

39) 什么是静态变量？

静态变量用于指代所有对象的共同属性（对每个对象来说不是唯一的），例如，员工的公司名称、学生的大学名称等。静态变量在类加载时只在类区域中分配一次内存。使用静态变量可以使您的程序更节省内存（它节省内存）。静态变量属于类而不是对象。以下 Java 程序描述了静态变量的使用。

示例

public class Main {  
    int rollno;  
    String name;  
    static final String COLLEGE = "ITS";  
    Main(int r, String n) {  
        rollno = r;  
        name = n;  
    }  
    void display() { 
        System.out.println(rollno + " " + name + " " + COLLEGE); 
    }  
    public static void main(String[] args) {  
        Main obj1 = new Main (111, "Karan");
        Main obj2 = new Main(222, "Aryan");  
        obj1.display();  
        obj2.display();  
    }  
}

编译并运行

输出

111 Karan ITS
222 Aryan ITS

40) 什么是静态方法？

在 Java 中，静态变量是类级别的变量，它属于类而不是类的实例。它在类的所有实例之间共享，并且在类加载到内存中时只初始化一次。

静态方法属于类而不是对象。
无需创建对象即可调用静态方法。
静态方法可以访问和更改静态变量的值。

Java 中的静态关键字

41) Java 静态方法有哪些限制？

Java 静态方法具有某些限制和特性，使其与实例方法不同。以下是 Java 静态方法的主要限制和注意事项

对静态方法的两个主要限制如下

静态方法不能直接使用非静态数据成员或调用非静态方法。
this 和 super 关键字不能在静态上下文中使用，因为它们是非静态的。
Java 中的静态方法不能被重写。即使子类声明了一个与超类中的静态方法具有相同签名的静态方法，它也被认为是方法隐藏，而不是重写。

了解更多信息：Java 中的静态方法

42) 为什么 main() 方法是静态的？

因为调用静态方法不需要对象，如果我们将 main() 方法设为非静态，JVM 将不得不先创建其对象，然后调用 main() 方法，这将导致额外的内存分配。

主要原因如下

main() 方法是 Java 程序执行的入口点。当我们运行 Java 程序时，Java 虚拟机 (JVM) 会寻找具有以下签名的 main() 方法

当 Java 程序执行时，JVM 将类加载到内存中并寻找 main() 方法来启动程序。

了解更多信息：为什么 main() 方法在 Java 中总是静态的

43) 我们可以重写静态方法吗？

不，Java 中的静态方法不能被重写。虽然子类可以声明一个与超类中的静态方法具有相同签名的静态方法，但它被认为是方法隐藏，而不是方法重写。

44) 什么是静态块？

静态块用于初始化静态数据成员。它在 main() 方法执行之前，在类加载时执行。

示例

class Main {  
static { System.out.println("static block is invoked"); }  
public static void main(String args[]) {  
System.out.println("Hello main");  
}  
}  

编译并运行

输出

static block is invoked
       Hello main

了解更多信息：Java 中的静态块

45) 我们可以不使用 main() 方法执行程序吗？

不，在 Java 中，我们不能不使用 main() 方法执行程序。main() 方法作为 Java 程序执行的入口点，它必须定义在作为应用程序起点的每个 Java 类中。JVM 寻找具有以下签名的 main() 方法以开始程序执行

了解更多信息：Java main() 方法

46) 如果从 main 方法的签名中移除静态修饰符会怎样？

程序编译。如果从 Java 中 main() 方法的签名中移除 static 关键字，程序将成功编译，但无法成功运行。main() 方法必须声明为静态，因为它作为 Java 程序的入口点，Java 虚拟机 (JVM) 需要在不创建类的实例的情况下调用它。它会抛出“NoSuchMethodError”错误。

47) 静态（类）方法和实例方法之间有什么区别？

被声明为静态的方法称为静态方法。	未声明为静态的方法称为实例方法。
我们不需要创建对象来调用静态方法。	调用实例方法需要对象。
非静态（实例）成员不能直接在静态上下文（静态方法、静态块和静态嵌套类）中访问。	静态和非静态变量都可以在实例方法中访问。
例如：public static int cube(int n){ return nnn;}	例如：public void msg(){...}。

了解更多信息：Java 中静态方法和实例方法的区别

48) 我们可以将构造函数设为静态吗？

不，构造函数不能在 Java 中声明为静态，因为我们知道静态上下文（方法、块或变量）属于类，而不是对象。由于构造函数仅在创建对象时才被调用，因此将构造函数设为静态没有意义。将构造函数设为静态意味着它属于类而不是实例，这与构造函数的基本目的相矛盾。但是，如果我们尝试这样做，编译器将显示编译错误。

49) 我们可以将抽象方法在 Java 中设为静态吗？

不，抽象方法不能在 Java 中声明为静态。在 Java 中，如果我们将抽象方法设为静态，它们将成为类的一部分，我们可以直接调用它们，这是不必要的。由于抽象方法预期会被子类重写，因此将它们设为静态将与其目的相矛盾。调用未定义的方法完全无用；因此，不允许这样做。

50) 我们可以将静态变量和方法声明在抽象类中吗？

是的，在 Java 的抽象类中声明静态变量和方法是可能的。正如我们所知，访问静态上下文不需要创建对象；因此，我们可以使用抽象类的名称访问在抽象类中声明的静态上下文。

请看以下示例。

示例

abstract class Test
{  
    static int i = 102;  
    static void display()  
    {  
        System.out.println("hi !! I am good !!");  
    }  
}  
public class Main extends Test   
{  
    public static void main (String args[])  
    {  
        Test.display();  
        System.out.println("i = "+Test.i);  
    }  
}  

编译并运行

输出

hi !! I am good !!
i = 102

Core Java - 面向对象概念：继承面试问题

51) Java 中的 this 关键字是什么？

在 Java 中，this 关键字是一个引用变量，它指向当前对象。this 关键字在 Java 中有各种用途。它主要用于类的实例方法中，以引用调用该方法的对象。它可以用于引用当前类的属性，例如实例方法、变量、构造函数等。它还可以作为参数传递给方法或构造函数。它还可以作为当前类实例从方法中返回。

了解更多信息：Java 中的 this 关键字

52) this 关键字的用途是什么？

this 关键字有以下用途

它可以用于引用当前类的实例变量。
它可以用于（隐式）调用当前类的方法。
构造函数 this() 可以用于调用当前类的构造函数。
它可以作为参数传递给方法调用。
它可以作为参数传递给构造函数调用。
它可以用于从方法中返回当前类实例。

让我们通过一个 Java 程序来理解。

public class Main {  
    private int x;  
    public void setX(int x) {  
        this.x = x; // Using 'this' to refer to the instance variable  
    }  
}  

了解更多信息：Java 中的 this 关键字

53) 我们可以将引用赋值给 this 变量吗？

不，在 Java 中无法为 this 变量分配新值。this 关键字是对类当前实例的隐式引用，当调用方法时，Java 运行时系统会自动设置它。但是，如果尝试这样做，将显示编译器错误。请考虑以下示例。

示例

public class Main 
{  
    public Main()  
    {  
        this = null;   
        System.out.println("Main class constructor called");  
    }  
    public static void main (String args[])  
    {  
        Main obj = new Main();  
    }  
}  

编译并运行

输出

Main.java:5: error: cannot assign to 'this'
        this = null;   
        ^
1 error

54) this 关键字可以用于引用静态成员吗？

是的，可以使用 this 关键字来引用静态成员，因为它只是一个引用当前类对象的引用变量。但是，正如我们所知，通过对象访问静态变量是不必要的。因此，使用 this 引用静态成员不是最佳实践。请考虑以下示例。

public class Main
{  
    static int i = 10;   
    public Main()  
    {  
        System.out.println(this.i);      
    }  
    public static void main (String args[])  
    {  
        Main obj = new Main();  
    }  
}  

输出

55) 如何使用 this 关键字实现构造函数链？

构造函数链使我们能够针对当前类对象从类的另一个构造函数中调用一个构造函数。Java 中的构造函数链可以使用 this 关键字实现。请考虑以下示例，它说明了如何使用 this 关键字来实现构造函数链。

public class Employee  
{  
    int id,age;   
    String name, address;  
    public Employee (int age)  
    {  
        this.age = age;  
    }  
    public Employee(int id, int age)  
    {  
        this(age);  
        this.id = id;  
    }  
    public Employee(int id, int age, String name, String address)  
    {  
        this(id, age);  
        this.name = name;   
        this.address = address;   
    }  
    public static void main (String args[])  
    {  
        Employee emp = new Employee(105, 22, "Peter", "Delhi");  
        System.out.println("ID: "+emp.id+" Name: "+emp.name+" age: "+emp.age+" address: "+emp.address);  
    }  
}  

输出

ID: 105 Name: Peter age: 22 address: Delhi

了解更多信息：Java 中的构造函数链

56) 将 this 传递给方法而不是当前类对象本身有什么优点？

正如我们所知，this 引用当前类对象；因此，它必须与当前类对象相似。但是，将 this 传递给方法而不是当前类对象本身有两个主要优点。

this 是一个 final 变量。因此，this 不能被赋予任何新值，而当前类对象可能不是 final 并且可以更改。
this 关键字可以在同步块中使用。

将 this 传递给方法而不是当前类对象本身具有几个优点

灵活性
封装
一致性

57) 什么是继承？

继承是一种机制，一个对象通过它获取另一个类的另一个对象的所有属性和行为。它用于代码重用和方法重写。继承是面向对象编程 (OOP) 中的一个基本概念，它允许一个类（子类或派生类）从另一个类（超类或基类）继承属性和行为。此外，我们还可以在当前类中添加新的方法和字段。继承表示 IS-A 关系，也称为父子关系。

要阅读更多内容，请访问 Java 继承

Java 中有五种类型的继承

单层继承
多层继承
多重继承
层次继承
混合继承

注意：Java 不支持通过类实现多重继承。

了解更多信息：Java 中的继承类型

58) 为什么在 Java 中使用继承？

下面列出了在 Java 中使用继承的各种优点。

继承提供代码重用。继承允许子类从超类继承属性和行为，从而促进代码重用。通用功能可以在超类中定义，子类可以扩展或专门化它。
运行时多态性无法在不使用继承的情况下实现。
我们可以用实时对象模拟类的继承，这使得面向对象编程更加真实。
继承提供数据隐藏。基类可以通过将其设为私有来向派生类隐藏一些数据。
方法重写无法在没有继承的情况下实现。继承促进多态性，允许将子类的对象视为超类的对象。通过方法重写，我们可以为基类中包含的一些基本方法提供特定的实现。

了解更多信息：Java 中的继承

59) 哪个类是所有类的超类？

在 Java 中，Object 类是所有其他类的超类。Java 中的每个类都直接或间接扩展 Object 类。Object 类提供了所有类继承的基本方法，例如 toString()、equals()。

了解更多信息：Java 中的 Object 类

60) 为什么 Java 不支持多重继承？

为了降低复杂性并简化语言，Java 不支持多重继承。考虑一个场景，其中 A、B 和 C 是三个类。C 类继承 A 和 B 类。如果 A 和 B 类具有相同的方法，并且我们从子类对象调用它，那么在调用 A 或 B 类的方法时将存在歧义。

当一个类从具有共同祖先的两个类继承时，就会出现菱形问题，从而导致方法解析中的歧义。

由于编译时错误优于运行时错误，如果我们继承两个类，Java 会渲染编译时错误。因此，无论我们是否有相同的方法或不同的方法，都会出现编译时错误。

class A{  
void msg(){System.out.println("Hello");}  
}  
class B{  
void msg(){System.out.println("Welcome");}  
}  
class Main extends A,B{//suppose if it were  
 public Static void main(String args[]){  
   Main obj=new Main();  
   obj.msg();//Now which msg() method would be invoked?  
}  
}  

上面的程序会给出编译时错误。

了解更多信息：Java 中的多重继承

61) 什么是聚合？

聚合可以定义为两个类之间的关系，其中聚合类包含对其拥有的类的引用。

聚合是面向对象编程中一种关联类型，其中一个类包含另一个类的对象，从而在它们之间形成关系。它表示“has-a”关系，表明一个类将其结构的一部分作为一个实体。

例如，聚合类 Employee，具有年龄、姓名和工资等各种字段，还包含 Address 类的对象，具有地址行 1、城市、州和邮政编码等各种字段。

换句话说，我们可以说 Employee（类）有一个 Address 类的对象。请考虑以下示例。

Address.java

public class Address {  
String city, state, country;  
public Address(String city, String state, String country) {  
    this.city = city;  
    this.state = state;  
    this.country = country;  
}    
}  

Employee.java

public class Emp {  
int id;  
String name;  
Address address;  
public Emp(int id, String name,Address address) {  
    this.id = id;  
    this.name = name;  
    this.address=address;  
}  
void display(){  
System.out.println(id+" "+name);  
System.out.println(address.city+" "+address.state+" "+address.country);  
}  
public static void main(String[] args) {  
Address address1 = new Address("gzb", "UP", "India");  
Address address2 = new Address("gno", "UP", "India");  
Emp e=new Emp(111,"varun",address1);  
Emp e2=new Emp(112,"arun",address2);  
e.display();  
e2.display();  
}  
}  

输出

111 varun
gzb UP India
112 arun
gno UP India

了解更多信息：Java 中的聚合

62) 什么是组合？

组合是面向对象编程中一种更强的聚合形式。将一个类的引用保留在另一个类中称为组合。当一个对象包含另一个对象时，如果所包含的对象不能独立存在于容器对象之外，则称为组合。换句话说，我们可以说组合是聚合的一种特殊情况，它代表了两个对象之间更强的关系。示例：一个班级包含学生。学生不能独立存在于班级之外。班级和学生之间存在组合关系。

组合是一种通过组合对象形成更大、更复杂的系统来创建更健壮和更紧密集成结构的方式。

了解更多信息：Java 中的组合

63) 聚合和组合有什么区别？

聚合表示弱关系，而组合表示强关系。聚合表示“has-a”关系，其中一个类引用另一个类，但被引用的类可以独立存在。组合也表示“has-a”关系，但它是一种更强的关联形式。例如，自行车有指示灯（聚合），但自行车有发动机（组合）。

了解更多信息：Java 中聚合和组合的区别

64) 为什么 Java 不支持指针？

Java 不支持像 C 或 C++ 等语言中常见的显式指针，因为指针是引用内存地址的变量。它们在 Java 中不使用，因为它们不安全且难以理解。

65) Java 中的 super 是什么？

在 Java 中，super 是一个关键字，用于引用直接父类对象。每当您创建子类的实例时，都会隐式创建父类的实例，该实例由 super 引用变量引用。如果子类构造函数中没有 super 或 this，则编译器会隐式调用 super()。

super 关键字通常用于类扩展另一个类并且需要区分子类和超类成员的场景。

class Animal {  
Animal() { System.out.println("An animal is created"); }  
}  
class Dog extends Animal {  
Dog(){  
System.out.println(" A dog is created");  
}  
}  
class Main {  
public static void main(String args[]) {  
Dog d=new Dog();  
}  
}  

输出

An animal is created
A dog is created

了解更多信息：Java 中的 super 关键字

66) 如何使用 super 关键字实现构造函数链？

Java 中的构造函数链指的是在同一类或父类中从一个构造函数调用另一个构造函数的过程。super 关键字用于调用父类的构造函数。

示例

class Person  
{  
    String name, address;   
    int age;  
    public Person(int age, String name, String address)  
    {  
        this.age = age;  
        this.name = name;  
        this.address = address;  
    }  
}  
class Employee extends Person   
{  
    float salary;  
    public Employee(int age, String name, String address, float salary)  
    {  
        super(age,name,address);  
        this.salary = salary;  
    }  
}  
public class Main
{  
    public static void main (String args[])  
    {  
        Employee e = new Employee(22, "Mukesh", "Delhi", 90000);  
        System.out.println("Name: "+e.name+" Salary: "+e.salary+" Age: "+e.age+" Address: "+e.address);  
    }  
}  

编译并运行

输出

Name: Mukesh Salary: 90000.0 Age: 22 Address: Delhi

67) super 关键字的主要用途是什么？

super 关键字有以下用途

它用于引用直接父类实例变量。
它用于调用直接父类方法。
构造函数 super() 可以用于调用直接父类构造函数。

了解更多信息：Java 中的 super 关键字

68) this 和 super 关键字有什么区别？

this 和 super 关键字之间有以下区别

super 关键字始终指向父类上下文，而 this 关键字始终指向类的当前实例。

super 关键字主要用于在派生类构造函数中初始化基类变量，而 this 关键字主要用于在传递给类构造函数时区分局部变量和实例变量。

super 和 this 必须是构造函数内部的第一条语句，否则编译器将抛出错误。

了解更多信息：Java 中 this 和 super 的区别

69) 以下 Java 程序的输出是什么？

class Person 
{
    public Person() 
    {
        System.out.println("Person class constructor called");
    }
}
public class Employee extends Person 
{
    public Employee() 
    {
        System.out.println("Employee class constructor called");
    }
    public static void main (String args[])
    {
        Employee e = new Employee();
    }
}

输出

Person class constructor called
Employee class constructor called

说明

如果派生类构造函数中没有显式包含 super() 或 this()，则编译器会隐式调用 super()。因此，在这种情况下，首先调用 Person 类构造函数，然后调用 Employee 类构造函数。

70) 可以在构造函数中使用 this() 和 super() 吗？

不，您不能在同一个构造函数中同时使用 this() 和 super()，因为 this() 和 super() 必须是类构造函数中的第一条语句。在同一个构造函数中同时使用它们会导致编译错误。

示例

public class Main {  
    Main()  
     {  
         super();   
         this();  
         System.out.println("Main class object is created");  
     }  
     public static void main(String []args){  
     Main t = new Main();  
     }  
}  

输出

Main.java:5: error: call to this must be first statement in constructor

了解更多信息：Java 中 this 和 super 的区别

71) 什么是对象克隆？

Java 中的对象克隆指的是创建对象精确副本的过程。Object 类的 clone() 方法用于克隆对象。必须由要创建对象克隆的类实现 java.lang.Cloneable 接口。如果我们不实现 Cloneable 接口，clone() 方法会生成 CloneNotSupportedException。clone() 方法创建一个与原始对象具有相同状态的新对象。

了解更多信息：Java 中的对象克隆

Core Java - 面向对象概念：方法重载面试问题

72) 什么是方法重载？

方法重载是多态性技术，它允许我们创建多个同名但签名不同的方法。Java 中的方法重载发生在类有多个同名但参数列表不同（参数的数量、类型或顺序）的方法时。我们可以通过以下两种方式实现方法重载

不同数量的参数
不同数据类型的参数

方法重载提高了程序的阅读性。执行方法重载是为了快速找出程序。

了解更多信息：Java 中的方法重载

73) 为什么 Java 中不能通过改变返回类型来重载方法？

在 Java 中，通过改变程序的返回类型无法重载方法，以避免歧义。方法名称和参数类型决定了方法签名。仅改变返回类型不足以为编译器提供区分重载方法的信息。

class Adder{  
static int add(int a,int b){return a+b;}  
static double add(int a,int b){return a+b;}  
}  
class Main {  
public static void main(String[] args){  
System.out.println(Adder.add(11,11));//ambiguity  
}}  

输出

Compile Time Error: method add(int, int) is already defined in class Adder

74) 我们可以通过将方法设为静态来重载方法吗？

不，我们不能仅仅通过对方法应用 static 关键字来重载方法（参数数量和类型相同）。请看以下示例。

public class Animal
{
    void consume(int a)
    {
        System.out.println(a+" consumed!!");
    }
    static void consume(int a)
    {
        System.out.println("consumed static "+a);
    }
    public static void main (String args[])
    {
        Animal a = new Animal();
        a.consume(10);
        Animal.consume(20);
    }
}  

输出

Animal.java:7: error: method consume(int) is already defined in class Animal
    static void consume(int a)
                ^
Animal.java:15: error: non-static method consume(int) cannot be referenced from a static context
        Animal.consume(20);
              ^
2 errors

75) 我们可以重载 main() 方法吗？

是的，我们可以通过方法重载在 Java 程序中拥有任意数量的 main() 方法。但是，JVM 在启动 Java 程序时会寻找标准的 public static void main(String[] args) 签名。重载的 main() 方法可以在标准的 main() 方法中调用，但程序执行从标准的 main() 方法开始。

了解更多信息：我们可以在 Java 中重载 main() 方法吗

76) 什么是带有类型提升的方法重载？

通过类型提升进行方法重载，我们指的是如果没有找到精确匹配，一个数据类型可以隐式提升为另一个数据类型。

Java 方法重载与类型提升

如上图所示，byte 可以提升为 short、int、long、float 或 double。short 数据类型可以提升为 int、long、float 或 double。char 数据类型可以提升为 int、long、float 或 double，等等。请看以下示例。

class Main {  
  void sum(int a,long b){System.out.println(a+b);}  
  void sum(int a,int b,int c){System.out.println(a+b+c);}  
  public static void main(String args[]){  
Main obj=new Main();  
  obj.sum(20,20);//now second int literal will be promoted to long  
  obj.sum(20,20,20);  
  }  
}  

输出

40
60

77) 以下 Java 程序的输出是什么？

class Main {    
  void sum(int a,long b){System.out.println("a method invoked");}    
  void sum(long a,int b){System.out.println("b method invoked");}    
  public static void main(String args[]){    
Main obj = new Main();    
  obj.sum(20,20);//now ambiguity    
  }    
}    

输出

Main.java:7: error: reference to sum is ambiguous
obj.sum(20,20);//now ambiguity
^
both method sum(int,long) in Main
and method sum(long,int) in Main match
1 error

说明

这里定义了两个同名的方法，即 sum。第一个方法接受整数和长整型，而第二个方法接受长整型和整数类型。传递的参数是 a = 20，b = 20。我们无法判断将调用哪个方法，因为整数文字和长整型文字之间没有明确的区分。这是一种歧义情况。因此，编译器将抛出错误。

Core Java - 面向对象概念：方法重写面试问题

78) 什么是方法重写？

如果子类提供了其父类已提供的方法的特定实现，则称为方法重写。Java 中的方法重写发生在子类为其超类中已定义的方法提供特定实现时。它用于运行时多态性和实现接口方法。

方法重写的规则

方法必须与父类中的名称相同。
方法必须与父类中的签名相同。
两个类之间必须存在 IS-A 关系。

了解更多信息：Java 中的方法重写

79) 我们可以重写静态方法吗？

不，我们不能重写静态方法，因为它们是类的一部分，而不是对象。

了解更多信息：Java 中的静态方法

80) 为什么我们不能重写静态方法？

从与多态性相关的动态方法调度传统意义上讲，静态方法不能被覆盖。这是因为静态方法是类的一部分，它与类绑定，而实例方法与对象绑定，静态方法在类区域获得内存，实例方法在堆中获得内存。

81) 我们可以覆盖重载方法吗？

是的，我们可以覆盖 Java 中的重载方法。覆盖：覆盖是像 Java 这样的 OOP 语言的一个特性，与运行时多态性相关。子类（或派生类）提供了超类（或基类）中方法的特定实现。

82) 方法重载和方法覆盖有什么区别？

方法重载	方法重写
方法重载增加了程序的可读性。	方法覆盖提供了超类已经提供的方法的特定实现。
方法重载发生在类内部。	方法覆盖发生在两个具有 IS-A 关系的类中。
在这种情况下，参数必须不同。	在这种情况下，参数必须相同。

阅读更多：Java 中的方法重载与方法覆盖的区别

83) 我们可以覆盖私有方法吗？

不，我们不能覆盖 Java 中的私有方法，因为私有方法的范围仅限于类，我们不能在类之外访问它们。但是私有方法在类之外是不可访问的。因此，私有方法不能被覆盖，因为子类不继承它们。

84) 我们可以在子类中更改被覆盖方法的范围吗？

是的，我们可以在子类中更改被覆盖方法的范围。但是，我们必须注意，我们不能降低方法的访问性。在更改方法的访问性时，必须注意以下几点。

私有访问修饰符可以更改为 protected、public 或 default。
protected 访问修饰符可以更改为 public 或 default。
default 访问修饰符可以更改为 public。
public 访问修饰符将始终保持 public。

85) 在子类中覆盖超类方法时，我们可以修改其 throws 子句吗？

是的，在子类中覆盖超类方法时，我们可以修改其 throws 子句。但是，在异常处理的情况下，覆盖时需要遵循一些规则。

如果超类方法不声明异常，则子类的覆盖方法不能声明检查异常，但可以声明未检查异常。
如果超类方法声明了异常，则子类覆盖方法可以声明相同的异常、子类异常或不声明异常，但不能声明父异常。

86) 以下 Java 程序的输出是什么？

示例

class Base  
{  
    void method(int a)  
    {  
        System.out.println("Base class method called with integer a = "+a);  
    }  
    void method(double d)  
    {  
        System.out.println("Base class method called with double d ="+d);  
    }  
}  
class Derived extends Base  
{  
    @Override  
    void method(double d)  
    {  
        System.out.println("Derived class method called with double d ="+d);  
    }  
}  
public class Main  
{      
    public static void main(String[] args)  
    {  
        new Derived().method(10);  
    }  
}  
}

编译并运行

输出

Base class method called with integer a = 10

说明

在 Base 类中，method() 被重载，而在 Derived 类中，它被派生为 double 类型参数。在方法调用中，传递了整数。

87) Java 中有虚函数吗？

是的，Java 中的所有函数默认都是虚拟的。这意味着方法调用是在运行时根据调用方法的对象的实际类型确定的。因此，虽然 Java 中没有明确使用“虚拟”一词，但通过动态方法调度和方法覆盖机制，该概念是存在的。

阅读更多：Java 中的虚函数

88) 什么是协变返回类型？

从 Java 5 开始，如果子类覆盖方法的返回类型是子类类型，则可以通过更改返回类型来覆盖任何方法。这被称为协变返回类型。协变返回类型指定返回类型可以与子类方向相同地变化。

示例

class A {  
A get(){return this;}  
}  
class Main extends A {  
Main get() {
return this; }  
void message() { 
System.out.println("Welcome to the covariant return type");}  
public static void main(String args[]){  
new Main().get().message();  
}  
}  

编译并运行

输出

Welcome to the covariant return type

阅读更多：Java 中的协变返回类型

89) 以下 Java 程序的输出是什么？

示例

class Base   
{  
    public void baseMethod()  
    {  
        System.out.println("BaseMethod called ...");  
    }  
}  
class Derived extends Base   
{  
    public void baseMethod()  
    {  
        System.out.println("Derived method called ...");  
    }  
}  
public class Main
{  
    public static void main (String args[])  
    {  
        Base b = new Derived();  
        b.baseMethod();  
    }  
}  

编译并运行

输出

Derived method called ...

说明

Base 类的方法，即 baseMethod()，在派生类中被覆盖。在 Main 类中，引用变量 b（Base 类类型）引用 Derived 类的实例。这里，在 Base 类和 Derived 类之间实现了运行时多态性。

在编译时，检查 Base 类中是否存在 baseMethod() 方法；如果存在，则程序被编译，否则将显示编译器错误。在这种情况下，baseMethod() 存在于 Base 类中；因此，它被成功编译。

但是，在运行时，它会检查 baseMethod() 是否已被 Derived 类覆盖；如果是，则调用 Derived 类方法，否则调用 Base 类方法。在这种情况下，Derived 类覆盖了 baseMethod()；因此，调用 Derived 类方法。

核心 Java - OOP 概念：final 关键字面试问题

90) 什么是 final 变量？

在 Java 中，final 变量用于限制用户更新它。如果初始化 final 变量，则不能更改其值。final 关键字用于声明 final 变量。换句话说，我们可以说 final 变量一旦被赋值，就永远不能更改。未赋值的 final 变量只能通过类构造函数赋值。

class Main {  
 final int speedlimit=90;//final variable  
 void run(){  
  speedlimit=400;  
 }  
 public static void main(String args[]){  
Main obj=new Main();  
 obj.run();  
 }  
}//end of class  

输出

Compile Time Error

阅读更多：Java 中的 final 变量

91) 什么是 final 方法？

如果我们将任何方法更改为 final 方法，则无法覆盖它。在 Java 中，final 方法是子类不能覆盖的方法。当方法在超类中声明为 final 时，这意味着没有子类可以为该方法提供不同的实现。

class Bike{  
  final void run(){System.out.println("running");}  
}  
class Main extends Bike{  
   void run(){System.out.println("running safely with 100kmph");}  
   public static void main(String args[]){  
   Main obj = new Main();  
   obj.run();  
   }  
}  

输出

Compile Time Error

92) 什么是 final 类？

如果我们将一个类设为 final，则不能将其继承到任何子类中。

在 Java 中，final 类是不能被子类化的类。当一个类被声明为 final 时，这意味着没有其他类可以扩展（继承自）它。

final class Bike{}    
class Main extends Bike{  
  void run(){System.out.println("running safely with 100kmph");}  
  public static void main(String args[]){  
  Main obj = new Main();  
  Obj.run();  
  }  
}  

输出

Compile Time Error

阅读更多：Java 中的 final 关键字

93) 什么是 final 空白变量？

在 Java 中，final 空白变量指的是在声明时未初始化但在使用前必须精确初始化一次的空白 final 变量。“空白”一词意味着变量在声明时没有初始值。当用户有一些数据不应该被其他人更改时，例如 PAN 号码，这很有用。考虑以下示例

class Student{
int id;
String name;
final String PAN_CARD_NUMBER;
...
}

阅读更多：Java 中的空白 final

94) 我们可以初始化 final 空白变量吗？

是的，如果它不是静态的，我们可以在构造函数中初始化它。如果它是静态的、空白的 final 变量，则只能在静态块中初始化。

95) 我们可以将 main() 方法声明为 final 吗？

是的，我们可以将 main() 方法声明为 public static final void main(String[] args){}. 从技术上讲，允许将 main 方法声明为 final，但它不会有任何影响或特殊意义。final 关键字应用于方法时，表示子类不能覆盖该方法。

96) 以下 Java 程序的输出是什么？

class Main {
 public static void main(String args[]){
   final int i;
   i = 20;
   System.out.println(i);
 }
}

输出

说明

由于 i 是空白 final 变量，因此只能初始化一次。我们将其初始化为 20。因此，将打印 20。

97) 以下 Java 程序的输出是什么？

class Base   
{  
    protected final void getInfo()  
    {  
        System.out.println("method of Base class");  
    }  
}  
public class Derived extends Base  
{  
    protected final void getInfo()  
    {  
        System.out.println("method of Derived class");  
    }  
    public static void main(String[] args)  
    {  
        Base obj = new Base();  
        obj.getInfo();  
    }  
}  

输出

Main.java:10: error: getInfo() in Main cannot override getInfo() in Base
    protected final void getInfo()  
                         ^
  overridden method is final
1 error

说明

getDetails() 方法是 final 的；因此，不能在子类中覆盖它。

98) 我们可以将构造函数声明为 final 吗？

不，构造函数不能在 Java 中声明为 final，因为它从不被继承。构造函数不是普通方法；因此，将构造函数声明为 final 没有任何意义。但是，如果尝试这样做，编译器将抛出错误。

99) 我们可以将接口声明为 final 吗？

不，我们不能将接口声明为 final，因为某些类必须实现接口才能提供其定义。接口的整个思想是提供一个类可以实现的契约。将接口设为 final 会违背允许类实现它的目的。但是，如果尝试这样做，编译器将显示错误。

100) final 方法和抽象方法有什么区别？

final 方法： 类中的 final 方法不能被子类覆盖。一旦方法被声明为 final，就不能被任何子类修改或覆盖。

抽象方法： 抽象方法是在抽象类或接口中声明的方法，在声明它的类/接口中没有实现。子类或实现类必须为抽象方法提供具体的实现。

final 方法和抽象方法的主要区别在于抽象方法不能是 final 的，因为我们需要在子类中覆盖它以给出其定义。

阅读更多：Java 中的抽象方法

下一个主题Java 面试问题第 2 部分

1 2 3 4 5

Java 基础面试问题	Java OOPs 面试问题
Java 多线程面试问题	Java 字符串和异常面试问题
Java 集合面试问题	JDBC 面试问题
Servlet面试题	JSP面试题
Spring 面试问题	Hibernate面试题
PL/SQL 面试问题	SQL面试题
Oracle 面试问题	Android 面试问题
SQL Server 面试问题	MySQL 面试问题

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

所有面试

公司面试

Technical Interview

Web Interview

PHP面试

.Net面试

Java Interview

Database Interview

300 个 Core Java 面试问题和答案

90% 的面试问题保证

Core Java：Java 基础面试问题

1) 什么是 Java？

2) C++ 和 Java 有什么区别？

3) 列出 Java 编程语言的特性。

4) 您对 Java 虚拟机 (JVM) 有何理解？

5) JDK、JRE 和 JVM 有什么区别？

6) JVM 分配了多少种内存区域？

7) 什么是 JIT 编译器？

8) 什么是平台？

9) Java 平台与其他平台的主要区别是什么？

10) 是什么赋予了 Java “一次编写，随处运行”的特性？

11) 什么是类加载器？

12) 空的 .java 文件名是否是有效的源文件名？

13) delete、next、main、exit 或 null 是 Java 中的关键字吗？

14) 如果我在命令行上没有提供任何参数，那么传递给 main() 方法的 String 数组中存储的值是空的还是 NULL？

15) 如果我们写 static public void 而不是 public static void 会怎样？

16) 局部变量的默认值是什么？

17) Java 中有哪些访问修饰符？

18) 静态方法和变量的目的是什么？

19) Java 中包的优点是什么？

20) 以下 Java 程序的输出是什么？

示例

21) 以下 Java 程序的输出是什么？

示例

22) 以下 Java 程序的输出是什么？

Core Java - 面向对象概念：初始面向对象面试问题

23) 什么是面向对象范式？

24) 什么是对象？

25) 面向对象编程语言和基于对象的编程语言有什么区别？

26) 定义为实例变量的对象引用的初始值是什么？

Core Java - 面向对象概念：构造函数面试问题

27) 什么是构造函数？

28) Java 中使用多少种类型的构造函数？

29) 默认构造函数的目的是什么？

示例

30) 构造函数会返回任何值吗？

31) 构造函数是否可以继承？

32) 您可以将构造函数设为 final 吗？

33) 我们可以重载构造函数吗？

示例

34) 您对 Java 中的复制构造函数有何理解？

示例

35) 构造函数和方法之间有什么区别？

36) 以下 Java 程序的输出是什么？

示例

37) 以下 Java 程序的输出是什么？

示例

38) 以下 Java 程序的输出是什么？

Core Java - 面向对象概念：static 关键字面试问题

39) 什么是静态变量？