300 个 Java 面试题 | 第 2 组

2025 年 4 月 14 日 | 阅读 65 分钟

核心 Java - OOPs：多态性面试题

101) 编译时多态性与运行时多态性有什么区别？

编译时多态性与运行时多态性之间存在以下区别。

序号	编译时多态	运行时多态
1	在编译时多态性中，方法调用在编译时解析。	在运行时多态性中，被覆盖方法调用在运行时解析。
2	它也称为静态绑定、早期绑定或重载。	它也称为动态绑定、后期绑定、覆盖或动态方法分派。
3	重载是实现编译时多态性的一种方式，通过它我们可以定义多个具有不同签名的方法或构造函数。	覆盖是实现运行时多态性的一种方式，通过它我们可以在派生类中重新定义某些特定的方法或变量。通过使用覆盖，我们可以为派生类中的基类属性提供一些特定的实现。
4	它提供快速执行，因为对象的类型在编译时确定。	与编译时相比，它提供较慢的执行速度，因为对象的类型在运行时确定。
5	编译时多态性提供的灵活性较差，因为所有内容都在编译时解析。	运行时多态性提供更高的灵活性，因为所有内容都在运行时解析。

阅读更多：Java 中的编译时多态性

102) 什么是运行时多态性？

运行时多态性，也称为动态方法分派，是一种在运行时而不是编译时解析被覆盖方法调用的过程。在此过程中，通过超类的引用变量调用被覆盖方法。它通过面向对象编程中的方法覆盖实现，其中子类为已在其超类中定义的方法提供特定实现。

 class Bike{
   void run(){System.out.println("running");}
 }
 class Splendor extends Bike{
   void run(){System.out.println("running safely with 60km");}
   public static void main(String args[]){
     Bike b = new Splendor();//upcasting
     b.run();
   }
 }

输出

running safely with 60km.

在此过程中，通过超类的引用变量调用被覆盖方法。要调用的方法的确定基于引用变量所引用的对象。

阅读更多：Java 中的多态性

103) 我们可以通过数据成员实现运行时多态性吗？

不，运行时多态性主要与方法/函数相关，而不是数据成员，因为方法覆盖用于实现运行时多态性，而数据成员不能被覆盖。我们可以覆盖成员函数，但不能覆盖数据成员。数据成员（字段或属性）不会以相同的方式表现出多态行为。考虑下面给出的示例。

 class Bike{
  int speedlimit=90;
 }
 class Honda3 extends Bike{
  int speedlimit=150;
  public static void main(String args[]){
   Bike obj=new Honda3();
   System.out.println(obj.speedlimit);//90
    }
}

输出

104) 静态绑定和动态绑定有什么区别？

在静态绑定中，对象的类型在编译时确定，而在动态绑定中，对象的类型在运行时确定。

静态绑定

class Dog{
 private void eat(){System.out.println("dog is eating...");}

 public static void main(String args[]){
  Dog d1=new Dog();
  d1.eat();
 }
}

动态绑定

class Animal{
 void eat(){System.out.println("animal is eating...");}
}

class Dog extends Animal{
 void eat(){System.out.println("dog is eating...");}

 public static void main(String args[]){
  Animal a=new Dog();
  a.eat();
 }
}

阅读更多：Java 中的静态绑定和动态绑定

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

class BaseTest 
{
  void print()
  {
    System.out.println("BaseTest:print() called");
  }
}
public class Test extends BaseTest 
{
  void print() 
  {
    System.out.println("Test:print() called");
  }
  public static void main (String args[])
  {
    BaseTest b = new Test();
    b.print();
  }
}

输出

  Test:print() called

说明

这是动态方法分派的一个示例。引用变量 b 的类型在运行时确定。在编译时，它会检查该方法是否存在于基类中。在这种情况下，它在子类中被覆盖，因此在运行时调用派生类方法。

阅读更多：Java 程序

106) 什么是 Java instanceof 运算符？

Java 中的 instanceof 运算符也称为类型比较运算符，因为它将实例与类型进行比较。它用于测试对象是否是特定类、接口或类型的实例。它返回 true 或 false。如果我们将 instanceof 运算符应用于具有 null 值的任何变量，它将返回 false。考虑以下示例。

class Simple1{
 public static void main(String args[]){
 Simple1 s=new Simple1();
 System.out.println(s instanceof Simple1);//true
 }
}

输出

true

阅读更多：Java instanceof 运算符

子类类型的对象也是父类的一种类型。例如，如果 Dog 继承自 Animal，那么 Dog 的对象可以由 Dog 或 Animal 类引用。

核心 Java - OOPs 概念：抽象面试题

107) 什么是抽象？

抽象是隐藏实现细节并仅向用户展示功能的过程。它只向用户显示基本信息并隐藏内部信息，它通过基于真实世界实体对类进行建模并关注相关属性和行为来简化系统。例如，发送短信时，您键入文本并发送消息。我们不知道消息传递的内部处理过程。抽象使我们能够专注于对象做什么，而不是它如何做。抽象让您专注于对象做什么，而不是它如何做。

在 Java 中，有两种方法可以实现抽象。

抽象类
Interface

阅读更多：Java 中的抽象

108) 抽象和封装有什么区别？

抽象和封装是相关的概念，但具有不同的含义。抽象是关于只展示对象的基本特征，同时隐藏不必要的细节。另一方面，封装是将数据和操作该数据的方法捆绑成一个单元，通常是一个类。抽象更多地是关于设计和建模，而封装是关于实现和数据隐藏。

阅读更多：抽象与封装

109) 什么是抽象类？

声明为抽象的类称为抽象类。它需要被扩展并实现其方法。它不能被实例化。抽象类可以同时拥有抽象方法和具体方法，并且可以被其他类扩展。它还可以拥有 final 方法，这将强制子类不改变方法体。

 abstract class Bike{
   abstract void run();
 }
 class Honda4 extends Bike{
 void run(){System.out.println("running safely");}
 public static void main(String args[]){
  Bike obj = new Honda4();
  obj.run();
 }
 }

输出

running safely

阅读更多：Java 中的抽象类

110) 没有抽象类可以有抽象方法吗？

不，抽象方法必须属于抽象类。抽象方法在抽象类中定义，并且必须由扩展抽象类的子类实现。

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

111) 以下程序是否编写正确？如果是，程序的输出是什么？

abstract class Calculate
{
    abstract int multiply(int a, int b);
}
 
public class Main
{
    public static void main(String[] args)
    {
        int result = new Calculate()
        {    
            @Override
            int multiply(int a, int b)
            {
                return a*b;
            }
        }.multiply(12,32);
        System.out.println("result = "+result);
    }
}

是的，程序编写正确。Main 类提供了抽象类 Calculation 中声明的抽象方法 multiply 的定义。程序的输出将是

输出

是的，程序编写正确。Main 类提供了抽象类 Calculation 中声明的抽象方法 multiply 的定义。程序的输出将是

112) 我们可以将 abstract 和 final 同时用于方法吗？

不，我们不能将 abstract 和 final 同时用于一个方法。抽象方法旨在被子类覆盖，而 final 方法不能被覆盖。

113) 是否可以实例化抽象类？

不，我们不能在 Java 中直接实例化抽象类。抽象类旨在由具体子类扩展，我们只能创建具体类的对象。

114) 什么是接口？

接口是类的蓝图，具有静态常量和抽象方法。它可以用于实现完全抽象和多重继承。Java 中的接口是抽象方法的集合。它是一种实现抽象的机制。Java 接口中只能有抽象方法，不能有方法体。它用于在 Java 中实现抽象和多重继承。换句话说，您可以说接口可以有抽象方法和变量。Java 接口也表示 IS-A 关系。它不能像抽象类一样被实例化。但是，我们需要实现它来定义其方法。从 Java 8 开始，我们可以在接口中拥有 default、static 和 private 方法。

阅读更多：Java 中的接口

115) 我们可以将接口方法声明为 static 吗？

不，在 Java 8 之前，接口方法不能声明为 static。但是，从 Java 8 开始，我们可以在接口中声明 static 方法。

116) 接口可以是 final 吗？

不，因为接口需要由其他类实现，如果它是 final 的，则不能由任何类实现。

117) 什么是标记接口？

Java 中的标记接口是不声明任何方法的接口。其目的是标记或标记一个类，表明该类具有某些行为或特征。例如，Serializable、Cloneable 是标记接口。标记接口可以声明如下。

public interface Serializable{  
}  

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

抽象类	Interface
抽象类可以有方法体（非抽象方法）。	接口只有抽象方法。
抽象类可以有实例变量。	接口不能有实例变量。
抽象类可以有构造函数。	接口不能有构造函数。
抽象类可以有静态方法。	接口不能有静态方法。
您可以扩展一个抽象类。	您可以实现多个接口。
抽象类可以提供接口的实现。	接口不能提供抽象类的实现。
abstract 关键字用于声明抽象类。	interface 关键字用于声明接口。
抽象类可以扩展另一个 Java 类并实现多个 Java 接口。	接口只能扩展另一个 Java 接口。
抽象类可以使用关键字 extends 进行扩展。	接口类可以使用关键字 implements 进行实现。
Java 抽象类可以有 private、protected 等类成员。	Java 接口的成员默认为 public。
示例 public abstract class Shape{ public abstract void draw(); }	示例 public interface Drawable{ void draw(); }

阅读更多：Java 中抽象类和接口的区别

119) 我们可以为接口中的成员定义 private 和 protected 修饰符吗？

不，在 Java 接口中，所有成员（字段和方法）都隐式为 public 和 abstract。接口成员是 public 的，因为接口定义了实现类必须遵守的契约，并且是 abstract 的，因为它们旨在由实现接口的类实现。

120) 何时可以将对象引用强制转换为接口引用？

当对象实现引用的接口时，对象引用可以强制转换为接口引用。

121) 如何在 Java 中创建一个只读类？

通过将所有字段设为 private，可以将类设为只读。只读类将只具有 getter 方法，这些方法将类的私有属性返回给 main 方法。我们无法修改此属性，因为类中没有 setter 方法。考虑以下示例。

  //A Java class which has only getter methods.  
public class Student{  
//private data member  
private String college="AKG";  
//getter method for college  
public String getCollege(){  
return college;  
}  
}  

122) 如何在 Java 中创建一个只写类？

通过将所有字段设为 private，可以将类设为只写。只写类将只具有 setter 方法，这些方法将从 main() 方法传递的值设置为私有字段。我们无法读取类的属性，因为此类别中没有 getter 方法。考虑以下示例。

  //A Java class which has only setter methods.  
public class Student{  
//private data member  
private String college;  
//getter method for college  
public void setCollege(String college){  
this.college=college;  
}  
}  

123) Java 中封装的优点是什么？

Java 中封装的优点如下

通过仅提供 setter 或 getter 方法，我们可以使类只读或只写。换句话说，我们可以跳过 getter 或 setter 方法。

它提供了对数据的控制。假设我们只想设置 id 的值，该值必须大于 100，我们可以将逻辑写入 setter 方法。我们可以在 setter 方法中编写不存储负数的逻辑。

它是在 Java 中实现数据隐藏的一种方式，因为其他类将无法通过私有数据成员访问数据。

封装类易于测试。因此，它更适合单元测试。

标准 IDE 提供生成 getter 和 setter 的功能。因此，在 Java 中创建封装类既简单又快速。

阅读更多：Java 中的封装

核心 Java - OOPs 概念：包面试题

124) 什么是包？

包是一组类似类型的类、接口和子包。它提供访问保护并消除命名冲突。Java 中的包可以分为两种形式：内置包和用户定义包。有许多内置包，例如 Java、lang、awt、javax、swing、net、io、util、sql 等。考虑以下示例在 Java 中创建一个包。

