300个核心Java面试问题和答案（一）

本文概述

• 核心Java：Java面试问题的基础
• 核心Java-OOP概念：初始OOP面试问题
• 核心Java-OOPs概念：构造函数面试问题
• 核心Java-OOPs概念：静态关键字面试问题
• 核心Java-OOPs概念：继承面试问题
• 核心Java-OOPs概念：方法重载面试问题
• 核心Java-OOPs概念：方法覆盖面试问题
• Java核心-OOPs概念：最终关键字面试问题

90％的面试问题保证

这里列出了300个Java核心面试问题。如果有任何核心Java面试问题被问到你, 请将其张贴在”问题”部分。我们保证你将获得90％的面试常见问题解答。

回答核心Java访谈问题的答案很简短。核心Java面试问题分为Java面试问题基础, OOPs面试问题, String Handling面试问题, 多线程面试问题, 集合面试问题, JDBC面试问题等。

1 2 3 4 5

核心Java：Java面试问题的基础

1)什么是Java？

Java是高级的, 面向对象的, 健壮的, 安全的编程语言, 与平台无关, 高性能, 多线程和可移植的编程语言。它由James Gosling于1991年6月开发。由于它提供了自己的JRE和API, 因此也可以称为平台。

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

下表列出了C ++和Java之间的区别。

3)列出Java编程语言的功能。

Java编程语言具有以下功能。

简单：Java很容易学习。 Java的语法基于C ++, 这使得使用C ++编写程序更加容易。

面向对象：Java遵循了面向对象的范例, 该范例使我们能够将包含数据和行为的不同类型的对象组合在一起来维护代码。

可移植：Java支持随时随地读取一次写入方法。我们可以在每台机器上执行Java程序。 Java程序(.java)转换为字节码(.class), 可以在每台计算机上轻松运行。

平台无关：Java是平台无关的编程语言。它与需要平台执行的其他编程语言(例如C和C ++)不同。 Java带有其平台, 可以在其平台上执行其代码。 Java不依赖于要执行的操作系统。

安全的：Java是安全的, 因为它不使用显式指针。 Java还提供了ByteCode和Exception处理的概念, 这使其更加安全。

健壮：Java是一种强大的编程语言, 因为它使用了强大的内存管理。像自动垃圾收集, 异常处理等概念使它更加健壮。

体系结构中立：Java是体系结构中立的, 因为它不依赖于体系结构。在C语言中, 数据类型的大小可能会根据Java中不存在的体系结构(32位或64位)而有所不同。

解释：Java使用即时(JIT)解释器和编译器来执行程序。

高性能：Java比其他传统的解释型编程语言要快, 因为Java字节码”接近”本机代码。它仍然比编译语言(例如C ++)慢一点。

多线程：我们可以通过定义多个线程来编写可同时处理许多任务的Java程序。多线程的主要优点是它不会占用每个线程的内存。它共享一个公共存储区。线程对于多媒体, Web应用程序等非常重要。

分布式：Java是分布式的, 因为它有助于用户使用Java创建分布式应用程序。 RMI和EJB用于创建分布式应用程序。 Java的这一功能使我们能够通过从互联网上的任何计算机上调用方法来访问文件。

动态的：Java是一种动态语言。它支持动态加载类。这意味着类是按需加载的。它还支持其本地语言(即C和C ++)中的功能。

4)你对Java虚拟机了解什么？

Java虚拟机是使计算机能够运行Java程序的虚拟机。 JVM的作用类似于运行时引擎, 该引擎调用Java代码中存在的main方法。 JVM是必须在计算机系统中实现的规范。 JVM将Java代码编译为一个字节码, 该字节码与机器无关并且与本机代码接近。

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

虚拟机

JVM是Java虚拟机的首字母缩写。它是一种抽象机, 提供了可以在其中执行Java字节码的运行时环境。它是指定Java虚拟机工作方式的规范。它的实现已由Oracle和其他公司提供。它的实现称为JRE。

JVM可用于许多硬件和软件平台(因此JVM取决于平台)。这是一个运行时实例, 是在我们运行Java类时创建的。 JVM有三种概念：规范, 实现和实例。

杰瑞