Simple.java

package mypack;  
public class Simple{  
 public static void main(String args[]){  
    System.out.println("Welcome to package");  
   }  
}  

阅读更多：Java 中的包

125) 在 Java 中定义包有什么好处？

通过定义包，我们可以避免不同包中定义的相同类名之间的名称冲突。包还使开发人员能够更有效地组织相似的类。例如，可以清楚地理解 java.io 包中存在的类用于执行与 io 相关的操作。

126) 如何在 Java 中创建包？

如果您使用的是 Eclipse、NetBeans、MyEclipse 等编程 IDE，请单击**文件->新建->项目**，Eclipse 将要求您输入包的名称。它将创建包含各种目录（如 src 等）的项目包。

如果我们在 Java 编程中使用记事本等编辑器，请使用以下步骤创建包。

要在 Java 中创建包，您需要在 Java 源文件开头使用 package 关键字，并根据包名将类组织到目录中。定义一个 **package_name 包。创建名为 class_name 的类，并将此文件保存为 your_class_name.java**。

现在通过在终端上运行以下命令编译文件。

上面的命令在当前工作目录中创建名为 **package_name** 的包。

现在，通过使用绝对类文件名运行类文件，如下所示。

阅读更多：如何在 Java 中创建包

127) 如何在 Java 中访问另一个类中的某个类？

有两种方法可以访问另一个类中的类。

**通过使用完全限定名：**要访问不同包中的类，我们必须使用该类的完全限定名，或者我们必须导入包含该类的包。

// Using fully qualified name
com.example.otherpackage.OtherClass obj = new com.example.otherpackage.OtherClass();
// Using import statement
import com.example.otherpackage.OtherClass;
// ...
OtherClass obj = new OtherClass();

**通过使用相对路径**，我们可以使用与包含我们类的包相关的类的路径。它可以是相同或子包。

128) 我需要随时导入 java.lang 包吗？为什么？

不。我们不需要显式导入 java.lang 包，因为它会自动导入到每个 Java 程序中。它默认由 JVM 内部加载。

阅读更多：Java 中默认导入哪个包

129) 我可以导入同一个包/类两次吗？JVM 会在运行时加载包两次吗？

是的，可以多次导入同一个包或同一个类。编译器和 JVM 都不会对此提出异议。但是，JVM 只会在运行时加载包或类一次。

130) 什么是静态导入？

静态导入是 Java 5 中引入的一项功能，它允许在 Java 程序中使用类的成员（字段和方法），而无需使用类名限定它们。

import static java.lang.Math.*;
public class MyMathClass {
    public static void main(String[] args) {
        double result = sqrt(25); // No need to use Math.sqrt here
        // ...
    }
}

阅读更多：Java 静态导入

Java：异常处理面试题

此处列出了带答案的异常处理面试题。如果您知道任何异常处理面试题，请在评论部分发布。

131) Java 程序中会发生多少种异常？

异常主要有两种类型：受检异常和非受检异常。这里，错误被视为非受检异常。根据 Oracle 的说法，有三种类型的异常

**受检异常：**受检异常在编译时检查，程序员必须使用 try-catch 处理它们，或在方法的 throws 子句中声明它们。例如，SQLException、ClassNotFoundException 等。
**非受检异常：**非受检异常是在运行时处理的，因为它们无法在编译时检查。例如，ArithmaticException、NullPointerException、ArrayIndexOutOfBoundsException 等。

阅读更多：Java 中异常的类型及示例

132) 什么是异常处理？

异常处理是一种用于处理运行时错误（异常）以防止程序异常终止的机制。它主要用于处理受检异常。异常处理保持程序的正常流程。异常主要有两种类型：受检异常和非受检异常。这里，错误被视为非受检异常。

阅读更多：Java 中的异常处理

133) 解释 Java 异常类的层次结构？

Java 异常类的层次结构包括顶级类 java.lang.Throwable 类是 Java 异常层次结构的根类，它被两个子类继承：Exception 和 Error。Java 异常类的层次结构如下所示

134) 受检异常和非受检异常有什么区别？

1) 受检异常

受检异常在编译时检查，程序员必须使用 try-catch 处理它们，或在方法的 throws 子句中声明它们。扩展 Throwable 类（RuntimeException 和 Error 除外）的类称为受检异常，例如 IOException、SQLException 等。

2) 非受检异常

非受检异常在编译时不会检查，包括运行时异常和错误。扩展 RuntimeException 的类称为非受检异常，例如 ArithmeticException、NullPointerException 等。

更多详情。

135) Error 和 Exception 的基类是什么？

Throwable 类是 Error 和 Exception 的基类。

136) 每个 try 块后面都必须跟着一个 catch 块吗？

不，try 块后面不一定必须跟着 catch 块。我们可以将 try 块与 catch、finally 或两者都使用。因此，可能抛出的任何异常都应在方法的 throws 子句中声明。考虑以下示例。

public class Main{
     public static void main(String []args){
        try{
            int a = 1; 
            System.out.println(a/0);
        }
        finally
        {
            System.out.println("rest of the code...");
        }
     }
}
	

输出

Exception in thread main java.lang.ArithmeticException:/ by zero
rest of the code...

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

public class ExceptionHandlingExample {
public static void main(String args[])
{
	try
	{
		int a = 1/0;
		System.out.println("a = "+a);
	}
	catch(Exception e){System.out.println(e);}
	catch(ArithmeticException ex){System.out.println(ex);}	
}
}

输出

ExceptionHandlingExample.java:10: error: exception ArithmeticException has already been caught
	catch(ArithmeticException ex){System.out.println(ex);}	
	^
1 error

说明

ArithmaticException 是 Exception 的子类。因此，它不能在 Exception 之后使用。由于 Exception 是所有异常的基类，因此它必须最后使用才能处理异常。在此之后不能使用任何类。

138) 什么是 finally 块？

在 Java 等编程语言中，finally 块是异常处理的一部分。它包含无论是否抛出异常都将执行的代码。finally 块通常用于确保某些清理或资源释放操作发生，无论是否发生异常。

finally 块跟在 try 或 catch 块之后。如果我们不处理异常，在程序终止之前，JVM 会运行 finally 块（如果有）。finally 块主要用于放置清理代码，例如关闭文件或关闭连接。在这里，我们必须知道对于每个 try 块，可以有零个或多个 catch 块，但只有一个 finally 块。如果程序退出（通过调用 System.exit() 或导致导致进程中止的致命错误），finally 块将不会执行。

阅读更多：Java finally 块

139) finally 块可以在没有 catch 的情况下使用吗？

是的，finally 块可以在没有 catch 块的情况下使用。在异常处理中，我们可以有一个 try 块，后面跟着 catch 块、finally 块或两者。根据 finally 块的定义，它必须跟在 try 或 catch 块之后，因此我们可以使用 try 块而不是 catch。更多详情。

140) 有没有 finally 块不执行的情况？

如果程序退出（通过调用 System.exit() 或导致导致进程中止的致命错误），finally 块将不会执行。一种这样的情况是程序突然终止，例如，通过调用 System.exit() 或发生硬件故障或 JVM 中的错误，从而阻止程序正常终止。更多详情。

141) throw 和 throws 有什么区别？

throw 关键字	throws 关键字
throw 关键字用于显式抛出异常。	throws 关键字用于声明异常。
受检异常不能仅通过 throw 传播。	受检异常可以通过 throws 传播
throw 关键字后跟一个实例。	throws 关键字后跟一个类。
throw 关键字在方法内部使用。	throws 关键字与方法签名一起使用。
您不能抛出多个异常。	您可以声明多个异常，例如 public void method()throws IOException, SQLException。

阅读更多：Java 中 throw 和 throws 的区别

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

  public class Main{
     public static void main(String []args){
        try
        {
            throw 90; 
        }
        catch(int e){
            System.out.println("Caught the exception "+e);
        }
            
    }
}

输出

Main.java:6: error: incompatible types: int cannot be converted to Throwable
            throw 90; 
            ^
Main.java:8: error: unexpected type
        catch(int e){
              ^
  required: class
  found:    int
2 errors

说明

在 Java 中，只有可抛出的对象才能被抛出。如果我们尝试抛出整数对象，编译器将显示错误，因为我们无法从代码块中抛出基本数据类型。

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

class Calculation extends Exception
{
    public Calculation() 
    {
        System.out.println("Calculation class is instantiated");
    }
    public void add(int a, int b)
    {
        System.out.println("The sum is "+(a+b));
    }
}
public class Main{
     public static void main(String []args){
        try
        {
            throw new Calculation(); 
        }
        catch(Calculation c){
            c.add(10,20);
        }
    }
} 

输出

Calculation class is instantiated
The sum is 30

说明

Calculation 的对象从 try 块抛出，并在 catch 块中捕获。通过使用此类的对象，使用整数值 10 和 20 调用 Calculation 类的 add()。因此，打印它们的和 30。Main 类的对象只能在对象类型可抛出的情况下抛出。为此，我们需要扩展 throwable 类。

144) 异常可以重新抛出吗？

是的，异常可以重新抛出。在 Java 中，我们可以在一个 catch 块中捕获异常，然后再次抛出相同的异常（或不同的异常）。这对于记录或在程序的更高层次处理异常很有用。

145) 如果父类方法不抛出异常，子类覆盖方法可以声明异常吗？

是的，在 Java 中，如果子类覆盖其父类中的方法，即使父类中的被覆盖方法不抛出异常，子类也允许在其方法签名中声明异常。

更多详情。

146) 什么是异常传播？

异常传播是指程序中抛出异常，然后沿着调用栈传播，直到被适当的 catch 块捕获和处理，或者直到它到达程序的顶层。

异常首先从栈顶抛出，如果未捕获，它会下落到上一个方法，如果那里未捕获，异常会再次下落到上一个方法，依此类推，直到它们被捕获或直到它们到达调用栈的最底部。这个过程称为异常传播。默认情况下，受检异常不会传播。

class TestExceptionPropagation1{
  void m(){
    int data=50/0;
  }
  void n(){
    m();
  }
  void p(){
   try{
    n();
   }catch(Exception e){System.out.println("exception handled");}
  }
  public static void main(String args[]){
   TestExceptionPropagation1 obj=new TestExceptionPropagation1();
   obj.p();
   System.out.println("normal flow...");
  }
}

输出

exception handled
normal flow...

更多详情。

阅读更多：Java 异常传播

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

public class Main 
{
    void a()
    {
        try{
        System.out.println("a(): Main called");
        b();
        }catch(Exception e)
        {
            System.out.println("Exception is caught");
        }
    }
    void b() throws Exception
    {
     try{
         System.out.println("b(): Main called");
         c();
     }catch(Exception e){
         throw new Exception();
     }
     finally 
     {
         System.out.println("finally block is called");
     }
    }
    void c() throws Exception 
    {
        throw new Exception();
    }

    public static void main (String args[])
    {
        Main m = new Main();
        m.a();
    }
}

输出

a(): Main called
b(): Main called
finally block is called
Exception is caught

说明

在 main() 方法中，调用 Main 类的 a()，它打印一条消息并调用 b()。方法 b() 打印一些消息，然后调用方法 c()。方法 c() 抛出异常，该异常由方法 b() 的 catch 块处理。但是，它通过使用 **throw Exception()** 传播此异常，以便由方法 a() 处理。我们知道，finally 块总是执行的，因此方法 b() 中的 finally 块首先执行并打印一条消息。最后，异常由方法 a() 的 catch 块处理。

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