JRE代表Java Runtime Environment。它是JVM的实现。 Java运行时环境是用于开发Java应用程序的一组软件工具。它用于提供运行时环境。它是JVM的实现。它实际上存在。它包含JVM在运行时使用的一组库+其他文件。

JDK

JDK是Java Development Kit的首字母缩写。这是一个软件开发环境, 用于开发Java应用程序和小程序。它实际上存在。它包含JRE +开发工具。 JDK是Oracle公司发布的以下任何给定Java平台的实现：

• 标准版Java平台
• 企业版Java平台
• 微型版Java平台

更多细节。

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

许多类型：

1. 类(方法)区域：类区域存储每个类的结构, 例如运行时常量池, 字段, 方法数据和方法代码。
2. 堆：这是运行时数据区, 在其中将内存分配给对象
3. 堆栈：Java堆栈存储框架。它保存局部变量和部分结果, 并在方法调用和返回中起作用。每个线程都有一个私有JVM堆栈, 与该线程同时创建。每次调用方法时都会创建一个新框架。框架的方法调用完成后将销毁。
4. 程序计数器寄存器：PC(程序计数器)寄存器包含当前正在执行的Java虚拟机指令的地址。
5. 本机方法堆栈：它包含应用程序中使用的所有本机方法。

更多细节。

7)什么是JIT编译器？

即时(JIT)编译器：用于提高性能。 JIT同时编译具有相似功能的字节码部分, 从而减少了编译所需的时间。这里的术语”编译器”是指从Java虚拟机(JVM)的指令集到特定CPU的指令集的转换器。

8)什么平台？

平台是在其中执行软件的硬件或软件环境。有两种类型的平台, 基于软件的平台和基于硬件的平台。 Java提供了基于软件的平台。

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

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

• Java是基于软件的平台, 而其他平台可能是硬件平台或基于软件的平台。
• Java在其他硬件平台之上执行, 而其他平台只能具有硬件组件。

10)是什么使Java具有”编写一次即可在任何地方运行”的特性？

字节码。 Java编译器将Java程序转换为类文件(字节代码), 该文件是源代码和机器代码之间的中间语言。此字节码不是特定于平台的, 可以在任何计算机上执行。

11)什么是类加载器？

Classloader是JVM的子系统, 用于加载类文件。每当我们运行Java程序时, 它都会由类加载器首先加载。 Java中有三个内置的类加载器。

1. Bootstrap ClassLoader：这是第一个类加载器, 它是Extension类加载器的超类。它加载rt.jar文件, 该文件包含Java Standard Edition的所有类文件, 例如java.lang包类, java.net包类, java.util包类, java.io包类, java.sql包类等。
2. 扩展ClassLoader：这是Bootstrap的子类加载器, 是System类加载器的父类加载器。它加载位于$ JAVA_HOME / jre / lib / ext目录中的jar文件。
3. 系统/应用程序类加载器：这是扩展类加载器的子类加载器。它从类路径加载类文件。默认情况下, 类路径设置为当前目录。你可以使用” -cp”或” -classpath”开关更改类路径。它也被称为应用程序类加载器。

12)Empty .java文件名是有效的源文件名吗？

是的, Java仅允许通过.java保存我们的java文件, 我们需要通过javac .java进行编译, 并由java classname运行。让我们举一个简单的例子：

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

通过javac .java进行编译

由Java A运行

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

编号

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

它为空, 但不为null。

15)如果我写静态公共无效而不是公共静态无效怎么办？

该程序可以编译并正确运行, 因为在Java中说明符的顺序无关紧要。

16)局部变量的默认值是多少？

局部变量未初始化为任何默认值, 即原始变量或对象引用均未初始化。

17)Java中的各种访问说明符是什么？

在Java中, 访问说明符是关键字, 用于定义方法, 类或变量的访问范围。在Java中, 下面给出了四个访问说明符。

• 公共类, 方法或定义为公共的变量可以由任何类或方法访问。
• 受保护的受保护的可以通过同一包的类, 此类的子类或在同一类中进行访问。
• 默认值默认值仅在软件包中可用。默认情况下, 所有类, 方法和变量都属于默认范围。
• 私有只能在该类内访问定义为私有的私有类, 方法或变量。

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