public class Calculation 
{
    int a; 
    public Calculation(int a)
    {
        this.a = a;
    }
    public int add()
    {
        a = a+10; 
        try 
        {
            a = a+10; 
            try 
            {
                a = a*10; 
                throw new Exception(); 
            }catch(Exception e){
                a = a - 10;
            }
        }catch(Exception e)
        {
            a = a - 10; 
        }
        return a;
    }
    
    public static void main (String args[])
    {
        Calculation c = new Calculation(10);
        int result = c.add();
        System.out.println("result = "+result);
    }
}

输出

result = 290

说明

Calculation 类的实例变量 a 在实例化类时通过类构造函数初始化为 10。调用 add 方法，该方法返回整数值结果。在 add() 方法中，a 递增 10 变为 20。然后，在第一个 try 块中，10 再次递增 10 变为 30。在第二个 try 块中，a 乘以 10 变为 300。第二个 try 块抛出异常，该异常由与此 try 块关联的 catch 块捕获。catch 块再次通过将 a 递减 10 更改 a 的值，使其变为 290。因此，add() 方法返回 290，该值赋给 result。然而，与最外层 try 块关联的 catch 块永远不会执行，因为没有异常可以由这个 catch 块处理。

Java：字符串处理面试题

此处列出了带简短而有针对性的答案的字符串处理面试题。如果您知道任何字符串处理面试题，请在评论部分发布。

阅读更多：Java 字符串

149) 什么是字符串池？

字符串池是 Java 中存储字符串字面量的特殊内存区域。使用字符串池的主要优点是，每当我们创建字符串字面量时，JVM 会首先检查“字符串常量池”。如果字符串已存在于池中，则返回池中实例的引用。如果字符串不存在于池中，则创建新的字符串实例并放入池中。这种机制通过减少重复字符串对象的数量来帮助优化内存。因此，它通过避免重复来节省内存。

阅读更多：Java 中的字符串池

150) 关于字符串的不可变性是什么意思？

不可变性的简单含义是不可修改或不可更改。在 Java 中，String 是不可变的，即一旦创建了 String 对象，其值就不能更改。考虑以下示例以更好地理解。

class Testimmutablestring{
 public static void main(String args[]){
   String s="Sachin";
   s.concat(" Tendulkar");//concat() method appends the string at the end
   System.out.println(s);//will print Sachin because strings are immutable objects
 }
}

输出

Sachin

阅读更多：为什么 String 在 Java 中是不可变的

151) 为什么 Java 中的对象是不可变的？

Java 中的对象不可变有几个原因，Java 使用字符串字面量的概念。假设有五个引用变量，都引用一个对象“sachin”。如果一个引用变量更改了对象的值，它将影响所有引用变量。线程安全，不可变对象本质上是线程安全的。这就是为什么 Java 中的字符串对象是不可变的。

更多详情。

152) 创建字符串对象有哪些方法？

在 Java 中创建字符串对象有几种方法

1) 使用字符串字面量

Java 字符串字面量是通过双引号创建的。例如

每次创建字符串字面量时，JVM 都会首先检查“字符串常量池”。如果字符串已存在于池中，则返回池中实例的引用。如果字符串不存在于池中，则创建新的字符串实例并放入池中。字符串对象存储在称为**字符串常量池**的特殊内存区域中。例如，

String s1="Welcome";  
String s2="Welcome";    //it does not create a new instance  

2) 使用 new 关键字

在这种情况下，JVM 将在普通（非池）堆内存中创建一个新的字符串对象，并将字面量“Welcome”放入常量字符串池中。变量 s 将引用堆（非池）中的对象。

153) 以下代码将创建多少个对象？

String s1="Welcome";
String s2="Welcome";
String s3="Welcome";

使用上述代码将只创建一个对象，因为 Java 中的字符串是不可变的。

更多详情。

154) 为什么 Java 使用字符串字面量的概念？

Java 使用字符串字面量的概念是为了效率和内存优化。为了使 Java 更节省内存（因为如果字符串常量池中已存在，则不会创建新对象）。它减少了内存消耗并提高了性能。

阅读更多：Java 中的字面量

155) 以下代码将创建多少个对象？

两个对象，一个在字符串常量池中，另一个在非池（堆）中。

阅读更多：Java 中的字符串字面量与字符串对象

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

  public class Test 
{
    public static void main (String args[])
    {
        String a = new String("Sharma is a good player");
        String b = "Sharma is a good player";
        if(a == b)
        {
            System.out.println("a == b");
        }
        if(a.equals(b))
        {
            System.out.println("a equals b");
        }
    }
}

输出

  a equals b

说明

运算符 **==** 还检查两个字符串对象的引用是否相等。尽管两个字符串包含相同的内容，但它们的引用不相等，因为它们是通过不同方式（构造函数和字符串字面量）创建的，因此 **a == b** 不相等。另一方面，equals() 方法总是检查内容。由于它们的内容相等，因此打印 **a equals b**。

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

public class Test 
{
    public static void main (String args[])
    {
        String s1 = "Sharma is a good player";
        String s2 = new String("Sharma is a good player");
        s2 = s2.intern();
        System.out.println(s1 ==s2);
    }
}

输出

true

说明

intern 方法从字符串池返回 String 对象引用。在这种情况下，s1 是使用字符串字面量创建的，而 s2 是使用字符串池创建的。但是，s2 更改为 s1 的引用，并且运算符 **==** 返回 true。

158) String 和 StringBuffer 有什么区别？

String 和 StringBuffer 之间的区别如下表所示。

编号。	String	StringBuffer
1)	String 类是不可变的。	StringBuffer 类是可变的。
2)	当我们连接太多字符串时，String 很慢并且消耗更多内存，因为每次它都会创建一个新实例。	StringBuffer 很快并且在连接字符串时消耗更少内存。
3)	String 类重写了 Object 类的 equals() 方法。因此我们可以通过 equals() 方法比较两个字符串的内容。	StringBuffer 类不重写 Object 类的 equals() 方法。

阅读更多：Java 中 String 和 StringBuffer 的区别

159) StringBuffer 和 StringBuilder 有什么区别？

StringBuffer 和 StringBuilder 之间的区别如下。

编号。	StringBuffer	StringBuilder
1)	StringBuffer 是同步的，即线程安全的。这意味着两个线程不能同时调用 StringBuffer 的方法。	StringBuilder 是非同步的，即不是线程安全的。这意味着两个线程可以同时调用 StringBuilder 的方法。
2)	StringBuffer 的效率低于StringBuilder。	StringBuilder 的效率高于StringBuffer。

160) 如何在 Java 中创建一个不可变类？

我们可以通过定义一个所有成员都是 final 的 final 类来创建一个不可变类。考虑以下示例。

将类设为 final，使其不能被子类化。
将所有字段声明为 private 和 final。
不要为字段提供 setter 方法。
确保类中的任何可变对象都被防御性复制以防止外部修改。
如果类具有可变字段，请确保在 getter 方法中返回防御性副本。

public final class Employee{
final String pancardNumber;

public Employee(String pancardNumber){
this.pancardNumber=pancardNumber;
}

public String getPancardNumber(){
return pancardNumber;
}

}

阅读更多：如何在 Java 中创建不可变类

161) Java 中 toString() 方法的目的是什么？

toString() 方法用于获取对象的字符串表示。它在 Object 类中定义，可以被自定义类重写，以根据实现提供对象状态的有意义的表示。通过重写 Object 类的 toString() 方法，我们可以返回对象的值，这样我们就不需要编写太多代码。考虑以下示例。

class Student {  
 int rollno;  
 String name;  
 String city;  
Student(int rollno, String name, String city){  
 this.rollno=rollno;  
 this.name=name;  
 this.city=city;  
 }  
public String toString(){    //overriding the toString() method  
  return rollno+" "+name+" "+city;  
 }  
 public static void main(String args[]){  
   Student s1=new Student(101,"Raj","Lucknow");  
   Student s2=new Student(102,"Vijay","Ghaziabad");  
   System.out.println(s1);//compiler writes here s1.toString()  
   System.out.println(s2);//compiler writes here s2.toString()  
 }  
}  

输出

101 Raj Lucknow
102 Vijay Ghaziabad

阅读更多：Java toString() 方法及示例

162) 为什么 toCharArray() 方法比 String 更受青睐用于存储密码？

出于安全原因，使用 toCharArray() 方法而不是 String 来存储密码更受青睐。String 会留在字符串池中，直到垃圾回收。如果我们将密码存储在字符串中，它会在内存中停留更长时间，任何拥有内存转储的人都可以以明文形式提取密码。如果我们将密码存储为字符串，它会一直留在内存中，直到垃圾收集器将其清除。另一方面，使用 toCharArray() 允许我们在使用完密码后将其设置为空白。它通过使我们能够控制内存来避免字符串带来的安全威胁。

阅读更多：Java String.toCharArray() 方法

163) 编写一个 Java 程序来计算字符串中存在的单词数？

程序

  public class Test 
{
    public static void main (String args[])
    {
        String s = "Sharma is a good player and he is so punctual";
        String words[] = s.split(" ");
        System.out.println("The Number of words present in the string are : "+words.length);
    }
}

输出

The Number of words present in the string are : 10

164) 说出 java.util.regex 包中存在的一些类。

java.util.regex 包中存在以下类和接口。

**Pattern 类：**它是一个抽象类，表示编译后的正则表达式。它不提供任何公共构造函数。
**Matcher 类：**它是一个抽象类，对字符序列根据给定字符串执行匹配操作。它也不提供任何公共构造函数。
**PatternSyntaxException 类：**它是一个非受检异常。表示正则表达式模式中的语法错误。

阅读更多：Java 正则表达式 (Regex)

165) 元字符与普通字符有什么不同？

正则表达式中的元字符具有特殊含义，用于构建模式。元字符是 ^、$、.、*、+ 等。正则表达式引擎不将它们视为普通字符。为了使正则表达式引擎将元字符视为普通字符，我们需要用反斜杠转义元字符。

166) 编写一个正则表达式来验证密码。密码必须以字母开头，后跟字母数字字符。长度必须为 8 到 20 个字符。

上述条件的正则表达式将是

其中，

**^** 表示正则表达式的开始。
**[a-zA-Z]** 表示第一个字符必须是字母。
**[a-zA-Z0-9]** 表示字母数字字符。
**{8,19}** 表示密码长度必须在 8 到 20 之间。

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

import java.util.regex.*;
class RegexExample2{
public static void main(String args[]){
System.out.println(Pattern.matches(".s", "as")); //line 4
System.out.println(Pattern.matches(".s", "mk")); //line 5 
System.out.println(Pattern.matches(".s", "mst")); //line 6
System.out.println(Pattern.matches(".s", "amms")); //line 7
System.out.println(Pattern.matches("..s", "mas")); //line 8
}}

输出

true
false 
false
false 
true

说明

第 4 行打印 true，因为字符串的第二个字符是 s；第 5 行打印 false，因为第二个字符不是 s；第 6 行打印 false，因为字符串中有超过 3 个字符；第 7 行打印 false，因为字符串中有超过 2 个字符，并且它也包含超过 2 个字符；第 8 行打印 true，因为字符串的第三个字符是 s。

核心 Java：嵌套类和接口面试题

168) Java 内部类有哪些优点？

Java 内部类具有以下优点

将逻辑封装在一个类中。
改进代码的组织和可读性。
增强代码模块化。
访问外部类的私有成员。
**代码优化：**它需要编写更少的代码。
嵌套类表示一种特殊类型的关系，即它可以访问外部类的所有成员（数据成员和方法），包括私有成员。
嵌套类用于开发更具可读性和可维护性的代码，因为它只将类和接口在逻辑上分组在一个位置。

阅读更多：Java 中的内部类

169) 什么是嵌套类？