定义为静态的方法或变量在该类的所有对象之间共享。静态是类的一部分, 而不是对象的一部分。静态变量存储在类区域中, 我们无需创建对象即可访问此类变量。因此, 在需要定义该类所有对象通用的变量或方法的情况下, 使用静态方法。

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

19)Java包的优点是什么？

在Java中定义包有很多优点。

• 软件包避免名称冲突。
• 该软件包提供了更轻松的访问控制。
• 我们还可以具有隐藏的类, 这些隐藏的类在包外部不可见, 而被包使用。
• 查找相关的类比较容易。

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

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

上面代码的输出将是

30srcmini
srcmini1020

解释

在第一种情况下, 将10和20视为数字并加为30。现在, 将它们的总和30视为字符串, 并与字符串srcmini连接。因此, 输出将为30srcmini。

在第二种情况下, 字符串srcmini与10串联为字符串srcmini10, 然后将字符串20与srcmini1020串联。

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

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

上面代码的输出将是

200srcmini
srcmini200

解释

在第一种情况下, 首先将数字10和20相乘, 然后将结果200视为字符串, 并与字符串srcmini串联以产生输出200srcmini。

在第二种情况下, 数字10和20将首先相乘为200, 因为乘法的优先级高于加法。结果200将被视为字符串, 并与字符串srcmini串联以产生srcmini200的输出。

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

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

上面的代码将给出编译时错误, 因为for循环在第二部分中需要一个布尔值, 并且我们提供了一个整数值, 即0。

Java核心-OOP概念：初始OOP面试问题

提供了超过50个OOP(面向对象编程和系统)面​​试问题。但是, 为了更好地理解它们, 它们被分为许多部分, 例如构造函数面试问题, 静态面试问题, 继承面试问题, 抽象面试问题, 多态面试问题等。

23)什么是面向对象的范例？

它是一种编程范例, 它基于对象, 该对象具有在其所属类中定义的数据和方法。面向对象的范例旨在整合模块化和可重用性的优点。对象是类的实例, 它们相互交互以设计应用程序和程序。面向对象范例具有以下功能。

• 在程序设计中遵循自下而上的方法。
• 专注于数据, 并采用可操作对象数据的方法
• 包括诸如封装和抽象之类的概念, 该概念向用户隐藏了复杂性, 仅显示功能。
• 实现实时方法, 如继承, 抽象等。
• 面向对象范例的示例是C ++, Simula, Smalltalk, Python, C＃等。

24)什么是物体？

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

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

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

• 面向对象的语言遵循OOP的所有概念, 而基于对象的语言并不遵循诸如继承和多态性的所有OOP概念。
• 面向对象的语言没有内置对象, 而基于对象的语言则具有内置对象, 例如, JavaScript有窗口对象。
• 面向对象编程的示例是Java, C＃, Smalltalk等, 而基于对象的语言的示例是JavaScript, VBScript等。

26)被定义为实例变量的对象引用的初始值是多少？

在Java中, 所有对象引用均初始化为null。

核心Java-OOPs概念：构造函数面试问题

27)什么是构造函数？

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

更多细节。

28)Java中使用了多少种构造函数？

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

• 默认构造函数：默认构造函数是不接受任何值的构造函数。默认构造函数主要用于使用默认值初始化实例变量。它也可以用于执行一些有关对象创建的有用任务。如果在类中没有定义构造函数, 则编译器会隐式调用默认构造函数。
• 参数化构造函数：参数化构造函数是可以使用给定值初始化实例变量的构造函数。换句话说, 可以说可以接受参数的构造函数称为参数化构造函数。

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

默认构造函数的目的是为对象分配默认值。如果类中没有构造函数, 则Java编译器会隐式创建一个默认构造函数。

class Student3{
int id;
String name;

void display(){System.out.println(id+" "+name);}

public static void main(String args[]){
Student3 s1=new Student3();
Student3 s2=new Student3();
s1.display();
s2.display();
}
}

立即测试

输出

0 null
0 null

说明：在上面的类中, 你没有创建任何构造函数, 因此编译器为你提供了默认的构造函数。这里默认构造函数提供0和null值。

更多细节。

30)构造函数是否返回任何值？

回答：是的, 构造函数隐式返回类的当前实例(你不能在构造函数中使用显式的返回类型)。更多细节。

31)构造函数是继承的吗？

不, 构造函数不继承。