嵌套类可以定义为在另一个类或接口中定义的类。它可以是静态嵌套类或内部类（非静态嵌套类）。我们使用嵌套类在逻辑上将类和接口分组在一个位置，以便更具可读性和可维护性。嵌套类可以访问外部类的所有数据成员，包括私有数据成员和方法。嵌套类的语法定义如下。

class Java_Outer_class{  
 //code  
 class Java_Nested_class{  
  //code  
 }  
}  

嵌套类有两种类型，静态嵌套类和非静态嵌套类。非静态嵌套类也可以称为内部类。

170) 使用内部类有什么缺点？

使用内部类有以下缺点

增加复杂性并降低可读性。
字节码大小更大。
与外部类紧密耦合。
内部类增加了开发人员使用的类总数，因此增加了 JVM 的工作量，因为它必须为这些额外的类执行一些例行操作，从而导致性能下降。
与顶级类相比，IDE 对内部类的支持较少，因此在处理内部类时会困扰开发人员。

171) Java 中使用的内部类（非静态嵌套类）有哪些类型？

Java 中使用以下三种类型的内部类。

类型	描述
成员内部类	在类中但方法外部创建的类。
匿名内部类	为实现接口或扩展类而创建的类。其名称由 java 编译器决定。
局部内部类	在方法中创建的类。

172) 嵌套类和内部类之间有什么区别吗？

是的，内部类是非静态嵌套类。换句话说，我们可以说内部类是嵌套类的一部分。

阅读更多：Java 中嵌套类和内部类的区别

173) 我们可以访问本地内部类中的非 final 局部变量吗？

不，在 Java 中，本地内部类可以访问 final 或effectively final 的局部变量。它不能访问非 final 的局部变量。

更多详情。

174) 编译以下程序的外部类时将创建多少个类文件？

public class Person {
String name, age, address;
class Employee{
  float salary=10000;
}
class BusinessMen{
  final String gstin="£4433drt3$"; 
}
public static void main (String args[])
{
  Person p = new Person();
}
}

编译上述代码后，我们得到三个类文件，名称分别为 Person.class、Person$BusinessMen.class 和 Person$Employee.class。

175) 什么是匿名内部类？

Java 中的匿名内部类是动态定义的无名类，通常用于一次性使用。它们同时声明和实例化。我们不能对它们应用不同的访问修饰符。匿名类不能是静态的，也不能定义任何静态字段、方法或类。换句话说，我们可以说它是一个没有名称的类，只能有一个由其定义创建的对象。考虑以下示例。

abstract class Person{
  abstract void eat();
}
class TestAnonymousInner{
 public static void main(String args[]){
  Person p=new Person(){
  void eat(){System.out.println("nice fruits");}
  };
  p.eat();
 }
}

输出

nice fruits

考虑以下使用接口的匿名类工作示例。

interface Eatable{
 void eat();
}
class TestAnnonymousInner1{
 public static void main(String args[]){
 Eatable e=new Eatable(){
  public void eat(){System.out.println("nice fruits");}
 };
 e.eat();
 }
}

输出

nice fruits

176) 什么是嵌套接口？

在接口或类中声明的接口称为嵌套接口。Java 中的嵌套接口是在另一个接口或类中声明的接口。它默认是静态的。嵌套接口用于分组相关接口，以便易于维护。外部接口或类必须引用嵌套接口。它不能直接访问。如果嵌套接口在接口中声明，则必须是 public 的，但如果它在类中声明，则可以具有任何访问修饰符。嵌套接口的语法如下。

interface interface_name{  
 ...  
 interface nested_interface_name{  
  ...  
 }  
}   

更多详情。

177) 类可以有接口吗？

是的，接口可以在类中定义。它被称为嵌套接口。Java 中的一个类可以实现多个接口。

更多详情。

178) 接口可以有类吗？

是的，我们可以在接口中定义一个类。该类可以是内部类或嵌套类。通常，如果接口的方法使用此类的，并且我们没有在其他任何地方使用它，我们将在接口中声明一个类。接口可以包含成员类型声明。

接口中的成员类型声明隐式为 static 和 public。允许冗余指定这两个修饰符中的任何一个或两者。不可能在 Java 接口中声明非静态类。

interface UserChecker {
   Ticket validateUser(Credentials credentials);
   class Credentials {
      // user and password
   }
   class Ticket {
      // some obscure implementation
   }
}

垃圾回收面试题

179) 什么是垃圾回收？

垃圾回收是 Java 中的自动过程，它识别并删除未使用的对象，释放内存并防止内存泄漏。换句话说，我们可以说它是从内存中删除未使用的对象以释放空间并使此空间可用于 Java 虚拟机（JVM）的过程。由于垃圾回收，Java 将未设置值的变量（即已定义但未初始化的变量）输出为 0。为此，我们在 C 语言中使用 free() 函数，在 C++ 中使用 delete()。在 Java 中，它是自动执行的。因此，Java 提供了更好的内存管理。

阅读更多：Java 中的垃圾回收

180) 什么是 gc()？

gc() 方法不是 Java 中的标准方法。垃圾回收过程是自动的，我们通常不需要显式调用方法来触发垃圾回收。JVM 将垃圾回收作为其内存管理的一部分进行处理。此函数显式使 Java 虚拟机释放未使用的对象占用的空间，以便可以利用或重用该空间。考虑以下示例，以便更好地理解 gc() 方法如何调用垃圾回收器。

public class TestGarbage1{
 public void finalize(){System.out.println("object is garbage collected");}
 public static void main(String args[]){
  TestGarbage1 s1=new TestGarbage1();
  TestGarbage1 s2=new TestGarbage1();
  s1=null;
  s2=null;
  System.gc();
 }
}

输出

       object is garbage collected
       object is garbage collected

181) 垃圾回收是如何控制的？

垃圾回收由 Java 虚拟机 (JVM) 管理。它在内存空间不足且内存不足时执行。我们可以外部调用 System.gc() 方法进行垃圾回收。开发人员可以通过调整堆大小、垃圾回收算法和调优选项来影响垃圾回收行为。但是，它取决于 JVM 是否执行它。

阅读更多：Java 中垃圾回收的工作原理

阅读更多：Java 虚拟机 (JVM)

182) 如何使对象解除引用？

当程序中的任何部分不再引用某个对象时，该对象就会变为未引用。在 Java 中，当对象不再可达时，即没有引用指向它们时，它们会自动进行垃圾回收。这可以通过以下几种方式发生

通过将引用设置为 null
通过将引用分配给另一个引用
通过匿名对象等。

1) 通过将引用设置为 null

Employee e=new Employee();
e=null;

2) 通过将引用分配给另一个引用

Employee e1=new Employee();
Employee e2=new Employee();
e1=e2;//now the first object referred by e1 is available for garbage collection

3) 通过匿名对象

183) finalize() 方法的目的是什么？

finalize() 方法在对象被垃圾回收之前调用。它用于执行清理处理。JVM 的垃圾收集器只收集那些通过 new 关键字创建的对象。但是，重要的是要注意 finalize() 方法很少使用，并且在资源清理方面被认为有些不可靠。因此，如果我们没有通过 new 创建对象，我们可以使用 finalize 方法执行清理处理（销毁剩余对象）。清理处理是释放所有以前使用过且不再需要的资源、网络的过程。重要的是要记住，它不是一个保留关键字，finalize 方法存在于 Object 类中，因此它在每个类中都可用，因为 Object 类是 Java 中每个类的超类。在这里，我们必须注意，无论是终结还是垃圾收集都不能保证。考虑以下示例。

public class FinalizeTest {
	int j=12;
	void add()
	{
		j=j+12;
		System.out.println("J="+j);
	}
	public void finalize()
	{
		System.out.println("Object is garbage collected");
	}
	public static void main(String[] args) {
		new FinalizeTest().add();
		System.gc();
		new FinalizeTest().add();
	}
}
	

184) 未引用的对象可以再次被引用吗？

是的，一旦对象变为未引用，在 Java 中就没有直接的方法可以再次引用它。但是，如果未引用的对象可以通过仍然引用的其他对象到达，则可以间接引用它。

185) 垃圾回收器线程是什么类型的线程？

守护线程。Java 中的垃圾回收器线程是一种特殊线程，负责通过删除不再可达的对象来回收内存。它在后台运行，并由 Java 虚拟机 (JVM) 管理。

186) final、finally 和 finalize 有什么区别？

编号。	final	finally	finalize
1)	final 用于对类、方法和变量施加限制。final 类不能被继承，final 方法不能被覆盖，final 变量的值不能被改变。	finally 用于放置重要的代码，无论异常是否处理，它都会执行。	finalize 用于在对象被垃圾回收之前执行清理处理。
2)	final 是一个关键字。	finally 是一个块。	finalize 是一个方法。

187) Runtime 类的目的是什么？

Java Runtime 类用于与 Java Runtime Environment 进行交互。Java Runtime 类提供执行进程、调用 GC、获取总内存和可用内存等方法。它允许 Java 应用程序与其运行环境进行交互，例如执行系统命令、管理进程执行、访问环境变量等。一个 Java 应用程序只有一个 java.lang.Runtime 类的实例可用。Runtime.getRuntime() 方法返回 Runtime 类的单例实例。

阅读更多：Java Runtime 类

188) 如何在 Java 中调用任何外部进程？

我们可以使用 ProcessBuilder 或 Runtime 类在 Java 中调用外部进程。这是一个使用 ProcessBuilder 的示例

public class Runtime1{
 public static void main(String args[])throws Exception{
  Runtime.getRuntime().exec("notepad");//will open a new notepad
 }
}

I/O 面试题

189) 给出 InputStream 和 OutputStream 类的层次结构。

OutputStream 层次结构

InputStream 层次结构

阅读更多：Java I/O 教程

190) 你如何理解 IO 流？

Java 中的 I/O 流表示一系列数据。它用于输入和输出操作，允许从文件、网络连接、内存等各种源读取或写入数据。在 Java 中，以下三个流会自动创建。

System.out：标准输出流
System.in：标准输入流
System.err：标准错误流

191) Reader/Writer 类层次结构与 InputStream/OutputStream 类层次结构有什么区别？

Reader/Writer 类层次结构是面向字符的，而 InputStream/OutputStream 类层次结构是面向字节的。字节流类用于执行 8 位字节的输入输出，而字符流类用于执行 16 位 Unicode 系统的输入输出。字节流类层次结构中有许多类，但最常用的类是 FileInputStream 和 FileOutputStream。字符流类层次结构中最常用的类是 FileReader 和 FileWriter。

Java 中的 Reader/Writer 类层次结构用于基于字符的输入/输出操作。这些类处理 Unicode 字符，适用于处理文本数据。

Java 中的 InputStream/OutputStream 类层次结构用于基于字节的输入/输出操作。这些类处理原始字节，适用于处理二进制数据。

阅读更多：Java 中的分层继承

192) 所有流的最高级类是什么？

所有流类可以分为两种类型的类，即字节流类和字符流类。字节流类进一步分为 InputStream 类和 OutputStream 类。字符流类也分为 Reader 类和 Writer 类。所有流的最高级类是 InputStream 和 OutputStream。这些类定义了从流读取和写入流的基本功能。类似地，对于所有 Reader 类，最高级类是 java.io.Reader，对于所有 Writer 类，它是 java.io.Writer。

193) 什么是 FileInputStream 和 FileOutputStream？

**Java FileOutputStream** 是一个用于将数据写入文件的输出流。如果要将一些原始值写入文件，请使用 FileOutputStream 类。它们分别是 InputStream 和 OutputStream 的子类。我们可以通过 FileOutputStream 类写入面向字节和面向字符的数据。但是，对于面向字符的数据，最好使用 FileWriter 而不是 FileOutputStream。考虑以下将字节写入文件的示例。