32)你可以使构造函数最终化吗？

不, 构造函数不能是最终的。

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);
	}
}

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

34)你对Java中的复制构造函数了解什么？

java中没有副本构造函数。但是, 我们可以将值从一个对象复制到另一个对象, 例如C ++中的复制构造函数。

在Java中, 有很多方法可以将一个对象的值复制到另一个对象中。他们是：

• 按构造函数
• 通过将一个对象的值分配给另一个对象
• 通过Object类的clone()方法

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

//Java program to initialize the values from one object to another
class Student6{
    int id;
    String name;
    //constructor to initialize integer and string
    Student6(int i, String n){
    id = i;
    name = n;
    }
    //constructor to initialize another object
    Student6(Student6 s){
    id = s.id;
    name =s.name;
    }
    void display(){System.out.println(id+" "+name);}
 
    public static void main(String args[]){
    Student6 s1 = new Student6(111, "Karan");
    Student6 s2 = new Student6(s1);
    s1.display();
    s2.display();
   }
}

立即测试

输出

111 Karan
111 Karan

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

构造函数和方法之间有许多差异。它们在下面给出。

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

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

以下程序的输出是：

a = 10 b = 15

此处, 变量a和b的数据类型(即字节)被提升为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);
	}
}

程序中存在编译器错误, 因为在main方法中有一个对默认构造函数的调用, 而该调用在类中不存在。但是, 在Test类中只有一个参数化的构造函数。因此, 构造函数不会隐式调用默认构造函数。

核心Java-OOPs概念：静态关键字面试问题

39)什么是静态变量？

静态变量用于引用所有对象的公共属性(每个对象不是唯一的), 例如, 员工的公司名称, 学生的大学名称等。静态变量仅在以下位置的类区域中获得内存上课时间。使用静态变量可使你的程序更高效地使用内存(节省内存)。静态变量属于类而不是对象。

//Program of static variable

class Student8{
   int rollno;
   String name;
   static String college ="ITS";
   
   Student8(int r, String n){
   rollno = r;
   name = n;
   }
 void display (){System.out.println(rollno+" "+name+" "+college);}

 public static void main(String args[]){
 Student8 s1 = new Student8(111, "Karan");
 Student8 s2 = new Student8(222, "Aryan");
 
 s1.display();
 s2.display();
 }
}

立即测试

Output:111 Karan ITS
       222 Aryan ITS

更多细节。

40)什么是静态方法？

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

更多细节。

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

静态方法有两个主要限制。

• 静态方法不能使用非静态数据成员或直接调用非静态方法。
• this和super不能在静态上下文中使用, 因为它们是非静态的。

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

因为不需要调用该对象的静态方法。如果我们将main方法设为非静态, 则JVM将必须首先创建其对象, 然后调用main()方法, 这将导致额外的内存分配。更多细节。

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

不, 我们不能覆盖静态方法。

44)什么是静态块？

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

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

立即测试

Output: static block is invoked
       Hello main

更多细节。

45)我们可以执行没有main()方法的程序吗？

回答)是的, 在没有主要方法的情况下执行程序的一种方法是使用静态块。更多细节。

46)如果从主方法的签名中删除了静态修饰符怎么办？

程序编译。但是, 在运行时, 它将引发错误” NoSuchMethodError”。

47)静态(类)方法和实例方法有什么区别？

48)我们可以使构造函数静态化吗？

我们知道静态上下文(方法, 块或变量)属于类, 而不是对象。由于仅在创建对象时才调用构造函数, 因此没有使构造函数静态化的意义。但是, 如果尝试这样做, 编译器将显示编译器错误。

49)我们可以在Java中使抽象方法静态化吗？

在Java中, 如果我们使抽象方法静态化, 它将成为类的一部分, 我们可以直接调用它, 这是不必要的。调用未定义的方法完全没有用, 因此是不允许的。

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

是的, 我们可以在抽象方法中声明静态变量和方法。我们知道不需要使对象访问静态上下文, 因此, 我们可以使用抽象类的名称来访问在抽象类内部声明的静态上下文。考虑以下示例。

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

输出

hi !! I am good !!
i = 102

核心Java-OOPs概念：继承面试问题

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