import java.io.FileOutputStream;  
public class FileOutputStreamExample {  
    public static void main(String args[]){    
           try{    
             FileOutputStream fout=new FileOutputStream("D:\\testout.txt");    
             fout.write(65);    
             fout.close();    
             System.out.println("success...");    
            }catch(Exception e){System.out.println(e);}    
      }    
}  

**Java FileInputStream 类**从文件中获取输入字节。它用于读取面向字节的数据（原始字节流），例如图像数据、音频、视频等。我们还可以读取字符流数据。但是，对于读取字符流，建议使用 FileReader 类。考虑以下从文件读取字节的示例。

import java.io.FileInputStream;  
public class DataStreamExample {  
     public static void main(String args[]){    
          try{    
            FileInputStream fin=new FileInputStream("D:\\testout.txt");    
            int i=fin.read();  
            System.out.print((char)i);    
  
            fin.close();    
          }catch(Exception e){System.out.println(e);}    
         }    
        }  
  

阅读更多：Java FileOutputStream 类

阅读更多：Java FileInputStream 类

194) 使用 BufferedInputStream 和 BufferedOutputStream 类的目的是什么？

在 Java 中，使用 BufferedInputStream 和 BufferedOutputStream 类的目的是通过减少磁盘或网络访问次数来提高 I/O 性能。它内部使用缓冲区来存储数据。它比直接将数据写入流更有效。因此，它使性能更快。而 Java BufferedInputStream 类用于从流中读取信息。它内部使用缓冲区机制来加快性能。

阅读更多：Java BufferedInputStream 类

阅读更多：Java BufferedOutputStream 类

195) 如何在 Java 中设置文件的权限？

在 Java 中，FilePermission 类用于更改文件上设置的权限。Java FilePermission 类包含与目录或文件相关的权限。我们可以使用 java.io.File 类的 setReadable()、setWritable() 和 setExecutable() 方法来设置文件的权限。这些方法分别允许我们为指定文件设置读、写和执行权限。所有权限都与路径相关。路径可以是两种类型：

D:\\IO\\-：表示权限与所有子目录和文件递归关联。
D:\\IO\\*：表示权限与此目录中的所有目录和文件（不包括子目录）关联。

让我们看一个简单的例子，其中目录路径被授予读取权限，该目录下的文件被授予写入权限。

package com.Tpointtech;
import java.io.*;
import java.security.PermissionCollection;
public class FilePermissionExample{
     public static void main(String[] args) throws IOException {
      String srg = "D:\\IO Package\\java.txt";
      FilePermission file1 = new FilePermission("D:\\IO Package\\-", "read");
      PermissionCollection permission = file1.newPermissionCollection();
      permission.add(file1);
           FilePermission file2 = new FilePermission(srg, "write");
           permission.add(file2);
         if(permission.implies(new FilePermission(srg, "read,write"))) {
           System.out.println("Read, Write permission is granted for the path "+srg );
             }else {
            System.out.println("No Read, Write permission is granted for the path "+srg);            }
     } 
}

输出

Read, Write permission is granted for the path D:\IO Package\java.txt

196) 什么是 FilterStreams？

FilterStream 类用于为其他流类添加额外功能。FilterStream 类就像一个接口，它从流中读取数据，过滤数据，然后将过滤后的数据传递给调用者。这些流在从底层流读取或写入数据时“过滤”数据。FilterStream 类提供额外的功能，例如为目标文件添加行号等。

197) 什么是 I/O 过滤器？

I/O 过滤器是一个从一个流读取并写入另一个流的对象。通常在数据从一个流传递到另一个流时以某种方式更改数据。过滤器可以应用于输入流和输出流以执行加密、压缩、缓冲等任务。许多 Filter 类允许用户使用多个输入流创建链。它对多个过滤器产生组合效果。

198) 有哪些从控制台获取输入的方法？

在 Java 中，有三种方法可以从控制台获取输入。

使用 Scanner 类
结合 System.in 使用 BufferedReader 类
使用 Console 类

让我们分别简述一下。

使用 BufferedReader 类： 我们可以通过将 System.in 包装到 InputStreamReader 中并将其传递给 BufferedReader 来从控制台获取输入。由于输入被缓冲，它提供了高效的读取。请看以下示例。

import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
public class Person 
{ 
    public static void main(String[] args) throws IOException  
    { 
      System.out.println("Enter the name of the person");
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); 
        String name = reader.readLine(); 
        System.out.println(name);         
    } 
} 

使用 Scanner 类： Java Scanner 类使用分隔符（默认是空格）将输入分解为标记。它提供了许多方法来读取和解析各种基本值。Java Scanner 类广泛用于使用正则表达式解析字符串和基本类型的文本。Java Scanner 类继承了 Object 类并实现了 Iterator 和 Closeable 接口。请看以下示例。

import java.util.*;  
public class ScannerClassExample2 {    
      public static void main(String args[]){                       
          String str = "Hello/This is Tpointtech/My name is Abhishek.";  
          //Create scanner with the specified String Object  
          Scanner scanner = new Scanner(str);  
          System.out.println("Boolean Result: "+scanner.hasNextBoolean());            
          //Change the delimiter of this scanner  
          scanner.useDelimiter("/");  
          //Printing the tokenized Strings  
          System.out.println("---Tokenizes String---");   
        while(scanner.hasNext()){  
            System.out.println(scanner.next());  
        }  
          //Display the new delimiter  
          System.out.println("Delimiter used: " +scanner.delimiter());            
          scanner.close();  
          }    
}  
  

使用 Console 类： Java Console 类用于从控制台获取输入。它提供了读取文本和密码的方法。如果我们使用 Console 类读取密码，密码将不会显示给用户。java.io.Console 类在内部连接到系统控制台。Console 类自 1.5 版本引入。请看以下示例。

import java.io.Console;  
class ReadStringTest{    
public static void main(String args[]){    
Console c=System.console();    
System.out.println("Enter your name: ");    
String n=c.readLine();    
System.out.println("Welcome "+n);    
}    
}  

序列化面试问题

199) 什么是序列化？

Java 中的序列化是将对象的状态写入字节流的机制。它主要用于 Hibernate、RMI、JPA、EJB 和 JMS 技术。它主要用于在网络上传输对象的状态（称为编组）。Serializable 接口用于执行序列化。当您需要将程序状态保存到文件等存储设备时，它非常有用。稍后，可以使用反序列化恢复此文件的内容。反序列化是将字节流转换回对象的逆过程。它还需要实现 RMI（远程方法调用）。借助 RMI，可以调用一台机器上的 Java 对象的方法到另一台机器。

了解更多：Java 中的序列化

200) 如何在 Java 中使类可序列化？

通过实现 Serializable 接口，类可以变得可序列化。此接口充当标记接口，向 Java 运行时指示该类的实例可以被序列化。

201) 如果基类实现了 Serializable 接口，如何避免子类序列化？

如果基类打算实现 Serializable 接口，阻止子类序列化非常棘手。但是，我们不能直接这样做，但可以通过在子类中实现 writeObject() 或 readObject() 方法并从这些方法中抛出 NotSerializableException 来避免序列化。请看以下示例。

如果基类实现了 Serializable 接口，并且您想避免子类序列化，可以将子类的字段标记为 transient。这将阻止这些字段在子类对象序列化时被序列化，即使基类实现了 Serializable。

import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.io.NotSerializableException; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.io.Serializable; 
class Person implements Serializable 
{ 
    String name = " ";
    public Person(String name)  
    { 
        this.name = name; 
    }       
} 
class Employee extends Person
{ 
    float salary;
    public Employee(String name, float salary)  
    { 
        super(name); 
        this.salary = salary; 
    } 
    private void writeObject(ObjectOutputStream out) throws IOException 
    { 
        throw new NotSerializableException(); 
    } 
    private void readObject(ObjectInputStream in) throws IOException 
    { 
        throw new NotSerializableException(); 
    } 
      
} 
public class Test 
{ 
    public static void main(String[] args)  
            throws Exception  
    { 
        Employee emp = new Employee("Sharma", 10000); 
          
        System.out.println("name = " + emp.name); 
        System.out.println("salary = " + emp.salary); 
          
        FileOutputStream fos = new FileOutputStream("abc.ser"); 
        ObjectOutputStream oos = new ObjectOutputStream(fos); 
              
        oos.writeObject(emp); 
              
        oos.close(); 
        fos.close(); 
              
        System.out.println("Object has been serialized"); 
          
        FileInputStream f = new FileInputStream("ab.txt"); 
        ObjectInputStream o = new ObjectInputStream(f); 
              
        Employee emp1 = (Employee)o.readObject(); 
              
        o.close(); 
        f.close(); 
              
        System.out.println("Object has been deserialized"); 
          
        System.out.println("name = " + emp1.name); 
        System.out.println("salary = " + emp1.salary); 
    } 
} 

202) 序列化对象可以通过网络传输吗？

是的，序列化对象可以通过网络传输。一旦对象被序列化为字节流，就可以通过网络传输。我们还可以将序列化对象写入磁盘或数据库。

203) 什么是反序列化？

反序列化是从序列化状态重建对象的过程。它是序列化的逆操作。反序列化涉及从文件、网络流或任何其他源读取序列化数据，并从该数据重建原始对象。ObjectInputStream 反序列化使用 ObjectOutputStream 写入的对象和原始数据。

import java.io.*;
class Depersist{
 public static void main(String args[])throws Exception{
  
  ObjectInputStream in=new ObjectInputStream(new FileInputStream("f.txt"));
  Student s=(Student)in.readObject();
  System.out.println(s.id+" "+s.name);

  in.close();
 }
}

输出

211 ravi

了解更多：Java 中序列化和反序列化的区别

204) transient 关键字有什么用？

在 Java 中，transient 关键字用于指示在对象序列化时，字段不应被序列化。通过定义 transient 关键字，变量的值在恢复时无需保留。更多详情。

了解更多：Java transient 关键字

205) 什么是 Externalizable？

Externalizable 接口用于以压缩格式将对象的状态写入字节流。与 Serializable 相比，它允许对序列化和反序列化过程进行更多控制。实现 Externalizable 的类必须提供 writeExternal() 和 readExternal() 方法的实现，这些方法分别在序列化和反序列化期间调用。它不是标记接口。

206) Serializable 和 Externalizable 接口有什么区别？

编号。	Serializable	Externalizable
1)	Serializable 接口没有任何方法，即它是一个标记接口。	Externalizable 接口不是标记接口，它包含两个方法，即 writeExternal() 和 readExternal()。
2)	它用于“标记”Java 类，以便这些类的对象可以获得某些功能。	Externalizable 接口将序列化逻辑的控制权交给程序员。
3)	它易于实现但性能成本较高。	它用于执行序列化，通常会带来更好的性能。
4)	序列化中不调用类构造函数。	使用此接口时，我们必须调用公共默认构造函数。

了解更多：序列化和 Externalizable 接口

网络面试问题

207) 简要描述 Java 套接字编程？

Java 套接字编程用于在不同 JRE 上运行的应用程序之间进行通信。Java 套接字编程可以是面向连接的，也可以是无连接的。Socket 和 ServerSocket 类用于面向连接的套接字编程，DatagramSocket 和 DatagramPacket 类用于无连接套接字编程。套接字编程中的客户端必须知道两个信息：

服务器的 IP 地址
端口号

了解更多：Java 套接字编程

208) 什么是 Socket？

套接字只是机器之间通信的端点。它提供了使用 TCP 连接两台计算机的连接机制。套接字允许在客户端和服务器进程之间发送和接收数据。Socket 类可用于创建套接字。