this关键字是引用当前对象的参考变量。 Java中此关键字有多种用法。它可以用来引用当前类的属性, 例如实例方法, 变量, 构造函数等。它也可以作为参数传递给方法或构造函数。也可以从方法中将其作为当前类实例返回。

更多细节。

52)此关键字的主要用途是什么？

此关键字有以下用途。

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

53)我们可以将引用分配给该变量吗？

不, 不能将其分配给任何值, 因为它始终指向当前的类对象, 并且这是Java中的最终引用。但是, 如果尝试这样做, 将显示编译器错误。考虑以下示例。

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

输出

Test.java:5: error: cannot assign a value to final variable this
        this = null; 
        ^
1 error

54)可以使用该关键字来引用静态成员吗​​？

是的, 可以使用此关键字来引用静态成员, 因为这只是引用当前类对象的引用变量。但是, 我们知道, 没有必要通过对象访问静态变量, 因此, 最佳做法是使用它来引用静态成员。考虑以下示例。

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

输出

10

55)如何使用此关键字完成构造函数链接？

构造函数链接使我们可以相对于当前类对象从该类的另一个构造函数调用一个构造函数。我们可以使用此关键字在同一类中执行构造函数链接。考虑以下示例, 该示例说明了如何使用此关键字来实现构造函数链接。

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, "Vikas", "Delhi");
        System.out.println("ID: "+emp.id+" Name:"+emp.name+" age:"+emp.age+" address: "+emp.address);
    }
    
}

输出

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

56)将其传递给方法而不是当前类对象本身有什么好处？

我们知道, 这是指当前类对象, 因此, 它必须类似于当前类对象。但是, 将其传递给方法而不是当前类对象有两个主要优点。

• 这是一个最终变量。因此, 不能将其分配给任何新值, 而当前类对象可能不是最终值, 可以更改。
• 可以在同步块中使用。

57)什么是继承？

继承是一种机制, 通过这种机制, 一个对象可以获取另一类的另一个对象的所有属性和行为。它用于代码可重用性和方法重写。 Java继承的思想是可以创建基于现有类的新类。从现有类继承时, 可以重用父类的方法和字段。此外, 你还可以在当前类中添加新的方法和字段。继承表示IS-A关系, 也称为父子关系。

Java有五种继承类型。

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

Java通过类不支持多重继承。

更多细节。

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

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

• 继承提供代码可重用性。派生类不需要重新定义基类的方法, 除非它需要提供该方法的特定实现。
• 不使用继承就无法实现运行时多态。
• 我们可以使用实时对象模拟类的继承, 这使OOP更加逼真。
• 继承提供数据隐藏。基类可以通过将其设为私有来隐藏派生类中的某些数据。
• 没有继承就无法实现方法重写。通过方法重写, 我们可以给出基类所包含的一些基本方法的特定实现。

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

对象类是Java中所有其他类的超类。

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

为了降低复杂性并简化语言, java不支持多重继承。考虑一个场景, 其中A, B和C是三个类别。 C类继承A和B类。如果A和B类具有相同的方法, 并且你从子类对象调用它, 则将有歧义来调用A或B类的方法。

由于编译时错误比运行时错误要好, 因此如果你继承2个类, 则Java会呈现编译时错误。因此, 无论你使用的是相同的方法还是不同的方法, 都会出现编译时错误。

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

立即测试

Compile Time Error

61)什么是聚合？

聚合可以定义为两个类之间的关系, 其中聚合类包含对其拥有的类的引用。最好将聚合描述为”具有”关系。例如, 具有各种字段(例如年龄, 姓名和薪水)的汇总类Employee还包含具有各种字段(例如地址行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

62)什么是成分？

将某个类的引用保存在其他某个类中的方法称为组合。当一个对象包含另一个对象时, 如果所包含的对象在没有容器对象的情况下无法存在, 则称为合成。换句话说, 我们可以说合成是聚合的特殊情况, 它代表了两个对象之间更强的关系。示例：一个班级包含学生。没有班级就不可能存在学生。班级与学生之间存在组成。

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

聚集代表弱关系, 而组成代表强关系。例如, 自行车具有指示器(集合), 但是自行车具有发动机(组成)。

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

指针是一个引用内存地址的变量。在Java中不使用它们, 因为它们不安全(不安全)并且理解起来很复杂。

65)Java中的超级是什么？

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

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

立即测试

输出

animal is created
dog is created

更多细节。

66)如何使用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 Test 
{
    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可用于引用直接父类实例变量。
• super可用于调用直接父类方法。
• super()可用于调用直接父类构造函数。

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

此关键字和super关键字之间存在以下差异。

• super关键字始终指向父类上下文, 而此关键字始终指向当前类上下文。
• super关键字主要用于初始化派生类构造函数中的基类变量, 而此关键字主要用于在传递给类构造函数时区分局部变量和实例变量。
• super和this必须是构造函数中的第一条语句, 否则编译器将抛出错误。

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()必须是类构造函数中的第一条语句。

例：

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

输出

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

71)什么是对象克隆？

对象克隆用于创建对象的精确副本。 Object类的clone()方法用于克隆对象。 java.lang.Cloneable接口必须由我们要创建其对象克隆的类实现。如果我们不实现Cloneable接口, 则clone()方法将生成CloneNotSupportedException。

protected Object clone() throws CloneNotSupportedException

更多细节。

核心Java-OOPs概念：方法重载面试问题

72)什么是方法重载？

方法重载是一种多态技术, 它允许我们创建具有相同名称但具有不同签名的多个方法。我们可以通过两种方式实现方法重载。

• 更改参数数量
• 更改退货类型

方法重载提高了程序的可读性。执行方法重载以快速找出程序。

更多细节。

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 TestOverloading3{
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程序中拥有许多主要方法。

更多细节。

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

“类型提升”是方法重载, 我们的意思是, 如果未找到精确匹配, 则可以将一个数据类型隐式提升为另一种数据类型。

如上图所示, 该字节可以提升为short, int, long, float或double。 short数据类型可以提升为int, long, float或double。 char数据类型可以提升为int, long, float或double等。考虑以下示例。

class OverloadingCalculation1{
  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[]){
  OverloadingCalculation1 obj=new OverloadingCalculation1();
  obj.sum(20, 20);//now second int literal will be promoted to long
  obj.sum(20, 20, 20);
  }
}

立即测试

输出

40
60

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

class OverloadingCalculation3{  
  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[]){  
  OverloadingCalculation3 obj=new OverloadingCalculation3();  
  obj.sum(20, 20);//now ambiguity  
  }  
}

输出

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

解释

定义了两个具有相同名称的方法, 即sum。第一种方法接受整型和整型, 而第二种方法接受整型和整型。传递的参数为a = 20, b =20。由于整数文字和长文字之间没有明确区分, 因此我们无法确定将调用哪种方法。这就是模棱两可的情况。因此, 编译器将引发错误。

核心Java-OOPs概念：方法覆盖面试问题

78)什么是方法重写：

如果子类提供其父类已经提供的方法的特定实现, 则称为”方法重写”。它用于运行时多态和实现接口方法。

方法覆盖规则

• 该方法必须具有与父类相同的名称。
• 该方法必须具有与父类相同的签名。
• 两个类之间必须具有IS-A关系。

更多细节。

79)我们可以覆盖静态方法吗？

不, 你不能覆盖静态方法, 因为它们是类的一部分, 而不是对象的一部分。

80)为什么不能覆盖静态方法？

这是因为静态方法是类的一部分, 并且与类绑定, 而实例方法与对象绑定, 并且静态在类区域中获取内存, 而实例在堆中获取内存。

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

是。

82)方法重载和覆盖之间的区别。

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

不可以, 我们不能覆盖私有方法, 因为私有方法的范围仅限于该类, 并且不能在类之外访问它们。

84)我们可以更改子类中重写方法的范围吗？

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

• 私有可以更改为受保护, 公开或默认。
• 可以将受保护者更改为公共或默认。
• 默认值可以更改为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

解释

method()在Base类中重载, 而在Derived类中派生, 并以double类型作为参数。在方法调用中, 将传递整数。

87)你可以在Java中使用虚函数吗？

是的, 默认情况下, Java中的所有功能都是虚拟的。

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

现在, 从java5开始, 如果子类重写方法的返回类型是子类类型, 则可以通过更改返回类型来重写任何方法。它被称为协变返回类型。协变量返回类型指定返回类型可以在与子类相同的方向上变化。

class A{
A get(){return this;}
}