209) 两台计算机通过 TCP 连接时遵循哪些步骤？

两台计算机通过 TCP 连接时执行以下步骤。

服务器套接字创建： 服务器实例化 ServerSocket 对象，该对象表示将建立连接的端口号。
侦听连接： 实例化 ServerSocket 对象后，服务器调用 ServerSocket 类的 accept() 方法，使服务器等待客户端尝试连接到给定端口上的服务器。
客户端套接字创建： 同时，服务器正在等待，客户端通过实例化 Socket 类来创建套接字。Socket 类构造函数接受服务器端口号和服务器名称。
服务器接受连接： Socket 类构造函数尝试连接到指定名称的服务器。如果连接建立，客户端将拥有一个可以与服务器通信的套接字对象。
连接建立： 服务器调用的 accept() 方法返回与服务器连接的服务器上新套接字的引用。

210) 编写一个 Java 程序来建立客户端和服务器之间的连接？

考虑以下程序，其中建立了客户端和服务器之间的连接。

文件：MyServer.java

import java.io.*;
import java.net.*;
public class MyServer {
public static void main(String[] args){
try{
ServerSocket ss=new ServerSocket(6666);
Socket s=ss.accept();//establishes connection 
DataInputStream dis=new DataInputStream(s.getInputStream());
String  str=(String)dis.readUTF();
System.out.println("message= "+str);
ss.close();
}catch(Exception e){System.out.println(e);}
}
}

文件：MyClient.java

import java.io.*;
import java.net.*;
public class MyClient {
public static void main(String[] args) {
try{  
Socket s=new Socket("localhost",6666);
DataOutputStream dout=new DataOutputStream(s.getOutputStream());
dout.writeUTF("Hello Server");
dout.flush();
dout.close();
s.close();
}catch(Exception e){System.out.println(e);}
}
}

211) 如何将数字 IP 地址（如 192.18.97.39）转换为主机名（如 java.sun.com）？

要将数字 IP 地址（如“192.18.97.39”）转换为主机名（如“java.sun.com”），我们可以使用 Java 中的 InetAddress 类。通过使用 InetAddress.getByName("192.18.97.39").getHostName() 方法，我们可以获取主机名。请看以下示例。

import java.io.*;  
import java.net.*;  
public class InetDemo{  
public static void main(String[] args){  
try{  
InetAddress ip=InetAddress.getByName("195.201.10.8");  

System.out.println("Host Name: "+ip.getHostName());  
}catch(Exception e){System.out.println(e);}  
}  
}  
	

反射面试问题

212) 什么是反射？

反射指的是程序在运行时检查和修改自身结构和行为的能力。java.lang.Class 类提供了各种方法，可用于获取元数据、检查和更改类的运行时行为。它允许我们分析类、接口和对象的功能，以及动态调用方法、访问字段和创建新对象。java.lang 和 java.lang.reflect 包提供了 Java 反射的类。它用于：

IDE（集成开发环境）。例如 Eclipse、MyEclipse、NetBeans。
调试器
测试工具等。

了解更多：Java 反射 API

213) 使用 java.lang.Class 类的目的是什么？

java.lang.Class 类主要执行两个任务：

提供在运行时获取类元数据的方法。
提供检查和更改类运行时行为的方法。

214) 有哪些实例化 Class 类的方法？

有三种实例化 Class 类的方法。

使用 .class 语法： Class<?> clazz = MyClass.class;
使用 getClass() 方法： Class<?> clazz = obj.getClass();
使用 forName() 方法： Class<?> clazz = Class.forName("fully.qualified.ClassName");

使用 Class.forName() 方法： forName() 方法用于动态加载类。它返回 Class 类的实例。如果我们知道类的完全限定名，就应该使用它。它不能用于基本类型。

使用 Object.getClass() 方法： 它返回 Class 类的实例。如果我们知道类型，就应该使用它。此外，它还可以用于基本类型。

使用 .class 语法： 如果类型可用但没有实例，可以通过在类型名称后附加“.class”来获取 Class。它也可以用于基本数据类型。

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

class Simple{  
 public Simple()
 {
   System.out.println("Constructor of Simple class is invoked");
 }
 void message(){System.out.println("Hello Java");}  
}  
  
class Test1{  
 public static void main(String args[]){  
  try{  
  Class c=Class.forName("Simple");  
  Simple s=(Simple)c.newInstance();  
  s.message();  
  }catch(Exception e){System.out.println(e);}  
 }  
}  

输出

Constructor of Simple class is invoked
Hello Java

说明

Class 类的 newInstance() 方法用于在运行时调用构造函数。在此程序中，创建了 Simple 类的实例。

216) 使用 javap 的目的是什么？

javap 命令反汇编类文件。它以人类可读的格式打印类的字段、方法和构造函数的信息。javap 对于理解 Java 类的内部结构和分析字节码非常有用。

语法

217) 我们能否从类外部访问私有方法？

不，在 Java 中我们不能从类外部访问私有方法。私有方法只能在其声明的类内部访问。它们不能从子类或同一包中的其他类访问。

更多详情。

杂项面试问题

218) 什么是包装类？

在 Java 中，包装类是允许将基本类型作为对象访问的类。换句话说，我们可以说包装类是 Java 内置类，允许将对象转换为基本类型，将基本类型转换为对象。将基本类型转换为对象的过程称为自动装箱，将对象转换为基本类型的过程称为拆箱。java.lang 包中存在八个包装类，如下所示。

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

了解更多：Java 中的包装类

219) 什么是自动装箱和拆箱？它何时发生？

自动装箱是将基本数据类型转换为相应的包装类对象的过程。例如，int 转换为 Integer。

拆箱是将包装类对象转换为基本数据类型。例如，Integer 转换为 int。

拆箱和自动装箱在 Java 中自动发生。但是，我们可以通过使用 valueOf() 或 xxxValue() 等方法在外部将它们相互转换。

每当需要包装类对象但提供了基本数据类型，或反之亦然时，它都可能发生。
将基本类型添加到 Java 中的 Collection（例如 ArrayList）。
创建参数化类的实例。例如，ThreadLocal 期望类型。
在方法调用中，只要需要对象而提供了基本类型，Java 就会自动将基本类型转换为对象。
当基本类型赋值给对象类型时。

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

public class Test1
{
  public static void main(String[] args) {
  Integer i = new Integer(201);
  Integer j = new Integer(201);
  if(i == j)
  {
    System.out.println("hello");
  }
  else 
  {
    System.out.println("bye");
  }
  }
}

输出

bye

说明

Integer 类缓存 -127 到 127 之间的整数值。因此，Integer 对象只能在 -128 到 127 的范围内创建。运算符 == 不适用于大于 127 的值；因此打印 bye。

221) 什么是对象克隆？

对象克隆是指创建对象的精确副本的过程。Object 类的 clone() 方法用于克隆对象。要创建其对象克隆的类必须实现 java.lang.Cloneable 接口。对象克隆创建一个与原始对象状态相同的新对象，但这两个对象彼此独立。如果我们不实现 Cloneable 接口，clone() 方法会生成 CloneNotSupportedException。clone() 方法在 Object 类中定义。clone() 方法的语法如下：

protected Object clone() throws CloneNotSupportedException

222) 对象克隆的优点和缺点是什么？

对象克隆的优点

我们不需要编写冗长重复的代码。只需使用一个抽象类，其中包含 4 或 5 行长的 clone() 方法。
它是复制对象最简单有效的方法，特别是如果我们将它应用于已开发或旧项目。只需定义一个父类，在其中实现 Cloneable，提供 clone() 方法的定义，任务就完成了。
使用 clone() 方法是复制数组最快的方法。

对象克隆的缺点

要使用 Object.clone() 方法，我们必须更改代码中的许多语法，例如实现 Cloneable 接口、定义 clone() 方法和处理 CloneNotSupportedException，最后调用 Object.clone() 等。
我们必须实现 Cloneable 接口，而它本身没有任何方法。我们必须使用它来告诉 JVM 我们可以在对象上执行 clone()。
clone() 是受保护的，所以我们必须提供自己的 clone() 并间接从它调用 Object.clone()。
clone() 不会调用任何构造函数，因此我们无法控制对象的构造。
如果要在子类中编写 clone 方法，则其所有超类都应该在其中定义 clone() 方法或从另一个父类继承它。否则，super.clone() 链将失败。
clone() 方法只支持浅拷贝，但如果我们需要深拷贝，则需要覆盖它。

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

223) 什么是 native 方法？

native 方法是用 Java 以外的语言实现的方法。native 方法有时也称为外部方法。native 方法使用 native 关键字声明，其实现由本机库或外部源提供。

224) strictfp 关键字的目的是什么？

Java strictfp 关键字确保如果我们对浮点变量执行操作，在每个平台上都会得到相同的结果。精度可能因平台而异，这就是为什么 Java 编程语言提供了 strictfp 关键字，以便我们在每个平台上都得到相同的结果。它确保浮点运算在不同的 JVM 实现中行为一致。因此，我们对浮点算术有更好的控制。

了解更多：Java 中的 Strictfp 关键字

225) System 类的目的是什么？

System 类的目的是提供对标准输入和输出等系统资源的访问。它不能被实例化。System 类提供的功能如下：

标准输入
错误输出流
标准输出
复制数组部分的实用方法
加载文件和库的实用程序

Java System 类有三个字段，即静态 printstream err、静态 inputstream in 和标准输出流。

226) 当有人提到 Java 中的浅拷贝时，你会想到什么？

对象克隆。当有人提到 Java 中的浅拷贝时，他们指的是一种复制操作，它创建一个新对象并将原始对象字段的值复制到新对象。

227) 什么是单例类？

Java 中的单例类是受限于在应用程序的整个生命周期中只有一个实例的类。要使一个类成为单例，我们既可以将其构造函数设为私有，也可以使用静态 getInstance() 方法。请看以下示例。

class Singleton{
    private static Singleton single_instance = null;
    int i;
     private Singleton ()
     {
         i=90;
     }
     public static Singleton getInstance()
     {
         if(single_instance == null)
         {
             single_instance = new Singleton();
         }
         return single_instance;
     }
}
public class Main 
{
    public static void main (String args[])
    {
        Singleton first = Singleton.getInstance();
        System.out.println("First instance integer value:"+first.i);
        first.i=first.i+90;
        Singleton second = Singleton.getInstance();
        System.out.println("Second instance integer value:"+second.i);
    }
}
	

了解更多：Java 中的单例类

228) 编写一个 Java 程序，打印命令行中给出的所有值。

程序

class A{
public static void main(String args[]){

for(int i=0;i<args.length;i++)
System.out.println(args[i]);

}
}

compile by > javac A.java
run by > java A sonoo jaiswal 1 3 abc

输出

sonoo
jaiswal
1
3
abc

229) 哪些容器使用边界布局作为其默认布局？

Window、Frame 和 Dialog 类使用边界布局作为其默认布局。使用 BorderLayout 作为其默认布局的容器包括 JFrame、JDialog、JWindow 和 Applet。

230) 哪些容器使用流式布局作为其默认布局？

使用 FlowLayout 作为其默认布局的容器包括 JPanel 和 JApplet。

231) 什么是无对等组件？

Swing 的轻量级组件称为无对等组件。Java Swing 中的无对等组件是没有原生操作系统对等体的组件。Spring 框架拥有自己的库，因此它不使用操作系统的资源，因此它具有轻量级组件。

232) Scrollbar 和 ScrollPane 之间有什么区别吗？

是的，Scrollbar 和 ScrollPane 之间有区别：Scrollbar 是一个 Component，而 ScrollPane 是一个 Container。ScrollPane 处理其事件并执行其滚动。