class B1 extends A{
B1 get(){return this;}
void message(){System.out.println("welcome to covariant return type");}

public static void main(String args[]){
new B1().get().message();
}
}

立即测试

Output: welcome to covariant return type

更多细节。

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 Test 
{
    public static void main (String args[])
    {
        Base b = new Derived();
        b.baseMethod();
    }
}

输出

Derived method called ...

解释

基类的方法, 即baseMethod()在派生类中被覆盖。在Test类中, 引用变量b(类型为Base类)引用Derived类的实例。在这里, 在基类和派生类之间实现了运行时多态。在编译时, 在Base类中检查方法baseMethod的存在, 如果存在, 则将编译该程序, 否则将显示编译器错误。在这种情况下, BaseMethod存在于Base类中。因此, 它已成功编译。但是, 在运行时, 它检查baseMethod是否已被Derived类重写, 如果是, 则调用Derived类方法, 否则调用Base类方法。在这种情况下, Derived类将覆盖baseMethod；因此, 将调用派生类方法。

Java核心-OOPs概念：最终关键字面试问题

90)最终变量是什么？

在Java中, 最终变量用于限制用户对其进行更新。如果初始化最终变量, 则无法更改其值。换句话说, 我们可以说最终变量一旦分配给一个值, 之后就再也不能更改了。未分配任何值的最终变量只能通过类构造函数进行分配。

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

立即测试

Output:Compile Time Error

更多细节。

91)最终的方法是什么？

如果将任何方法更改为最终方法, 则无法覆盖它。更多细节。

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

立即测试

Output:Compile Time Error

92)最后一堂课是什么？

如果我们将任何类定为最终类, 则不能将其继承到任何子类中。

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

立即测试

Output:Compile Time Error

更多细节。

93)最终的空白变量是什么？

声明时未初始化的最终变量称为最终空白变量。我们不能直接初始化最终的空白变量。相反, 我们必须使用类构造函数对其进行初始化。在用户拥有某些不能被其他人更改的数据(例如PAN编号)的情况下, 此功能很有用。考虑以下示例：

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

更多细节。

94)我们可以初始化最终的空白变量吗？

是的, 如果它不是静态的, 我们可以在构造函数中对其进行初始化。如果它是静态的空白最终变量, 则只能在静态块中对其进行初始化。更多细节。

95)你可以将main方法声明为final吗？

是的, 我们可以将main方法声明为public static final void main(String [] args){}。

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

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

输出

20

解释

由于我是空白的最终变量。只能初始化一次。我们已经将其初始化为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();
    }
}

输出

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

解释

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

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

构造函数永远都不能声明为final, 因为它永远不会被继承。构造函数不是普通方法。因此, 将构造函数声明为final是没有意义的。但是, 如果尝试这样做, 则编译器将引发错误。

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

不可以, 我们不能将接口声明为final, 因为该接口必须由某些类实现以提供其定义。因此, 没有必要将接口定为最终接口。但是, 如果尝试这样做, 编译器将显示错误。

100)最终方法和抽象方法之间有什么区别？

final方法和abstract方法之间的主要区别在于abstract方法不能是final方法, 因为我们需要在子类中重写它们以提供其定义。

1 2 3 4 5

平台无关

主要用于

设计目标

后藤

多重继承

操作员超载

指针

编译器和口译员

按值调用和按引用调用

结构与联合

线程支持

文档注释

虚拟关键字

无符号右移>>>

继承树

硬件

面向对象

构造函数用于初始化对象的状态。

构造函数不得具有返回类型。

构造函数被隐式调用。

如果你的类中没有任何构造函数, 则Java编译器会提供默认构造函数。

构造函数名称必须与类名称相同。

1)声明为static的方法称为static方法。

2)我们不需要创建对象来调用静态方法。

3)无法在静态上下文(静态方法, 静态块和静态嵌套类)中直接访问非静态(实例)成员。

4)例如：public static int cube(int n){return n * n * n;}

1)方法重载提高了程序的可读性。

2)方法重载发生在类中。

3)在这种情况下, 参数必须不同。

Java基础面试问题

Java多线程面试问题

Java Collection面试题

Servlet面试问题

春季面试问题

PL / SQL面试问题

Oracle面试问题

SQL Server面试问题