233) 什么是轻量级组件？

Java Swing 中的轻量级组件是完全由 Java 代码绘制且没有原生操作系统对等体的组件。它不进行原生调用以获取图形单元。它们共享其父组件的图形单元来渲染它们。例如，Swing 组件和 JavaFX 组件。

234) 什么是重量级组件？

Java Swing 中的重量级组件是具有原生操作系统对等体的组件。操作系统提供的可移植元素称为重量级组件。AWT 仅限于操作系统提供的图形类，因此它只实现了所有平台支持的屏幕元素的最小子集。依赖于操作系统的 UI 发现工具称为重量级组件。

235) 什么是 applet？

applet 是一个在浏览器中运行并生成动态内容的小型 Java 程序。它嵌入在网页中并在客户端运行。它安全且响应时间短。它可以在许多平台（包括 Linux、Windows、macOS 等）上运行的浏览器中执行。它们在互联网早期很流行，但已 largely 被 JavaScript 和 HTML5 等其他 Web 技术取代。但是，客户端浏览器需要插件才能执行 applet。下图显示了 Applet 的架构。

创建 applet 时，按顺序调用以下方法。

init()
start()
paint()

销毁 applet 时，按顺序调用以下函数。

stop()
destroy()

了解更多：Java Applet

236) 你能编写一个既可以作为 applet 也可以作为应用程序使用的 Java 类吗？

是的。我们可以编写一个既可以作为 applet 也可以作为应用程序使用的 Java 类。只需向 applet 添加一个 main() 方法。

国际化面试问题

237) 什么是 Locale？

Locale 对象表示特定的地理、政治或文化区域。Locale 对象用于指定日期、数字、货币和消息的格式，以用户首选的语言和格式显示给用户。此对象可用于获取特定于区域设置的信息，例如国家/地区名称、语言、变体等。

import java.util.*;
public class LocaleExample {
public static void main(String[] args) {
Locale locale=Locale.getDefault();
//Locale locale=new Locale("fr","fr");//for the specific locale

System.out.println(locale.getDisplayCountry());
System.out.println(locale.getDisplayLanguage());
System.out.println(locale.getDisplayName());
System.out.println(locale.getISO3Country());
System.out.println(locale.getISO3Language());
System.out.println(locale.getLanguage());
System.out.println(locale.getCountry());
	
}
}

输出

United States
English
English (United States)
USA
eng
en
US

238) 如何加载特定区域设置？

可以使用 ResourceBundle.getBundle(?) 方法加载特定区域设置。

Java Bean 面试问题

239) 什么是 JavaBean？

JavaBean 是用 Java 编程语言编写的可重用软件组件，旨在由软件开发环境（如 JBuilder 或 VisualAge for Java）进行可视化操作。JavaBean 遵循一组约定，例如为访问属性提供 getter 和 setter 方法、可序列化以及提供无参数构造函数。JavaBean 将许多对象封装到一个对象中，这样我们就可以从多个地方访问此对象。此外，它还提供了易于维护的特性。请看以下创建 JavaBean 类的示例。

Employee.java

//Employee.java
package mypack;
public class Employee implements java.io.Serializable{
private int id;
private String name;
public Employee(){}
public void setId(int id){this.id=id;}
public int getId(){return id;}
public void setName(String name){this.name=name;}
public String getName(){return name;}
}

了解更多：JavaBean

240) 使用 Java bean 的目的是什么？

根据 Java 白皮书，它是一个可重用软件组件。Bean 将许多对象封装到一个对象中，这样我们就可以从多个地方访问此对象。Java Bean 遵循标准命名约定和设计模式，使其能够与各种开发工具和框架互操作。此外，它还提供了易于维护的特性。

241) 你对 bean 持久属性有什么了解？

Java bean 的持久性属性在属性、字段和状态信息保存到存储或从存储检索时发挥作用。这种持久性通常通过将属性值存储在持久性存储机制（如数据库、文件系统或远程存储服务）中来实现。Bean 持久属性通常用于企业应用程序中，以存储和检索配置设置、用户偏好和其他应用程序状态数据。

RMI 面试问题

242) 什么是 RMI？

RMI（远程方法调用）是一个 API，它提供了一种在 Java 中创建分布式应用程序的机制。RMI 允许对象调用在另一个 JVM 中运行对象上的方法。它支持在不同机器上运行的 Java 应用程序之间的通信。RMI 使用两个对象——存根 (stub) 和骨架 (skeleton) 提供应用程序之间的远程通信。

了解更多：RMI

243) 存根和骨架的目的是什么？

存根 (Stub)

存根是表示远程对象的客户端代理对象。它充当客户端的网关。所有传出请求都通过它路由。它位于客户端并表示远程对象。当调用者在存根对象上调用方法时，它执行以下任务：

它启动与远程虚拟机 (JVM) 的连接。
它将参数写入并传输（编组）到远程虚拟机 (JVM)。
它等待结果。
它读取（解组）返回值或异常。
最后，它将值返回给调用者。

骨架 (Skeleton)

骨架是服务器端对象，充当服务器应用程序和远程对象之间的中介。所有传入请求都通过它路由。当骨架接收到传入请求时，它执行以下任务：

它读取远程方法的参数。
它在实际远程对象上调用方法。
它将结果写入并传输（编组）到调用者。

244) 编写基于 RMI 的程序涉及哪些步骤？

编写基于 RMI 的程序需要执行以下六个步骤。

创建远程接口。
提供远程接口的实现。
编译实现类并使用 rmic 工具创建存根和骨架对象。
通过 rmiregistry 工具启动注册表服务。
创建并启动远程应用程序。
创建并启动客户端应用程序。

245) RMI 中 HTTP 隧道有什么用？

RMI 中的 HTTP 隧道是一种允许 RMI 通过 HTTP 协议（例如 HTTP 或 HTTPS）进行通信的技术。它可以定义为无需任何设置即可在防火墙环境中工作的方法。它通过代理服务器处理 HTTP 连接。但是，它不允许出站 TCP 连接。

246) 什么是 JRMP？

JRMP (Java Remote Method Protocol) 可以定义为 Java 特有的、基于流的协议，用于查找和引用远程对象。它要求客户端和服务器都使用 Java 对象。JRMP 在 TCP/IP 上运行，负责编组和解组方法参数、管理远程对象引用以及处理 Java 虚拟机 (JVM) 之间的通信。它是在 RMI 下、TCP/IP 上运行的线级协议。

247) RMI 和 CORBA 应用程序可以交互吗？

是的，它们可以。RMI 可以使用 IIOP 作为传输协议而不是 JRMP。例如，RMI/IIOP（RMI over IIOP）桥接器允许基于 RMI 的 Java 应用程序使用 Internet Inter-ORB 协议 (IIOP) 与基于 CORBA 的应用程序进行通信。同样，CORBA/IIOP 到 RMI 的桥接器使基于 CORBA 的应用程序能够调用基于 RMI 的 Java 对象。

Core Java：数据结构面试问题

248) 如何在 Java 中执行冒泡排序？

考虑以下程序在 Java 中执行冒泡排序。

public class BubbleSort {
  public static void main(String[] args) {
  int[] a = {10, 9, 7, 101, 23, 44, 12, 78, 34, 23};
  for(int i=0;i<10;i++)
  {
    for (int j=0;j<10;j++)
    {
      if(a[i]<a[j])
      {
        int temp = a[i];
        a[i]=a[j];
        a[j] = temp; 
      }
    }
  }
  System.out.println("Printing Sorted List ...");
  for(int i=0;i<10;i++)
  {
    System.out.println(a[i]);
  }
}
}

输出

Printing Sorted List . . . 
7
9
10
12
23
34
34
44
78 
101

了解更多：Java 中的冒泡排序

249) 如何在 Java 中执行二分查找？

考虑以下程序在 Java 中执行二分查找。

import java.util.*;
public class BinarySearch {
public static void main(String[] args) {
  int[] arr = {16, 19, 20, 23, 45, 56, 78, 90, 96, 100};
  int item, location = -1;
  System.out.println("Enter the item which you want to search");
  Scanner sc = new Scanner(System.in);
  item = sc.nextInt();
  location = binarySearch(arr,0,9,item);
  if(location != -1)
  System.out.println("the location of the item is "+location);
  else 
    System.out.println("Item not found");
  }
public static int binarySearch(int[] a, int beg, int end, int item)
{
  int mid;
  if(end >= beg) 
  { 
    mid = (beg + end)/2;
    if(a[mid] == item)
    {
      return mid+1;
    }
    else if(a[mid] < item) 
    {
      return binarySearch(a,mid+1,end,item);
    }
    else 
    {
      return binarySearch(a,beg,mid-1,item);
    }
  }
  return -1; 
}
}

输出

Enter the item which you want to search 
45 
the location of the item is 5

了解更多：Java 中的二分查找

250) 如何在 Java 中执行选择排序？

考虑以下程序在 Java 中执行选择排序。

public class SelectionSort {
public static void main(String[] args) {
  int[] a = {10, 9, 7, 101, 23, 44, 12, 78, 34, 23};
  int i,j,k,pos,temp;
  for(i=0;i<10;i++)
  {
    pos = smallest(a,10,i);
    temp = a[i];
    a[i]=a[pos];
    a[pos] = temp;
  }
  System.out.println("\nprinting sorted elements...\n");
  for(i=0;i<10;i++)
  {
    System.out.println(a[i]);
  }
}
public static int smallest(int a[], int n, int i)
{
  int small,pos,j;
  small = a[i];
  pos = i;
  for(j=i+1;j<10;j++)
  {
    if(a[j]<small)
    {
      small = a[j];
      pos=j;
    }
  }
  return pos;
}
}

输出

printing sorted elements...
7
9
10
12
23
23
34
44
78
101

了解更多：Java 中的选择排序

251) 如何在 Java 中执行线性查找？

考虑以下程序在 Java 中执行线性查找。

import java.util.Scanner;  
public class Leniear_Search {  
public static void main(String[] args) {  
  int[] arr = {10, 23, 15, 8, 4, 3, 25, 30, 34, 2, 19};  
  int item,flag=0;   
  Scanner sc = new Scanner(System.in);  
  System.out.println("Enter Item?");  
  item = sc.nextInt();  
  for(int i = 0; i<10; i++)  
  {  
    if(arr[i]==item)  
    {  
      flag = i+1;  
      break;  
    }  
    else   
      flag = 0;   
  }  
  if(flag != 0)  
  {  
    System.out.println("Item found at location" + flag);  
  }  
  else   
    System.out.println("Item not found");  
}  
} 

输出

Enter Item?
23
Item found at location 2
Enter Item?
22
Item not found

了解更多：Java 中的线性查找

252) 如何在 Java 中执行归并排序？

考虑以下程序在 Java 中执行归并排序。

public class MyMergeSort
{
void merge(int arr[], int beg, int mid, int end)
{

int l = mid - beg + 1;
int r = end - mid;

intLeftArray[] = new int [l];
intRightArray[] = new int [r];

for (int i=0; i<l; ++i)
LeftArray[i] = arr[beg + i];

for (int j=0; j<r; ++j)
RightArray[j] = arr[mid + 1+ j];


int i = 0, j = 0;
int k = beg;
while (i<l&&j<r)
{
if (LeftArray[i] <= RightArray[j])
{
arr[k] = LeftArray[i];
i++;
}
else
{
arr[k] = RightArray[j];
j++;
}
k++;
}
while (i<l)
{
arr[k] = LeftArray[i];
i++;
k++;
}

while (j<r)
{
arr[k] = RightArray[j];
j++;
k++;
}
}

void sort(int arr[], int beg, int end)
{
if (beg<end)
{
int mid = (beg+end)/2;
sort(arr, beg, mid);
sort(arr , mid+1, end);
merge(arr, beg, mid, end);
}
}
public static void main(String args[])
{
intarr[] = {90,23,101,45,65,23,67,89,34,23};
MyMergeSort ob = new MyMergeSort();
ob.sort(arr, 0, arr.length-1);

System.out.println("\nSorted array");
for(int i =0; i<arr.length;i++)
{
  System.out.println(arr[i]+"");
}
}
}

输出

Sorted array 
23
23
23
34
45
65
67
89
90
101

了解更多：Java 中的归并排序

253) 如何在 Java 中执行快速排序？

考虑以下程序在 Java 中执行快速排序。

public class QuickSort {
public static void main(String[] args) {
    int i;
    int[] arr={90,23,101,45,65,23,67,89,34,23};
    quickSort(arr, 0, 9);
    System.out.println("\n The sorted array is: \n");
    for(i=0;i<10;i++)
    System.out.println(arr[i]);
  }
  public static int partition(int a[], int beg, int end)
  {
    
    int left, right, temp, loc, flag; 
    loc = left = beg;
    right = end;
    flag = 0;
    while(flag != 1)
    {
      while((a[loc] <= a[right]) && (loc!=right))
      right--;
      if(loc==right)
      flag =1;
      elseif(a[loc]>a[right])
      {
        temp = a[loc];
        a[loc] = a[right];
        a[right] = temp;
        loc = right;
      }
      if(flag!=1)
      {
        while((a[loc] >= a[left]) && (loc!=left))
        left++;
        if(loc==left)
        flag =1;
        elseif(a[loc] <a[left])
        {
          temp = a[loc];
          a[loc] = a[left];
          a[left] = temp;
          loc = left;
        }
      }
    }
    returnloc;
  }
  static void quickSort(int a[], int beg, int end)
  {
    
    int loc;
    if(beg<end)
    {
      loc = partition(a, beg, end);
      quickSort(a, beg, loc-1);
      quickSort(a, loc+1, end);
    }
  }
}

输出

The sorted array is: 
23
23
23
34
45
65
67
89
90
101

254) 编写一个 Java 程序来创建包含 n 个节点的双向链表。

考虑以下程序来创建包含 n 个节点的双向链表。

  public class CountList {
    
    //Represent a node of the doubly linked list

    class Node{
        int data;
        Node previous;
        Node next;
        
        public Node(int data) {
            this.data = data;
        }
    }
    
    //Represent the head and tail of the doubly linked list
    Node head, tail = null;
    
    //addNode() will add a node to the list
    public void addNode(int data) {
        //Create a new node
        Node newNode = new Node(data);
        
        //If list is empty
        if(head == null) {
            //Both head and tail will point to newNode
            head = tail = newNode;
            //head's previous will point to null
            head.previous = null;
            //tail's next will point to null, as it is the last node of the list
            tail.next = null;
        }
        else {
            //newNode will be added after tail such that tail's next will point to newNode
            tail.next = newNode;
            //newNode's previous will point to tail
            newNode.previous = tail;
            //newNode will become new tail
            tail = newNode;
            //As it is last node, tail's next will point to null
            tail.next = null;
        }
    }
    
    //countNodes() will count the nodes present in the list
    public int countNodes() {
        int counter = 0;
        //Node current will point to head
        Node current = head;
        
        while(current != null) {
            //Increment the counter by 1 for each node
            counter++;
            current = current.next;
        }
        return counter;
    }
    
    //display() will print out the elements of the list
    public void display() {
        //Node current will point to head
        Node current = head;
        if(head == null) {
            System.out.println("List is empty");
            return;
        }
        System.out.println("Nodes of doubly linked list: ");
        while(current != null) {
            //Prints each node by incrementing the pointer.

            System.out.print(current.data + " ");
            current = current.next;
        }
    }
    
    public static void main(String[] args) {
        
        CountList dList = new CountList();
        //Add nodes to the list
        dList.addNode(1);
        dList.addNode(2);
        dList.addNode(3);
        dList.addNode(4);
        dList.addNode(5);
        
        //Displays the nodes present in the list
        dList.display();
        
        //Counts the nodes present in the given list
        System.out.println("\nCount of nodes present in the list: " + dList.countNodes());
    }
}

输出

Nodes of doubly linked list: 
1 2 3 4 5 
Count of nodes present in the list: 5

255) 编写一个 Java 程序来查找循环链表中的最大值和最小值节点。

考虑以下程序：

public class MinMax {
    //Represents the node of list.
    public class Node{
        int data;
        Node next;
        public Node(int data) {
            this.data = data;
        }
    }
    
    //Declaring head and tail pointer as null.
    public Node head = null;
    public Node tail = null;
    
    //This function will add the new node at the end of the list.
    public void add(int data){
        //Create new node
        Node newNode = new Node(data);
        //Checks if the list is empty.
        if(head == null) {
             //If list is empty, both head and tail would point to new node.
            head = newNode;
            tail = newNode;
            newNode.next = head;
        }
        else {
            //tail will point to new node.
            tail.next = newNode;
            //New node will become new tail.
            tail = newNode;
            //Since, it is circular linked list tail will points to head.
            tail.next = head;
        }
    }
    
    //Finds out the minimum value node in the list
    public void minNode() {
        Node current = head;
        //Initializing min to initial node data
        int min = head.data;
        if(head == null) {
            System.out.println("List is empty");
        }
        else {
             do{
                 //If current node's data is smaller than min
                 //Then replace value of min with current node's data
                 if(min > current.data) {
                     min = current.data;
                 }
                 current= current.next;
            }while(current != head);
        
            System.out.println("Minimum value node in the list: "+ min);
        }
    }
        
    //Finds out the maximum value node in the list
    public void maxNode() {
        Node current = head;
        //Initializing max to initial node data
        int max = head.data;
        if(head == null) {
            System.out.println("List is empty");
        }
        else {
             do{
                 //If current node's data is greater than max
                 //Then replace value of max with current node's data
                 if(max < current.data) {
                     max = current.data;
                 }
                 current= current.next;
                }while(current != head);
             
            System.out.println("Maximum value node in the list: "+ max);
        }
    }
                
    public static void main(String[] args) {
        MinMax cl = new MinMax();
        //Adds data to the list
        cl.add(5);
        cl.add(20);
        cl.add(10);
        cl.add(1);
        //Prints the minimum value node in the list
        cl.minNode();
        //Prints the maximum value node in the list
        cl.maxNode();
    }
}

输出

Minimum value node in the list: 1
Maximum value node in the list: 20

256) 编写一个 Java 程序来计算二叉树的奇数层和偶数层节点之和的差。

考虑以下程序：

import java.util.LinkedList;
import java.util.Queue;
 
public class DiffOddEven {
    
    //Represent a node of binary tree
    public static class Node{
        int data;
        Node left;
        Node right;
        
        public Node(int data){
            //Assign data to the new node, set left and right children to null
            this.data = data;
            this.left = null;
            this.right = null;
            }
        }
    
    //Represent the root of binary tree
    public Node root;
  
    public DiffOddEven(){
        root = null;
    }
 
    //difference() will calculate the difference between sum of odd and even levels of binary tree
    public int difference() {
          int oddLevel = 0, evenLevel = 0, diffOddEven = 0;
          
          //Variable nodesInLevel keep tracks of number of nodes in each level
          int nodesInLevel = 0;
          
          //Variable currentLevel keep track of level in binary tree
          int currentLevel = 0;
          
          //Queue will be used to keep track of nodes of tree level-wise
          Queue<Node> queue = new LinkedList<Node>();
          
          //Check if root is null
          if(root == null) {
              System.out.println("Tree is empty");
              return 0;
          }
          else {
              //Add root node to queue as it represents the first level
              queue.add(root);
              currentLevel++;
              
              while(queue.size() != 0) {
                  
                  //Variable nodesInLevel will hold the size of queue i.e. number of elements in queue
                  nodesInLevel = queue.size();
                  
                  while(nodesInLevel > 0) {
                      Node current = queue.remove();
                      
                    //Checks if currentLevel is even or not.
                      if(currentLevel % 2 == 0)
                          //If level is even, add nodes's to variable evenLevel
                          evenLevel += current.data;
                      else
                          //If level is odd, add nodes's to variable oddLevel
                          oddLevel += current.data;
                      
                      //Adds left child to queue
                      if(current.left != null)
                          queue.add(current.left);
                      //Adds right child to queue
                      if(current.right != null) 
                          queue.add(current.right);
                     nodesInLevel--;
                  }
                  currentLevel++;
              }
              //Calculates difference between oddLevel and evenLevel
              diffOddEven = Math.abs(oddLevel - evenLevel);
          }
          return diffOddEven;
      }
  
    public static void main (String[] args) {
        
        DiffOddEven bt = new DiffOddEven();
        //Add nodes to the binary tree
        bt.root = new Node(1);
        bt.root.left = new Node(2);
        bt.root.right = new Node(3);
        bt.root.left.left = new Node(4);
        bt.root.right.left = new Node(5);
        bt.root.right.right = new Node(6);
    
        //Display the difference between sum of odd level and even level nodes
        System.out.println("Difference between sum of odd level and even level nodes: " + bt.difference());
}
}

输出

Difference between sum of odd level and even level nodes: 11

下一主题Java 多线程面试问题

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 个 Java 面试题 | 第 2 组

核心 Java - OOPs：多态性面试题

101) 编译时多态性与运行时多态性有什么区别？

102) 什么是运行时多态性？

103) 我们可以通过数据成员实现运行时多态性吗？

104) 静态绑定和动态绑定有什么区别？

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

106) 什么是 Java instanceof 运算符？

核心 Java - OOPs 概念：抽象面试题

107) 什么是抽象？

108) 抽象和封装有什么区别？

109) 什么是抽象类？

110) 没有抽象类可以有抽象方法吗？

111) 以下程序是否编写正确？如果是，程序的输出是什么？

112) 我们可以将 abstract 和 final 同时用于方法吗？

113) 是否可以实例化抽象类？

114) 什么是接口？

115) 我们可以将接口方法声明为 static 吗？

116) 接口可以是 final 吗？

117) 什么是标记接口？

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

119) 我们可以为接口中的成员定义 private 和 protected 修饰符吗？

120) 何时可以将对象引用强制转换为接口引用？

121) 如何在 Java 中创建一个只读类？

122) 如何在 Java 中创建一个只写类？

123) Java 中封装的优点是什么？

核心 Java - OOPs 概念：包面试题

124) 什么是包？

125) 在 Java 中定义包有什么好处？

126) 如何在 Java 中创建包？

127) 如何在 Java 中访问另一个类中的某个类？

128) 我需要随时导入 java.lang 包吗？为什么？

129) 我可以导入同一个包/类两次吗？JVM 会在运行时加载包两次吗？

130) 什么是静态导入？

Java：异常处理面试题

131) Java 程序中会发生多少种异常？

132) 什么是异常处理？

133) 解释 Java 异常类的层次结构？

134) 受检异常和非受检异常有什么区别？

135) Error 和 Exception 的基类是什么？

136) 每个 try 块后面都必须跟着一个 catch 块吗？

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

138) 什么是 finally 块？

139) finally 块可以在没有 catch 的情况下使用吗？

140) 有没有 finally 块不执行的情况？

141) throw 和 throws 有什么区别？

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

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

144) 异常可以重新抛出吗？

145) 如果父类方法不抛出异常，子类覆盖方法可以声明异常吗？

146) 什么是异常传播？

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

164) 说出 java.util.regex 包中存在的一些类。