Java面试题和答案(2024年收集更新)

Java是一种是高级的、面向对象的、健壮、安全的编程语言、平台无关、高性能、多线程和可移植的编程语言。它是由詹姆斯·高斯林在1991年6月开发。它也可以称为平台，因为它提供了自己的JRE和API。完整答案

C++和Java的区别，如下表中列出 - 比较索引 C++ Java 平台无关 C++ 是平台相关的。 Java 是平台无关的。主要用于 C++主要用于系统编程。 Java主要用于应用程序编程。它广泛用于窗口、基于Web、企业和移动应用程序。设计目标 C++ 专为系统和应用程序编程而设计，它是 C 编程语言的扩展。 Java 被设计和创建为打印系统的解释器，但后来扩展为支持网络计算。它的设计目标是易于使用并可供更广泛的受众使用。 Goto语句 C++ 支持 got... 完整答案

Java 编程语言有以下特点如下：简单：Java 很容易学习。 Java 的语法基于 C++，这使得在其中编写程序更容易。面向对象：Java 遵循面向对象的范式，它允许将代码维护为包含数据和行为的不同类型对象的组合。可移植性：Java 支持随处读取一次写入的方法。可以在每台机器上执行 Java 程序。 Java 程序 (.java) 被转换为可以在每台机器上轻松运行的字节码 (.class)。平台无关：Java 是一种平台无关的编程语言。它不同于需要平台执行的其他编程语言，如 C 和 C++... 完整答案

Java 虚拟机是使计算机能够运行Java程序的虚拟机。 JVM 就像一个运行时引擎，它调用 Java 代码中的 main 方法。 JVM是必须在计算机系统中实现的规范。 Java 代码由 JVM 编译为与机器无关且接近本机代码的字节码。完整答案

虚拟机/JVMJVM是Java Virtual Machine的首字母缩写；它是一个抽象机器，提供可以执行 Java 字节码的运行时环境。它是一个规范Java虚拟机工作的规范。它的实现由 Oracle 和其他公司提供。它的实现被称为 JRE。JVM 可用于许多硬件和软件平台(因此 JVM 取决于平台)。它是在我们运行 Java 类时创建的运行时实例。 JVM 有三个概念：规范、实现和实例。 JREJRE 代表 Java 运行时环境。它是JVM的实现。 Java 运行时环境是一组用于开发 Java... 完整答案

JVM分配了以下几种类型的内存区域：类(方法)区：类区存储每个类的结构，例如运行时常量池、字段、方法数据和方法代码。堆：它是运行时数据区，内存被分配给对象栈：Java Stack 存储帧。它保存局部变量和部分结果，并在方法调用和返回中发挥作用。每个线程都有一个私有 JVM 堆栈，与线程同时创建。每次调用方法时都会创建一个新框架。框架在其方法调用完成时被销毁。程序计数器寄存器：PC(程序计数器)寄存器包含当前正在执行的Java虚拟机指令的地址。本机方法堆栈：它包含应用程序中使用的所有本... 完整答案

Just-In-Time(JIT) 编译器：用于提高性能。 JIT 同时编译具有相似功能的部分字节码，从而减少编译所需的时间。这里术语“编译器”是指从 Java 虚拟机 (JVM) 的指令集到特定 CPU 的指令集的翻译器。完整答案

平台是执行软件的硬件或软件环境。有两种类型的平台，基于软件的和基于硬件的。 Java 提供了基于软件的平台。完整答案

Java平台与其他平台有以下区别： Java 是基于软件的平台，而其他平台可能是硬件平台或基于软件的平台。Java 在其他硬件平台之上执行，而其他平台只能有硬件组件。完整答案

这是因为有字节码。Java编译器将Java程序转换成类文件(字节码)，它是源代码和机器码之间的中间语言。此字节码不是特定于平台的，可以在任何计算机上执行。完整答案

Classloader 是 JVM 的一个子系统，用于加载类文件。每当运行 java 程序时，它首先由类加载器加载。 Java中有三个内置的类加载器。 Bootstrap ClassLoader：这是第一个类加载器，它是 Extension 类加载器的超类。它加载包含Java标准版所有类文件的rt.jar文件，如java.lang包类、java.net包类、java.util包类、java.io包类、java.sql包类等。Extension ClassLoader：这是Bootstrap的子... 完整答案

是的，Java 只允许通过 .java 保存 java 文件，需要通过 javac xxx.java 编译它并通过 java 类名运行。下面举个简单的例子： //save by .java only class A{ public static void main(String args[]){ System.out.println("Hello java"); } } //compile by javac .java ... 完整答案

不是。完整答案

传递的值应该是空的，不是null。完整答案

程序可以正确编译和运行，因为说明符的顺序在 Java 中并不重要。完整答案

局部变量没有初始化为任何默认值，既不是原语也不是对象引用。完整答案

在 Java 中，访问说明符是用于定义方法、类或变量的访问范围的关键字。在 Java 中，下面给出了四个访问说明符。 public 定义为公共的类、方法或变量可以被任何类或方法访问。protected 可以被同一个包的类访问，也可以被这个类的子类访问，也可以在同一个类内访问。default 只能在包中访问。默认情况下，所有类、方法和变量都具有默认范围。private 定义私有类、方法或变量只能在该类中访问。完整答案

定义为静态的方法或变量在类的所有对象之间共享。静态是类的一部分，而不是对象的一部分。静态变量存储在类区域中，我们不需要创建对象来访问这些变量。因此，在需要定义类的所有对象共有的变量或方法的情况下使用静态。例如，在模拟学院学生集合的类中，学院名称是所有学生的共同属性。因此，学院名称可以被定义为静态。完整答案

在 Java 中定义包有很多优点：包避免了名称冲突。包提供更容易的访问控制。还可以拥有在外部不可见并由包使用的隐藏类。更容易找到相关的类。完整答案

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

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

上面 Java 程序的输出结果是： 30Yiibai Yiibai1020 解释说明：在第一种情况下，10 和 20 被视为数字并相加为 30。然后，它们的和 30 被视为字符串并与字符串 “Yiibai” 连接。因此，输出将是：”30Yiibai”。在第二种情况下，字符串 Yiibai 与 10 连接成为字符串 Yiibai10，然后将其与 20 连接成为：”Yiibai1020”。完整答案

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

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

上述代码的输出将是： 200Yiibai Yiibai200 在第一种情况下，首先将数字 10 和 20 相乘，然后将结果 200 视为字符串并与字符串 Yiibai 连接以产生输出 200Yiibai。在第二种情况下，数字 10 和 20 将首先相乘为 200，因为乘法的优先级高于加法。结果 200 将被视为字符串并与字符串 Yiibai 连接以生成作为 Yiibai200 的输出。完整答案

23、以下 Java 程序的输出是什么？

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

上面的代码将给出编译时错误，因为 for 循环在第二部分需要一个布尔值，而提供了一个整数值，即 0。完整答案

它是一种基于对象的编程范式，对象具有在其所属的类中定义的数据和方法。面向对象范式旨在结合模块化和可重用性的优点。对象是类的实例，它们相互交互以设计应用程序和程序。面向对象范式有以下特点：在程序设计中遵循自下而上的方法。使用对对象数据进行操作的方法来关注数据包括像封装和抽象这样的概念，它向用户隐藏复杂性并仅显示功能。实现实时方法，如继承、抽象等。面向对象范式的示例有：C++、Simula、Smalltalk、Python、C# 等。完整答案

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

面向对象语言和基于对象的语言有以下基本区别：面向对象的语言遵循 OOP 的所有概念，而基于对象的语言并不遵循 OOP 的所有概念，如继承和多态。面向对象的语言没有内置对象，而基于对象的语言有内置对象，例如 JavaScript 有 window 对象。面向对象编程的示例有 Java、C#、Smalltalk 等，而基于对象的语言示例有 JavaScript、VBScript 等。完整答案

在 Java 中，所有对象引用都初始化为 null。完整答案

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

根据构造函数中传递的参数，Java 中有两种类型的构造函数：默认构造函数：默认构造函数是不接受任何值的构造函数。默认构造函数主要用于用默认值初始化实例变量。它还可以用于在对象创建上执行一些有用的任务。如果类中没有定义构造函数，则编译器会隐式调用默认构造函数。参数化构造函数：参数化构造函数是可以用给定值初始化实例变量的构造函数。换句话说，接受参数的构造函数称为参数化构造函数。完整答案

默认构造函数的目的是为对象分配默认值。如果类中没有构造函数，java 编译器会隐式创建默认构造函数。 class Student3 { int id; String name; void display() { System.out.println(id + " " + name); } public static void main(String args[]) { Stu... 完整答案

是的，构造函数隐式返回类的当前实例(不能在构造函数中使用显式返回类型)。完整答案

不，构造函数不是继承的。完整答案

不可以。构造函数不能是最终(final)的。完整答案

是的，可以通过更改构造函数接受的参数数量或更改参数的数据类型来重载构造函数。考虑以下示例： 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... 完整答案

java中没有复制构造函数。但是，可以将值从一个对象复制到另一个对象，就像 C++ 中的复制构造函数一样。在 java 中有很多方法可以将一个对象的值复制到另一个对象中：通过构造函数；通过将一个对象的值分配给另一个对象；通过 Object 类的 clone() 方法；在此示例中，将使用 java 构造函数将一个对象的值复制到另一个对象中。 //Java program to initialize the values from one object to another class... 完整答案

构造函数和方法之间有很多区别。它们的区别下面给出 - Java 构造函数 Java 方法构造函数用于初始化对象的状态。方法用于公开对象的行为。构造函数不能有返回类型。方法必须有返回类型。构造函数被隐式调用。方法被显式调用。如果类中没有任何构造函数，Java 编译器会提供默认构造函数。在任何情况下，编译器都不会提供该方法。构造函数名称必须与类名称相同。方法名可能与类名相同，也可能不同。完整答案

37、以下 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 的数据类型，即 byte 被提升为 int，并调用具有两个整数参数的第一个参数化构造函数。完整答案

38、以下 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，因为类中没有构造函数。完整答案

39、以下 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);  
    }  
}

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

静态变量用于引用所有对象的公共属性(每个对象不是唯一的)，例如，员工的公司名称、学生的大学名称等。静态变量在课堂区域中只获取一次内存类加载时间。使用静态变量可以让您的程序更节省内存(它可以节省内存)。静态变量属于类而不是对象。 //Program of static variable class Student8 { int rollno; String name; static String college = "ITS"; Stu... 完整答案

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

静态方法有两个主要限制：静态方法不能使用非静态数据成员或直接调用非静态方法。this 和 super 不能在静态上下文中使用，因为它们是非静态的。完整答案

因为运行是直接可以调用静态方法。如果我们将 main() 方法设为非静态，JVM 将不得不先创建它的对象，然后调用 main() 方法，这将导致额外的内存分配。完整答案

不能覆盖静态方法。完整答案

静态块用于初始化静态数据成员。它在类加载时在 main 方法之前执行。示例： package com.yiibai.demo; class YBA { static { System.out.println("static block is invoked"); } public static void main(String args[]) { System.out.println("Hello ma... 完整答案

不能，在 JDK 1.7 之前使用静态块是可能的。从 JDK 1.7 开始，这是不可能的。完整答案

程序编译。但是，在运行时，它会引发错误 “NoSuchMethodError”。完整答案

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

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

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

是的，可以在抽象方法中声明静态变量和方法。众所周知，不需要使对象访问静态上下文，因此，可以通过使用抽象类的名称来访问抽象类内部声明的静态上下文。考虑以下示例： abstract class Test { static int i = 102; static void TestMethod() { System.out.println("hi !! I am good !!"); } } publ... 完整答案

this关键字是一个引用变量，它引用当前对象。 this关键字在 Java 中有多种用途。它可以用来引用当前类的属性，例如实例方法、变量、构造函数等。它也可以作为参数传递给方法或构造函数。它也可以作为当前类实例从方法中返回。完整答案

this关键字有以下用途： this可用于引用当前类实例变量。this可用于调用当前类方法(隐式)。this() 可用于调用当前类的构造函数。this可以作为方法调用中的参数传递。this可以在构造函数调用中作为参数传递。this可用于从方法返回当前类实例。完整答案

不能。this不能分配给任何值，因为它始终指向当前类对象，并且this是 Java 中的最终引用。但是，如果我们尝试这样做，则会显示编译器错误。考虑以下示例： public class Test { public Test() { this = null; System.out.println("Test class constructor called"); } public ... 完整答案

是的，可以使用 this 关键字来引用静态成员，因为this只是引用当前类对象的引用变量。通过对象访问静态变量是不必要的，因此使用 this 来引用静态成员并不是最佳实践。考虑以下示例。 public class Test { static int i = 10; public Test () { System.out.println(this.i); } public static void ma... 完整答案

构造函数链接使我们能够从该类的另一个构造函数中调用一个构造函数，该构造函数与当前类对象有关。可以使用this关键字在同一个类中执行构造函数链接。考虑以下示例，该示例说明了我们如何使用 this 关键字来实现构造函数链接。 public class Employee { int id,age; String name, address; public Employee (int age) { this.age = age... 完整答案

众所周知，this 指的是当前的类对象，因此它必须与当前的类对象相似。但是，将 this 传递给方法而不是当前的类对象有两个主要优点。这是一个final变量。因此，这不能分配给任何新值，而当前类对象可能不是最终的并且可以更改。这可以在同步块中使用。完整答案

继承是一种机制，通过该机制一个对象获取另一个类的另一个对象的所有属性和行为。它用于代码可重用性和方法覆盖。 Java 中继承背后的想法是，可以创建基于现有类的新类。从现有类继承时，可以重用父类的方法和字段。此外，还可以在当前类中添加新方法和字段。继承表示 IS-A 关系，也称为父子关系。 Java中有五种继承类型：单级继承多级继承多重继承分层继承混合继承 Java 中不支持通过类进行多重继承。完整答案

下面给出了在 Java 中使用继承的各种优点：继承提供代码可重用性。派生类不需要重新定义基类的方法，除非它需要提供方法的具体实现。不使用继承就无法实现运行时多态性。可以使用实时对象模拟类的继承，这使得 OOP 更加真实。继承提供数据隐藏。基类可以通过将其设为私有来隐藏派生类的一些数据。没有继承就无法实现方法覆盖。通过方法覆盖，可以给出基类包含的一些基本方法的具体实现。完整答案

对象类是 Java 中所有其他类的超类。完整答案

为了降低复杂度和简化语言，java 中不支持多重继承。考虑一个场景，其中 A、B 和 C 是三个类。 C 类继承 A 和 B 类。如果 A 类和 B 类有相同的方法，并且从子类对象中调用它，那么调用 A 类或 B 类的方法就会有歧义。由于编译时错误优于运行时错误，如果继承 2 个类，Java 会呈现编译时错误。所以无论有相同的方法还是不同的方法，都会出现编译时错误。 package com.yiibai.demo; class A { void msg() { ... 完整答案

聚合可以定义为两个类之间的关系，其中聚合类包含对其拥有的类的引用。聚合最好描述为具有关系。例如，具有诸如年龄、姓名和薪水等各种字段的聚合类 Employee 还包含具有诸如 Address-Line 1、City、State 和 pin-code 等各种字段的 Address 类的对象。换句话说， Employee(类)有一个 Address 类的对象。考虑以下示例：文件：Address.java package com.yiibai.demo; public class Address... 完整答案

在其他类中保存类的引用称为组合。当一个对象包含另一个对象时，如果所包含的对象没有容器对象的存在就不能存在，则称为组合。换句话说，可以说组合是聚合的特例，它代表了两个对象之间更强的关系。示例：一个班级包含学生。没有班级，学生就无法存在。班级和学生之间存在着组合。完整答案

聚合代表弱关系，组合代表强关系。例如，自行车有一个指示器(聚合)，自行车有一个引擎(组合)。完整答案

指针是一个指向内存地址的变量。它们没有在 Java 中使用，因为它们不安全(不安全)并且难以理解。完整答案

Java 中的 super 关键字是一个引用变量，用于引用直接父类对象。每当创建子类的实例时，都会隐式创建父类的实例，实例由super引用变量引用。如果没有 super 或 this，编译器会在类构造函数中隐式调用 super()。示例： package com.yiibai.demo; class Animal { Animal() { System.out.println("animal is created"); } } cla... 完整答案

参考以下实现代码： 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 Employ... 完整答案

super关键字有以下用途： super 可用于引用直接父类实例变量。super 可用于调用直接父类方法。super() 可用于调用直接父类构造函数。完整答案

this 和 super 关键字有以下区别： super 关键字始终指向父类上下文，而 this 关键字始终指向当前类上下文。super 关键字主要用于在派生类构造函数中初始化基类变量，而 this 关键字主要用于在传入类构造函数时区分局部变量和实例变量。super 和 this 必须是构造函数中的第一条语句，否则编译器会抛出错误。完整答案

70、以下 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 类构造函数。完整答案

不能。因为 this() 和 super() 必须是类构造函数中的第一条语句。例子： public class Test{ Test() { super(); this(); System.out.println("Test class object is created"); } public static void main(String []arg... 完整答案

对象克隆用于创建对象的精确副本。 Object 类的 clone() 方法用于克隆对象。 java.lang.Cloneable 接口必须由要创建其对象克隆的类实现。如果不实现 Cloneable 接口，clone() 方法会生成 CloneNotSupportedException。 protected Object clone() throws CloneNotSupportedException 完整答案

方法重载是一种多态技术，它允许我们创建多个具有相同名称但不同签名的方法。可以通过两种方式实现方法重载：通过更改参数的数量。通过更改参数的数据类型。方法重载增加了程序的可读性，执行方法重载以快速找出程序。完整答案

在 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[]... 完整答案

不能。不能通过仅对它们应用 static 关键字来重载方法(参数和类型的数量相同)。考虑以下示例： public class Animal { void consume(int a) { System.out.println(a+" consumed!!"); } static void consume(int a) { System.out.println("... 完整答案

可以。通过使用方法重载，可以在 Java 程序中拥有任意数量的main方法。完整答案

类型提升是方法重载，如果没有找到精确匹配，可以隐式地将一种数据类型提升为另一种数据类型。如上图所示，byte可以提升为 short、int、long、float 或 double。 short类型可以提升为 int、long、float 或 double。 char 数据类型可以提升为 int、long、float 或 double 等。考虑以下示例： class OverloadingCalculation1 { void sum(int a, long b) { ... 完整答案

78、以下 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 解... 完整答案

如果子类提供了其父类已经提供的方法的特定实现，则称为方法覆盖。它用于运行时多态性和实现接口方法。方法覆盖的规则：方法必须与父类中的名称相同。方法必须具有与父类中相同的签名。两个类之间必须具有 IS-A 关系。完整答案

不能，不能覆盖静态方法，因为它们是类的一部分，而不是对象。完整答案

这是因为静态方法是类的一部分，它与类绑定，而实例方法与对象绑定，静态获取类区内存，实例获取堆内存。完整答案

可以。完整答案

方法重载和覆盖的区别如下：方法重载方法重载方法重载增加了程序的可读性。方法覆盖提供其超类已经提供的方法的具体实现。方法重载发生在类中。方法覆盖发生在两个具有 IS-A 关系的类中。方法重载参数必须不同。方法覆盖参数必须相同。完整答案

不能。不能覆盖私有方法，因为私有方法的范围仅限于类，不能在类之外访问它们。完整答案

是的。可以改变子类中被覆盖方法的范围。但是，必须注意：不能降低该方法的可访问性。在更改方法的可访问性时必须注意以下几点。可以将private更改为protected、public或default。protected的可以更改为public或default。default可以更改为public。public永远是public。完整答案

可以。可以修改超类方法的 throws 子句，同时在子类中重写它。但是，在处理异常时需要遵循一些规则。如果超类方法没有声明异常，子类重写的方法不能声明已检查异常，但可以声明未检查异常。如果超类方法声明异常，子类重写方法可以声明相同、子类异常或无异常但不能声明父异常。完整答案

87、以下 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 类型作为参数。在方法调用中，整数被传递。完整答案

有。Java 中的所有函数默认都是虚拟的。完整答案

从 java5 开始，如果子类覆盖方法的返回类型是子类类型，则可以通过更改返回类型来覆盖任何方法。它被称为协变返回类型。协变返回类型指定返回类型可以在与子类相同的方向上变化。示例： class A { A get() { return this; } void message() { System.out.println("A => welcome to covariant return type"); ... 完整答案

90、以下 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 ... 解释：Base 类的方法 baseMethod() 在 Derived 类中被覆盖。在 Test 类中，引用变量 b(类型为 Base 类)指的是 Derived 类的实例。在这里，在类 Base 和 Derived 之间实现了运行时多态性。在编译时，检查 Base 类中方法 baseMethod 的存在，如果存在则程序编译，否则将显示编译器错误。在这种情况下，baseMethod 存在于 Base 类中；因此，... 完整答案

在 Java 中，final 变量用于限制用户对其进行更新。如果初始化 final 变量，就不能改变它的值。换句话说，可以说 final 变量一旦分配了一个值，之后就永远无法更改。 final 没有赋值的变量只能通过类构造函数赋值。 class Bike9 { final int speedlimit = 90;//final variable void run() { speedlimit = 400; // 不能再赋值 } pu... 完整答案

如果将任何方法更改为final方法，就不能覆盖它。示例： class Bike { final void run() { System.out.println("running"); } } class Honda extends Bike { // 错误：不能重写 final 方法 void run() { System.out.println("running safely with 100... 完整答案

如果将一个类设为 final，就不能将它继承到任何子类中。示例： final class Bike { } // 错误用法：不能继承 final 类 class Honda1 extends Bike { void run() { System.out.println("running safely with 100kmph"); } public static void main(String args[]) { ... 完整答案

在声明时未初始化的final变量称为final空变量。不能直接初始化final空变量。我们必须使用类构造函数来初始化它。当用户有一些数据不能被其他人更改时，它很有用，例如 PAN 号码。参考以下示例： class Student { int id; String name; final String PAN_CARD_NUMBER; Student(){ PAN_CARD_NUMBER = "123456"; }... 完整答案

是的，如果它不是静态的，可以在构造函数中初始化它。如果是静态空白最终变量，只能在静态块中初始化。完整答案

可以。可以将 main 方法声明为 public static final void main(String[] args){}。完整答案

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

class NewClass {

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

运行结果为：20 解释：因为 i 是空的最终变量，它只能初始化一次。已将其初始化为 20。因此，将打印 20。完整答案

98、以下 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()方法是最终的；因此它不能在子类中被覆盖。完整答案

构造函数永远不能被声明为 final，因为这样做的话永远不会被继承。构造函数不是普通的方法；因此，将构造函数声明为 final 是没有意义的。但是，如果您尝试这样做，编译器将抛出错误。完整答案

不能。不能将接口声明为 final，因为该接口必须由某个类实现才能提供其定义。因此，使接口最终化是没有意义的。但是，如果您尝试这样做，编译器将显示错误。完整答案

final方法和abstract方法的主要区别在于abstract方法不能是final的，因为需要在子类中重写abstract方法来给出它的定义。完整答案

编译时多态性和运行时多态性之间有以下区别：编号编译时多态性运行时多态性 1 在编译时多态性中，对方法的调用在编译时被解析。在运行时多态中，对重写方法的调用在运行时被解析。 2 它也称为静态绑定、早期绑定或重载。它也称为动态绑定、后期绑定、覆盖或动态方法分派。 3 重载是一种实现编译时多态性的方法，可以定义多个具有不同签名的方法或构造函数。重写是一种实现运行时多态性的方法，可以在派生类中重新定义一些特定的方法或变量。通过使用覆盖，可以对派生类中的基类属性进行一些具... 完整答案

运行时多态性或动态方法分派是在运行时而不是在编译时解决对覆盖方法的调用的过程。在这个过程中，通过超类的引用变量调用被覆盖的方法。要调用的方法的确定是基于引用变量所引用的对象。示例： class Bike { void run() { System.out.println("running"); } } class Splendor extends Bike { void run() { System.out.p... 完整答案

不能。因为方法覆盖用于实现运行时多态性，并且数据成员不能被覆盖。可以覆盖成员函数，但不能覆盖数据成员。参考下面给出的示例： class Bike { int speedlimit = 90; } class Honda3 extends Bike { int speedlimit = 150; public static void main(String args[]) { Bike obj = new Honda3(); Sys... 完整答案

在静态绑定的情况下，对象的类型是在编译时确定的，而在动态绑定中，对象的类型是在运行时确定的。静态绑定 class Dog { private void eat() { System.out.println("dog is eating..."); } public static void main(String args[]) { Dog d1 = new Dog(); d1.eat(); ... 完整答案

106、以下 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 中的 instanceof 也称为类型比较运算符，因为它将实例与类型进行比较。它返回真或假。如果将 instanceof 运算符应用于任何具有null值的变量，它会返回 false。考虑以下示例： class Simple1 { public static void main(String args[]) { Simple1 s = new Simple1(); System.out.println(s instanceof Simple1... 完整答案

抽象是隐藏实现细节并仅向用户显示功能的过程。它仅向用户显示基本信息并隐藏内部信息，例如，在键入文本并发送消息然后发送 SMS。我们并不了解有关消息传递的内部处理。抽象使您能够专注于对象的作用，而不是它的作用方式。抽象让我们专注于对象的作用，而不是它如何做。在Java中，有两种方法可以实现抽象：抽象类接口完整答案

抽象隐藏了实现细节，而封装将代码和数据包装到一个单元中。完整答案

声明为抽象的类称为抽象类。它需要扩展并实现其方法。它不能被实例化，抽象类可以有抽象方法、非抽象方法、构造函数和静态方法。它还可以有 final 方法，这将强制子类不更改方法的主体。考虑以下示例： abstract class Bike { abstract void run(); } class Honda4 extends Bike { void run() { System.out.println("running safely"... 完整答案

不能。如果类中有抽象方法，则该类必须是抽象的。完整答案

112、下面的程序写对了吗？如果对，那么程序的输出是什么？

abstract class Calculate  
{  
    abstract int multiply(int a, int b);  
}  

public class NewClass  
{  
    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 的定义。程序的输出结果是： 384 完整答案

不能。因为需要重写抽象方法来提供它的实现，但是不能重写final方法。完整答案

不能。即使抽象类包含构造函数并且其所有方法都已实现，也永远无法实例化它。完整答案

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

不可以，因为接口的方法默认是抽象的，不能同时使用静态和抽象。完整答案

不能。因为一个接口需要由另一个类实现，如果它是final，则不能由任何类实现。完整答案

标记接口可以定义为没有数据成员和成员函数的接口。例如，Serializable、Cloneable 都是标记接口。标记接口可以声明如下： public interface Serializable{ } 完整答案

抽象类和接口的区别如下：抽象类接口抽象类可以有一个方法体(非抽象方法) 接口只有抽象方法抽象类可以有实例变量接口不能有实例变量抽象类可以有构造函数接口不能有构造函数抽象类可以有静态方法接口不能有静态方法抽象类可以扩展可以实现多个接口抽象类可以提供接口的实现接口不能提供抽象类的实现使用 abstract 关键字用于声明一个抽象类 interface 关键字用于声明接口一个抽象类可以扩展另一个 Java 类并实现多个 Java ... 完整答案

不能。它们是隐式公开的。完整答案

当对象实现被引用的接口时，对象引用可以转换为接口引用。完整答案

通过将所有字段设为private，可以将类设为只读。只读类将只有 getter 方法，将类的private属性返回给 main 方法。无法修改此属性，因为该类中没有可用的 setter 方法。考虑以下示例: //A Java class which has only getter methods. public class Student { //private data member private String college = "AKG... 完整答案

通过将所有字段设为private，可以将类设为只写。只写类将只有 setter 方法，用于设置从 main 方法传递给私有字段的值。我们无法读取该类的属性，因为该类中没有 getter 方法。考虑以下示例： //A Java class which has only setter methods. public class Student { //private data member private String college; //getter meth... 完整答案

Java中的封装有以下优点: 通过仅提供 setter 或 getter 方法，可以使类只读或只写。它为提供对数据的控制。假设想设置 id 的值应该大于 100，可以在 setter 方法中编写逻辑。它是一种在Java中实现数据隐藏的方法，因为其他类将无法通过私有数据成员访问数据。封装类很容易测试。因此，它更适合单元测试。标准 IDE 提供了生成 getter 和 setter 的工具。因此，在 Java 中创建封装类既简单又快速。完整答案

包是一组相似类型的类、接口和子包。它提供访问保护并消除命名冲突。 Java中的包可以分为两种形式，内置包和用户自定义包。有很多内置的包，例如：lang、awt、javax、swing、net、io、util、sql 等。考虑以下示例以在 Java 中创建包。 //save as Simple.java package mypack; public class Simple{ public static void main(String args[]){ System... 完整答案

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

如果使用的是 Eclipse、NetBeans、MyEclipse 等编程 IDE，请单击 file->new->project，eclipse 会要求输入包的名称。它将创建包含各种目录(如 src 等)的项目包。如果使用记事本等编辑器进行 java 编程，请使用以下步骤创建包。定义一个包 package_name。创建名为 class_name 的类，并使用 your_class_name.java 保存此文件。现在通过在终端上运行以下命令来编译文件。javac -d . ... 完整答案

有两种方法可以访问一个类中的类: 通过使用完全限定名：要访问不同包中的类，必须使用该类的完全限定名，或者必须导入包含该类的包。通过使用相对路径，可以使用与包含类的包相关的类的路径。它可以是相同的或子包。完整答案

不用。默认情况下它是由 JVM 内部加载的。完整答案

可以多次导入同一个包或同一个类。编译器和 JVM 都没有抱怨。但是，无论导入同一个类多少次，JVM 都只会在内部加载该类一次。完整答案

通过静态导入，可以直接访问一个类的静态成员，不需要用类名来限定它。示例代码： import static java.lang.System.*; class StaticImportExample{ public static void main(String args[]){ out.println("Hello");//Now no need of System.out out.println("Java"); ... 完整答案

主要有两种类型的异常：已检查和未检查。在这里，错误被认为是未经检查的异常。根据 Oracle 的说法，有以下三种类型的异常：已检查异常：已检查异常是在编译时检查的异常。例如，SQLException、ClassNotFoundException 等。未经检查的异常：未经检查的异常是在运行时处理的异常，因为它们无法在编译时进行检查。例如：ArithmaticException、NullPointerException、ArrayIndexOutOfBoundsException 等。错... 完整答案

异常处理是一种用于处理运行时错误的机制。它主要用于处理已检查的异常。异常处理维护程序的正常流程。主要有两种类型的异常：已检查和未检查。在这里，错误被认为是未经检查的异常。完整答案

java.lang.Throwable 类是Java Exception 层次结构的根类，它由两个子类继承：Exception 和Error。 Java Exception 类的层次结构如下：完整答案

检查异常除了 RuntimeException 和 Error 之外，扩展 Throwable 类的类称为检查异常，例如 IOException、SQLException 等。检查异常在编译时检查。未经检查的异常扩展 RuntimeException 的类称为未经检查的异常，例如 ArithmeticException、NullPointerException 等。未经检查的异常在编译时不检查。完整答案

Throwable 类是 Error 和 Exception 的基类。完整答案

不一定每个 try 块后面都必须跟一个 catch 块。它后面应该跟一个 catch 块或 finally 块。所以任何可能抛出的异常都应该在方法的 throws 子句中声明。考虑以下示例： public class Main { public static void main(String[] args) { try { int a = 1; System.out.println(a / 0); }... 完整答案

138、以下 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 之后使用。由于Except... 完整答案

finally块用于执行程序的重要代码。无论是否处理异常都会执行。换句话说 finally 块是始终执行的块。 finally 块跟在 try 或 catch 块之后。如果不处理异常，则在终止程序之前，JVM 会运行 finally 块(如果有)。 finally 块主要用于放置关闭文件或关闭连接等清理代码。在这里，我们必须知道，对于每个 try 块，可以有零个或多个 catch 块，但只有一个 finally 块。如果程序退出(通过调用 System.exit() 或通过导致导致进程... 完整答案

可以。根据 finally 块的定义，它后面必须跟一个 try 或 catch 块，因此，可以用 try 块代替 catch。完整答案

如果程序退出(通过调用 System.exit() 或通过导致导致进程中止的致命错误)，将不会执行 finally 块。完整答案

throw 和 throws 的区别如下： throw关键字 throws关键字 throw 关键字用于显式抛出异常。 throws 关键字用于声明异常。已检查的异常不能仅通过 throw 传播。检查的异常可以通过 throws 传播 throw 关键字后跟一个实例。 throws 关键字后面是类。在方法中使用 throw 关键字。 throws 关键字与方法签名一起使用。不能抛出多个异常可以声明多个异常，例如，public void method() t... 完整答案

143、以下 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 中，... 完整答案

144、以下 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 的对象是从 catch 块中捕获的 try 块中抛出的。 Calculation 类的 add() 使用该类的对象调用整数值 10 和 20。因此，总和 30 被打印出来。 Main类的对象只有在对象的类型是可抛出的情况下才能抛出。为此，需要扩展 throwable 类。完整答案

可以。完整答案

可以，但只有未检查的异常未检查。完整答案

异常首先从栈顶抛出，如果没有被捕获，则将调用栈下降到前一个方法，如果没有捕获到，异常再次下降到前一个方法，依此类推，直到它们被捕获或直到它们到达调用堆栈的最底部。此过程称为异常传播。默认情况下，检查的异常不会传播。 class TestExceptionPropagation1 { void m() { int data = 50 / 0; } void n() { m(); } voi... 完整答案

148、以下 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() 处理。正如我们所知，... 完整答案

149、以下 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 块中，a 再次增加 10 为 30。在第二个 try 块中，a 乘以 10 为 300。第二个 try 块抛出异常，该异常被与 try 块关联的 catch 块捕获。 catch 块再次更改 a 的值，将其减 10 以使其变为 290。因此 ad... 完整答案

字符串池是堆内存中保留的空间，可用于存储字符串。使用字符串池的主要优点是每当创建一个字符串字面量时； JVM首先检查“字符串常量池”。如果该字符串已存在于池中，则返回对池实例的引用。如果该字符串在池中不存在，则创建一个新的字符串实例并将其放置在池中。因此，它通过避免重复来节省内存。完整答案

不可变的简单含义是不可修改或不可改变。在 Java 中，String 是不可变的，即一旦创建了字符串对象，它的值就不能改变。请参考以下示例以更好地理解。 class Testimmutablestring { public static void main(String args[]) { String s = "Yii"; s.concat(" bai.com");//concat() method app... 完整答案

因为Java使用了字符串字面量的概念。假设有五个引用变量，都引用一个对象“yiibai”。如果一个引用变量改变了对象的值，它将受到所有引用变量的影响。这就是为什么字符串对象在 java 中是不可变的。完整答案

1、字符串字面量Java 字符串文字是使用双引号创建的。例如： String s="welcome"; 每次创建字符串文字时，JVM 首先检查“字符串常量池”。如果该字符串已存在于池中，则返回对池实例的引用。如果该字符串在池中不存在，则创建一个新的字符串实例并将其放置在池中。字符串对象存储在称为字符串常量池的特殊内存区域例如： String s1="Welcome"; String s2="Welcome";//It doe... 完整答案

154、下面的代码将创建多少个对象？

class Main {
    public static void main(String args[]) {
        String s1 = "Yiibai";
        String s2 = "Yiibai";
        String s3 = "yiibai.com";
        System.out.println(s1.hashCode());//will print Sachin because strings are immutable objects  
        System.out.println(s2.hashCode());
        System.out.println(s3.hashCode());
    }
}

使用上述代码会创建两个对象，因为 Java 中的字符串是不可变的。运行结果： -1646777807 -1646777807 -844482524 完整答案

使 Java 内存效率更高(因为如果字符串常量池中已经存在新对象，则不会创建新对象)。完整答案

两个对象：一个在字符串常量池中，另一个在非池(堆)中。完整答案

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

public class Main {

    public static void main(String args[]) {
        String a = new String("Yiibai is a good study place");
        String b = "Yiibai is a good study place";
        if (a == b) {
            System.out.println("a == b");
        }
        if (a.equals(b)) {
            System.out.println("a equals b");
        }
    }
}

运行结果： a equals b 解释：运算符 == 还会检查两个字符串对象的引用是否相等。尽管两个字符串都包含相同的内容，但它们的引用并不相等，因为它们都是通过不同的方式(构造函数和字符串文字)创建的，因此 a == b 是不相等的。另一方面，equal() 方法总是检查内容。由于它们的内容相等，因此打印 a equals b 。完整答案

158、以下 Java 程序的输出是什么？

public class Main {

    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()方法从字符串池返回字符串对象引用。在这种情况下，s1 是使用字符串文字创建的，而 s2 是使用字符串池创建的。但是 s2 变成了 s1 的引用，所以操作符 == 返回 true。完整答案

String 和 StringBuffer 的区别如下表所示：编号 String StringBuffer 1 String 类是不可变的 StringBuffer 类是可变的 2 当连接太多字符串时，字符串很慢并且消耗更多内存，因为每次它都会创建一个新实例。当可以捕获字符串时，StringBuffer 速度很快并且消耗的内存更少。 3 String 类重写了 Object 类的 equals() 方法。所以可以通过 equals() 方法比较两个字符串的内容。 St... 完整答案

下面列出了 StringBuffer 和 StringBuilder 之间的区别：编号 StringBuffer StringBuilder 1 StringBuffer是同步的，即线程安全的。两个线程不能同时调用 StringBuffer 的方法。 StringBuilder 是非同步的，即不是线程安全的。两个线程可以同时调用 StringBuilder 的方法。 2 StringBuffer 比 StringBuilder 效率低。 StringBuilder 比 Str... 完整答案

可以通过定义一个所有成员都为 final 的 final 类来创建一个不可变类。考虑以下示例： public final class Employee { final String pancardNumber; public Employee(String pancardNumber) { this.pancardNumber = pancardNumber; } public String getPancardNumber() { ... 完整答案

toString()方法返回对象的字符串表示形式。如果打印任何对象，java 编译器会在内部调用该对象的 toString() 方法。因此，重写 toString() 方法，返回所需的输出，它可以是对象的状态等，具体取决于实现。通过重写 Object 类的 toString() 方法，可以返回对象的值，所以不需要写太多代码。考虑以下示例： class Student { int rollno; String name; String city; Stud... 完整答案

字符串留在字符串池中，直到垃圾被收集。如果将密码存储为字符串，它会在内存中保留更长的时间，任何拥有内存转储的人都可以将密码提取为明文。另一方面，使用 CharArray 允许在完成密码后将其设置为空白。它通过使能够控制内存来避免字符串的安全威胁。完整答案

程序实现参考： 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 wo... 完整答案

java.util.regex 包中存在以下类和接口。 MatchResult接口Matcher类Pattern类PatternSyntaxException类完整答案

元字符对正则表达式引擎具有特殊意义。元字符是 ^，$，.，*，+等。正则表达式引擎不会将它们视为正则字符。为了使正则表达式引擎将元字符视为普通字符，需要使用反斜杠对元字符进行转义。完整答案

上述条件的正则表达式将是： ^[a-zA-Z][a-zA-Z0-9]{8,19} 其中 ^ 表示正则表达式的开始，[a-zA-Z] 表示第一个字符必须是字母。[a-zA-Z0-9] 表示字母数字字符。{8,19} 表示密码长度必须在 8 到 20 之间。完整答案

168、以下 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 内部类有三个优点：嵌套类代表一种特殊类型的关系，它可以访问外部类的所有成员(数据成员和方法)，包括私有的。嵌套类用于开发更具可读性和可维护性的代码，因为它在逻辑上仅将类和接口分组在一个位置。代码优化：它需要更少的代码来编写。完整答案

嵌套类可以定义为在另一个类或接口中定义的类。使用嵌套类将类和接口逻辑分组在一个地方，这样它就更具可读性和可维护性。嵌套类可以访问外部类的所有数据成员，包括私有数据成员和方法。嵌套类的语法定义如下： class Java_Outer_class { //code class Java_Nested_class { //code } } 嵌套类有两种类型：静态嵌套类和非静态嵌套类。非静态嵌套类也可以称为内部类。完整答案

使用内部类有以下主要缺点：内部类增加了开发人员使用的类的总数，因此增加了 JVM 的工作量，因为它必须对那些额外的类执行一些常规操作，这会导致性能下降。与顶级类相比，IDE 对内部类的支持较少，因此在使用内部类时会惹恼开发人员。完整答案

Java中主要使用了三种内部类：成员内部类：在类和外部方法中创建的类。匿名内部类：为实现接口或扩展类而创建的类，它的名称由 java 编译器决定。局部内部类：在方法中创建的类。完整答案

是的，内部类是非静态嵌套类。换句话说，可以说内部类是嵌套类的一部分。完整答案

不能。如果要在局部内部类中访问局部变量，它必须是常量。完整答案

175、在下面的程序中编译 OuterClass 时创建了多少个类文件？


public class Person {

    String name, age, address;

    class Employee {

        float salary = 10000;
    }

    class BusinessMen {

        final String gstin = "geekview$";
    }

    public static void main(String args[]) {
        Person p = new Person();
    }
}

编译上面代码将创建 3 个类文件，名称分别为：Person.class、Person$BusinessMen.class 和 Person$Employee.class。完整答案

匿名内部类是在表达式中自动声明和实例化的类。不能对它们应用不同的访问修饰符。匿名类不能是静态的，也不能定义任何静态字段、方法或类。换句话说，它是一个没有名称的类，并且只能有一个由其定义创建的对象。考虑以下示例： abstract class Person { abstract void eat(); } class TestAnonymousInner { public static void main(String args[]) { Person ... 完整答案

在接口或类中声明的接口称为嵌套接口。默认情况下它是静态的。嵌套接口用于对相关接口进行分组，以便于维护。外部接口或类必须引用嵌套接口。不能直接访问。如果嵌套接口在接口内声明，则它必须是公共的，但如果在类内声明，它可以具有任何访问修饰符。嵌套接口的语法如下： interface interface_name { //... interface nested_interface_name { //... } } 完整答案

可以。可以在类中定义接口。它被称为嵌套接口。完整答案

可以。它们隐含地是静态的。完整答案

垃圾收集是回收未使用的运行时对象的过程。它用于内存管理。换句话说，它是从内存中删除未使用的对象以释放空间并使该空间可用于Java虚拟机的过程。由于垃圾回收，java 将 0 作为输出提供给未设置值的变量，即该变量已定义但未初始化。类似在 C 语言中使用了 free() 函数，在 C++ 中使用了 delete()。在 Java 中，它是自动执行的。因此，java 提供了更好的内存管理。完整答案

gc()方法用于调用垃圾收集器进行清理处理。此方法可在 System 和 Runtime 类中找到。该函数显式地使 Java 虚拟机释放未使用对象所占用的空间，以便可以利用或重用它。请参考以下示例，以更好地理解 gc() 方法如何调用垃圾收集器。 public class TestGarbage1 { public void finalize() { System.out.println("object is garbage collected"... 完整答案

垃圾收集由 JVM 管理。当内存空间不足且内存不足时执行。可以在外部调用 System.gc() 进行垃圾收集。但是，这取决于 JVM 是否执行它。完整答案

对象不被引用有一下几种方法：通过将引用无效通过将引用分配给另一个对象通过匿名对象等 1、通过使引用无效： 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... 完整答案

finalize()方法在对象被垃圾回收之前调用。它用于执行清理处理。 JVM 的垃圾收集器只收集那些由 new 关键字创建的对象。所以如果创建了一个没有new的对象，可以使用finalize方法进行清理处理(销毁剩余的对象)。清理处理是释放所有资源、网络的过程，这些资源、网络以前使用过但不再需要。必须记住，它不是保留关键字，finalize 方法存在于对象类中，因此它在每个类中都可用，因为对象类是 java 中每个类的超类。在这里，我们必须注意，既不能保证终结，也不能保证垃圾回收。 ... 完整答案

可以。完整答案

守护线程。完整答案

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

Java Runtime 类用于与 Java 运行时环境进行交互。 Java Runtime 类提供了执行进程、调用 GC、获取总内存和空闲内存等方法。java.lang.Runtime 类的实例只有一个，可用于一个 java 应用程序。 Runtime.getRuntime() 方法返回 Runtime 类的单例实例。完整答案

通过 Runtime.getRuntime().exec(String command) 方法。参考以下示例： public class Runtime1{ public static void main(String args[])throws Exception{ Runtime.getRuntime().exec("notepad");//will open a new notepad } } 完整答案

流是从源流向目标的数据序列。它由字节组成。在 Java 中，自动创建了三个流： System.out：标准输出流System.in：标准输入流System.err：标准错误流完整答案

Reader/Writer 类层次结构是面向字符的，InputStream/OutputStream 类层次结构是面向字节的。 ByteStream 类用于执行 8 位字节的输入输出，而 CharacterStream 类用于执行 16 位 Unicode 系统的输入/输出。 ByteStream 类层次结构中有很多类，但最常用的类是 FileInputStream 和 FileOutputStream。最常用的类 CharacterStream 类层次结构是 FileReader 和 Fil... 完整答案

所有的流类可以分为两类，即ByteStream类和CharacterStream类。 ByteStream 类进一步分为 InputStream 类和 OutputStream 类。 CharacterStream 类也分为 Reader 类和 Writer 类。所有 InputStream 类的父类是 java.io.InputStream，所有输出流类的父类是 java.io.OutPutStream。类似地，对于所有的 Reader 类，最上层的类是 java.io.Reader，而对... 完整答案

Java FileOutputStream 是用于将数据写入文件的输出流。如果有一些原始值要写入文件，那么使用 FileOutputStream 类。可以通过 FileOutputStream 类编写面向字节和面向字符的数据。但是，对于面向字符的数据，最好使用 FileWriter 而不是 FileOutputStream。以下是将字节写入文件的示例。 import java.io.FileOutputStream; public class FileOutputStreamExa... 完整答案

Java BufferedOutputStream 类用于缓冲输出流。它在内部使用缓冲区来存储数据。与将数据直接写入流相比，它提高了效率。因此，它使性能快速。而 Java BufferedInputStream 类用于从流中读取信息。它在内部使用缓冲机制来使性能快速。完整答案

在 Java 中，FilePermission 类用于更改文件上设置的权限。 Java FilePermission 类包含与目录或文件相关的权限。所有权限都与路径有关。路径可以有两种类型： D:\IO\-：表示该权限与所有子目录和文件递归关联。D:\IO\*：表示该权限与该目录下除子目录外的所有目录和文件相关联。让我们看一个简单的例子，其中目录路径的权限被授予读取权限，并且该目录的文件被授予写入权限。 import java.io.*; import java.securit... 完整答案

FilterStream类用于向其他流类添加附加功能。 FilterStream 类的作用类似于从流中读取数据、对其进行过滤并将过滤后的数据传递给调用者的接口。 FilterStream 类提供了额外的功能，例如将行号添加到目标文件等。完整答案

I/O 过滤器是一个从一个流读取并写入另一个流的对象，通常在数据从一个流传递到另一个流时以某种方式更改数据。许多过滤器类允许用户使用多个输入流创建一个链。它会在多个过滤器上产生组合效果。完整答案

在 Java 中，可以通过三种方式从控制台获取输入。 1、使用 BufferedReader 类：可以通过将 System.in 包装到 InputStreamReader 并将其传递给 BufferedReader 来从控制台获取输入。当输入被缓冲时，它提供了有效的读取。考虑以下示例。 import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; p... 完整答案

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

一个类可以通过实现 Serializable 接口变成可序列化的。完整答案

如果基类旨在实现 Serializable 接口，那么防止子类的序列化是非常棘手的。但是，不能直接这样做，但是可以通过在子类中实现 writeObject() 或 readObject() 方法并从这些方法中抛出 NotSerializableException来避免序列化。参考以下示例： import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import j... 完整答案

可以的。可以通过网络传输序列化对象，因为序列化对象以字节的形式存储在内存中，可以通过网络传输。还可以将序列化的对象写入磁盘或数据库。完整答案

反序列化是从序列化状态重构对象的过程。它是序列化的逆操作。 ObjectInputStream 反序列化使用 ObjectOutputStream 写入的对象和原始数据。 import java.io.*; class Depersist { public static void main(String args[]) throws Exception { ObjectInputStream in = new ObjectInputStream(new File... 完整答案

如果将任何数据成员定义为瞬态(transient)，它将不会被序列化。通过确定transient关键字，变量的值在恢复时不需要持久化。完整答案

Externalizable接口用于将对象的状态以压缩格式写入字节流。它不是一个标记接口。完整答案

Serializable 和 Externalizable 接口的区别如下：编号 Serializable Externalizable 1 Serializable 接口没有任何方法，即它是一个标记接口。 Externalizable 接口包含的不是标记接口，它包含两个方法，即 writeExternal() 和 readExternal()。 2 用于“标记”Java 类，使这些类的对象可以获得一定的能力。 Externalizable 接口为程序员提供了对序列化逻辑的控... 完整答案

Java Socket 编程用于在不同 JRE 上运行的应用程序之间进行通信。 Java Socket 编程可以是面向连接的或无连接的。 Socket 和 ServerSocket 类用于面向连接的套接字编程和 DatagramSocket，DatagramPacket 类用于无连接的套接字编程。套接字编程中的客户端必须知道两个信息：服务器的IP地址端口号完整答案

套接字只是机器之间通信的端点。它提供了使用 TCP 连接两台计算机的连接机制。 Socket 类可用于创建套接字。完整答案

当两台计算机通过 TCP 连接时，会执行以下步骤： ServerSocket 对象由服务器实例化，它表示将建立连接的端口号。实例化 ServerSocket 对象后，服务器调用 ServerSocket 类的 accept() 方法，这使服务器等待，直到客户端尝试在给定端口上连接到服务器。同时，服务端正在等待，客户端通过实例化 Socket 类来创建一个套接字。套接字类构造函数接受服务器端口号和服务器名称。Socket 类构造函数尝试连接指定名称的服务器。如果连接建立，客户端将拥有一个可以... 完整答案

考虑以下程序，其中建立了客户端和服务器之间的连接。文件：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.accep... 完整答案

通过 InetAddress.getByName("192.18.97.39").getHostName() 其中 192.18.97.39 是 IP 地址。参考以下示例。 import java.io.*; import java.net.*; public class InetDemo { public static void main(String[] args) { try { InetAddress ip = ... 完整答案

反射是在运行时检查或修改类的运行时行为的过程。 java.lang.Class 类提供了各种可用于获取元数据、检查和更改类的运行时行为的方法。 java.lang 和 java.lang.reflect 包为 java 反射提供了类。它用于： IDE(集成开发环境)，例如：Eclipse、MyEclipse、NetBeans。调试器-测试工具等完整答案

java.lang.Class 类主要执行两个任务：提供在运行时获取类元数据的方法。提供检查和更改类的运行时行为的方法。完整答案

有三种方法可以实例化 Class 类： 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 类的实例。完整答案

javap 命令反汇编一个类文件。 javap 命令显示有关类文件中存在的字段、构造函数和方法的信息。语法： javap fully_class_name 完整答案

可以。如果类不安全，则通过更改类的运行时行为。完整答案

包装类是允许将原始类型作为对象访问的类。换句话说，可以说包装类是内置的 java 类，它允许将对象转换为基元，将基元转换为对象。将基元转换为对象的过程称为自动装箱，将对象转换为基元的过程称为拆箱。 java.lang 包中存在八个包装类，如下所示：原始类型包装类 boolean Boolean char Character byte Byte short Short int Integer long Long float Float double... 完整答案

自动装箱是将原始数据类型转换为相应的包装类对象的过程，例如，将 int 转换为 Integer。拆箱是将包装类对象转换为原始数据类型的过程。例如，Integer 到 int。拆箱和自动装箱在 Java 中自动发生。但是可以使用 valueOf() 或 xxxValue() 等方法从外部将一个转换为另一个。每当需要包装类对象并提供原始数据类型时，它都可能发生，反之亦然。将原始类型添加到集合中，如 Java 中的 ArrayList。创建参数化类的实例，例如期望 Type 的 Threa... 完整答案

220、下面的 Java 程序的输出是什么？

public class YiibaiDemo {

    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 的整数值。因此，只能在 -128 到 127 范围内创建 Integer 对象。运算符 == 对大于 127 的值不起作用；因此打印了”bye”。完整答案

对象克隆是一种创建对象精确副本的方法。 Object 类的 clone() 方法用于克隆对象。 java.lang.Cloneable 接口必须由要创建其对象克隆的类实现。如果不实现 Cloneable 接口，clone() 方法会生成 CloneNotSupportedException。 clone()方法在 Object 类中定义。 clone()方法的语法如下： protected Object clone() throws CloneNotSupportedException 完整答案

对象克隆的优点：无需编写冗长且重复的代码。只需使用带有 4 行或 5 行长的 clone() 方法的抽象类。这是复制对象的最简单和最有效的方法，尤其是当将其应用于已开发或旧项目时。只需定义一个父类，在其中实现 Cloneable，提供 clone() 方法的定义，任务就完成了。clone()方法是复制数组的最快方法。对象克隆的缺点：要使用 Object.clone() 方法，必须在代码中更改许多语法，例如实现 Cloneable 接口、定义 clone() 方法和处理 CloneNo... 完整答案

原生方法是用 Java 以外的语言实现的方法。原生方法有时也称为外来方法。完整答案

如果您在浮点变量中执行操作，Java strictfp 关键字可确保在每个平台上都获得相同的结果。精度可能因平台而异，这就是为什么 java 编程语言提供了 strictfp 关键字，以便您在每个平台上获得相同的结果。因此，现在可以更好地控制浮点运算。完整答案

System类的目的是提供对标准输入和输出等系统资源的访问。它不能被实例化。 System类提供的设施如下。标准输入错误输出流标准输出复制数组部分的实用方法加载文件和库的实用程序 Java System 类共有三个字段，即静态 printstream err、静态 inputstream in 和标准输出流。完整答案

对象克隆。完整答案

单例类是不能多次实例化的类。要使类单例，要么将其构造函数设为私有，要么使用静态 getInstance 方法。参考以下示例： class Singleton { private static Singleton single_instance = null; int i; private Singleton() { i = 90; } public static Singleton getInstance() { i... 完整答案

参考以下程序示例： class Main { public static void main(String args[]) { if (args.length > 0) { for (int i = 0; i < args.length; i++) { System.out.println(args[i]); } } } } 编译运行： > j... 完整答案

Window、Frame 和 Dialog 类使用边框布局作为它们的默认布局。完整答案

Panel 和 Applet 类使用 FlowLayout 作为它们的默认布局。完整答案

Swing 的轻量级组件被称为绝世组件。Swing 有它的库，因此它不使用来自操作系统的资源，因此它具有轻量级组件。完整答案

Scrollbar 是一个组件，而 ScrollPane 是一个容器。ScrollPane 处理其事件并执行其滚动。完整答案

轻量级组件是不通过本机调用来获取图形单元的组件。它们共享它们的父组件图形单元来渲染它们。例如，Swing 组件和 JavaFX 组件。完整答案

操作系统提供的可移植元素称为重量级组件。AWT 仅限于操作系统提供的图形类，因此，它仅实现所有平台支持的屏幕元素的最小子集。依赖于操作系统的 UI 发现工具被称为重量级组件。完整答案

applet是在浏览器中运行并生成动态内容的小型 Java 程序。它嵌入在网页中并在客户端运行。它是安全的并且需要更少的响应时间。它可以被运行在许多平台下的浏览器执行，包括Linux、Windows、Mac Os等。但是，在客户端浏览器上需要插件来执行applet。下图显示了 Applet 的架构：创建小程序时，依次调用以下方法： init()start()paint() 当一个小程序被销毁时，会依次调用以下方法： stop()destroy() 完整答案

Locale 对象表示特定的地理、政治或文化区域。此对象可用于获取特定于语言环境的信息，例如国家名称、语言、变体等。参考示例： import java.util.*; public class YiibaiDemo { public static void main(String[] args) { Locale locale = Locale.getDefault(); //Locale locale=new Locale("zh","... 完整答案

通过 ResourceBundle.getBundle(??) 方法。完整答案

JavaBean 是用 Java 编程语言编写的可重用软件组件，旨在由软件开发环境(如 JBuilder 或 VisualAge for Java)进行可视化操作。JavaBean 将许多对象封装到一个对象中，以便我们可以从多个位置访问该对象。此外，它提供了简单的维护。参考以下示例来创建 JavaBean 类。 public class Employee implements java.io.Serializable { private int id; private Strin... 完整答案

根据 Java 白皮书，它是一个可重用的软件组件。一个 bean 将许多对象封装到一个对象中，这样我们就可以从多个地方访问这个对象。此外，它提供了简单的维护。完整答案

当属性、字段和状态信息被保存到存储中或从存储中检索时，Java bean 的持久性属性开始起作用。完整答案

RMI(远程方法调用)是一种 API，它提供了一种在 java 中创建分布式应用程序的机制。RMI 允许对象调用在另一个 JVM 中运行的对象的方法。RMI 使用两个对象存根和框架在应用程序之间提供远程通信。完整答案

存根/stub 存根是一个对象，充当客户端的网关。所有传出请求都通过它进行路由。它驻留在客户端并代表远程对象。当调用者调用存根对象上的方法时，它会执行以下任务：它启动与远程虚拟机 (JVM) 的连接。它将参数写入并传输(编组)到远程虚拟机 (JVM)。它等待结果。它读取(解组)返回值或异常。最后，将值返回给调用者。骨架/Skeleton 骨架是一个对象，充当服务器端对象的网关。所有传入的请求都通过它进行路由。当骨架接收到传入的请求时，它会执行以下任务：它读取远程方法的参数。它调用实际远... 完整答案

编写基于 RMI 的程序需要执行 6 个步骤：创建远程接口。提供远程接口的实现。编译实现类并使用 rmic 工具创建存根和骨架对象。通过 rmiregistry 工具启动注册表服务。创建并启动远程应用程序。创建并启动客户端应用程序。完整答案

HTTP隧道可以定义为不需要任何设置即可在防火墙环境中工作的方法。它通过代理服务器处理 HTTP 连接。但是，它不允许出站 TCP 连接。完整答案

JRMP(Java 远程方法协议)可以定义为 Java 特定的、基于流的协议，它查找并引用远程对象。它要求客户端和服务器都使用 Java 对象。它是在 RMI 和 TCP/IP 上运行的线路级协议。完整答案

是的他们可以。RMI 与 IIOP 一起作为传输协议而不是 JRMP 可用。完整答案

参考以下程序在 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++) { ... 完整答案

参考以下程序以在 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("E... 完整答案

参考以下程序在 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 = small... 完整答案

参考以下程序在 Java 中执行线性搜索。 import java.util.Scanner; public class LeniearSearch { 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(Sy... 完整答案

参考以下程序在 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]; f... 完整答案

参考以下程序以在 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.... 完整答案

参考以下程序来创建一个包含 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; ... 完整答案

参考以下程序： 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 tai... 完整答案

参考以下程序： 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 Nod... 完整答案

多线程是同时执行多个线程的过程，多线程用于获得多任务处理。它消耗更少的内存并提供快速高效的性能。它的主要优点是：线程共享相同的地址空间。线程是轻量级的。进程之间的通信成本很低。完整答案

线程是一个轻量级的子进程。这是一个单独的执行路径，因为每个线程都在不同的堆栈帧中运行。一个进程可能包含多个线程。线程共享进程资源，但它们仍然独立执行。完整答案

进程和线程有以下区别：执行中的程序称为进程，而线程是进程的子集进程是独立的，而线程是进程的子集。进程在内存中有不同的地址空间，而线程包含一个共享的地址空间。与进程相比，线程之间的上下文切换更快。进程间通信比线程间通信更慢且成本更高。父进程的任何更改都不会影响子进程，而父线程的更改会影响子线程。完整答案

线程间通信是：同步线程之间的通信过程称为线程间通信。线程间通信用于避免 Java 中的线程轮询。线程在其临界区暂停运行，允许另一个线程进入(或锁定)在同一临界区执行。可以通过wait()、notify()、notifyAll()方法获取。完整答案

wait() 方法由 Java 中的 Object 类提供。此方法用于 Java 中的线程间通信。java.lang.Object.wait()用于暂停当前线程，并等待直到另一个线程调用 notify() 或 notifyAll()方法。它的语法如下： public final void wait() 完整答案

多线程编程具有以下优点：多线程允许应用程序/程序始终响应输入，即使已经运行一些后台任务。多线程允许更快地执行任务，因为线程独立执行。多线程可以更好地利用高速缓存，因为线程共享公共内存资源。多线程减少了所需服务器的数量，因为一台服务器可以一次执行多个线程。完整答案

线程在其生命周期内可以具有以下状态之一：新建：在这种状态下，使用 new 操作符创建了一个 Thread 类对象，但该线程不是活动的。在调用 start() 方法之前，线程不会启动。可运行：在这种状态下，线程在调用 start() 方法后就可以运行了。但是，线程调度程序尚未选择线程。正在运行：在这种状态下，线程调度程序从就绪状态中挑选线程，并且线程正在运行。等待/阻止：在这种状态下，一个线程没有运行但仍然活着，或者它正在等待另一个线程完成。死亡/终止：当 run() 方法退出时，线程处于终止... 完整答案

在抢占式调度下，最高优先级的任务一直执行，直到它进入等待或死亡状态或更高优先级的任务出现。在时间片下，任务执行预定义的时间片，然后重新进入就绪任务池。然后调度程序根据优先级和其他因素确定接下来应该执行哪个任务。完整答案

在上下文切换中，进程(或线程)的状态被存储，以便它可以被恢复并且以后可以从同一点恢复执行。上下文切换使多个进程可以共享同一个 CPU。完整答案

可以使用两种方式创建线程：通过扩展 Thread 类通过实现 Runnable 接口但是，两种方式之间的主要区别如下：通过扩展 Thread 类，不能扩展任何其他类，因为 Java 在实现 Runnable 接口时不允许多重继承；还可以扩展其他基类(如果需要)。通过扩展Thread类，每个线程在实现Runnable接口的同时创建唯一的对象并与之关联；多个线程共享同一个对象Thread 类提供了各种内置方法，例如 getPriority()、isAlive 等等，而 Runnable 接... 完整答案

join()方法等待线程终止。换句话说，它会导致当前运行的线程停止执行，直到它加入的线程完成它的任务。Join 方法在 Thread 类中通过以下方式重载。 public void join()throws InterruptedException public void join(long milliseconds)throws InterruptedException 完整答案

java 中的 sleep() 方法用于将线程阻塞特定时间，这意味着它将线程的执行暂停特定时间。有两种方法可以这样做。语法： public static void sleep(long milliseconds)throws InterruptedException public static void sleep(long milliseconds, int nanos)throws InterruptedException sleep()方法的工作原理：当调用 sleep() 方法时，... 完整答案

wait() sleep() 1 wait() 方法在 Object 类中定义。 sleep() 方法在 Thread 类中定义。 2 wait() 方法释放锁。 sleep() 方法不会释放锁。完整答案

不能。不能重新启动线程，因为一旦线程启动并执行，它就会进入 Dead 状态。因此，如果尝试启动一个线程两次，它会给出一个 runtimeException “java.lang.IllegalThreadStateException”。参考以下示例。 public class Multithread1 extends Thread { public void run() { try { System.out.println(&qu... 完整答案

可以。直接调用 run() 方法是有效的，但它不能作为线程工作，而是作为普通对象工作。线程之间不会有上下文切换。当调用 start() 方法时，它内部调用了 run() 方法，该方法为线程创建了一个新堆栈，而直接调用 run() 不会创建一个新堆栈。完整答案

守护线程是为用户线程提供后台支持和服务的低优先级线程。如果程序仅保留守护线程，并且所有其他用户线程都已结束/终止，则 JVM 会自动终止守护线程。Thread 类中有两种守护线程的方法： public void setDaemon(boolean status)：用于标记线程守护线程或用户线程。public boolean isDaemon()：检查线程是否为守护进程。完整答案

不能。如果这样做，它会抛出 IllegalThreadStateException。因此，只能在启动线程之前创建一个守护线程。示例代码： class Testdaemon1 extends Thread{ public void run(){ System.out.println("Running thread is daemon..."); } public static void main (String[] args) { ... 完整答案

关闭挂钩是在 JVM 关闭之前隐式调用的线程。所以当JVM正常或突然关闭时，可以使用它来清理资源或保存状态。可以使用以下方法添加关闭挂钩： public void addShutdownHook(Thread hook){} Runtime r=Runtime.getRuntime(); r.addShutdownHook(new MyThread()); 关于关闭挂钩的一些要点是：关闭挂钩已初始化，但只能在 JVM 关闭时启动。关闭挂钩比 finalizer() 更可靠，因为... 完整答案

当想打破线程的睡眠或等待状态时，应该中断一个线程。可以通过调用interrupt() 抛出InterruptedException 来中断线程。完整答案

同步是控制多个线程对任何共享资源的访问的能力。它用于：防止线程干扰。防止一致性问题。当多个线程尝试执行同一任务时，可能会出现错误结果，因此为了消除此问题，Java 使用了一次只允许执行一个线程的同步过程。同步可以通过三种方式实现：通过同步方法通过同步块通过静态同步同步块的语法： synchronized(object reference expression) { //code block } 完整答案

Synchronized 块可用于对方法的任何特定资源执行同步。一次只有一个线程可以在特定资源上执行，所有其他尝试进入同步块的线程都被阻塞。同步块用于锁定任何共享资源的对象。同步块的范围仅限于应用它的块。它的范围小于一个方法。完整答案

是的。可以通过将对象放在“synchronized”块中来锁定它。除了明确声明它的线程之外，任何线程都无法访问锁定的对象。完整答案

如果将任何静态方法设置为同步，则锁定将在类上而不是在对象上。如果在方法之前使用 synchronized 关键字，它会锁定对象(一个线程一次可以访问一个对象)，但如果使用静态同步，它会锁定一个类(一个线程一次可以访问一个类)。完整答案

notify()用于解除对一个等待线程的阻塞，而 notifyAll()方法用于解除对所有处于等待状态的线程的阻塞。完整答案

死锁是一种情况，其中每个线程都在等待由其他等待线程持有的资源。在这种情况下，线程都不会执行，也没有机会被执行。相反，所有线程之间存在一个通用的等待状态。死锁是一种非常复杂的情况，它可以在运行时破坏我们的代码。完整答案

可以通过在 cmd 上运行代码并收集 Thread Dump 来检测死锁情况，如果代码中存在死锁，则会在 cmd 上显示一条消息。 Java中避免死锁的方法：避免嵌套锁：嵌套锁是死锁的常见原因，因为当为各种线程提供锁时会发生死锁，因此应该在某个特定时间只给一个线程一个锁。避免不必要的锁：我们必须避免不必要的锁。使用线程连接：线程连接有助于等待一个线程，直到另一个线程没有完成它的执行，所以我们可以通过最大限度地使用连接方法来避免死锁。完整答案

在 Java 中，当我们创建线程时，它们是在线程调度程序的帮助下进行监督的，线程调度程序是 JVM 的一部分。线程调度器只负责决定应该执行哪个线程。线程调度器使用两种机制来调度线程：抢占式和时间片。 Java 线程调度程序还可以为线程决定以下内容：它选择线程的优先级。它确定线程的等待时间它检查线程的性质完整答案

是的，在多线程编程中，每个线程都在内存中维护自己的或单独的堆栈区域，因此每个线程彼此独立。完整答案

如果一个方法或类对象可以一次被多个线程使用而没有任何竞争条件，则该类是线程安全的。线程安全用于使程序在多线程编程中安全使用。可以通过以下方式实现：同步使用 Volatile 关键字使用基于锁的机制使用原子包装类完整答案

竞态条件是多线程编程中多个线程同时执行访问共享资源时出现的问题。正确使用同步可以避免竞态条件。完整答案

volatile关键字用于多线程编程以实现线程安全，因为一个 volatile 变量的更改对所有其他线程都是可见的，因此一个变量一次只能由一个线程使用。完整答案

线程池是： Java 线程池代表一组工作线程，它们正在等待分配的任务。线程池中的线程由服务提供者监督，该服务提供者从池中拉出一个线程并为其分配一个作业。完成给定任务后，线程再次来到线程池。线程池的大小取决于保留执行的线程总数。线程池的优点是：使用线程池可以提高性能。使用线程池，可以实现更好的系统稳定性。完整答案

可以使用 java.util.Concurrent 包的类和接口开发并发 API。java.util.Concurrent 包中有以下类和接口： ExecutorFarkJoinPoolExecutorServiceScheduledExecutorServiceFutureTimeUnit(Enum)CountDownLatchCyclicBarrierSemaphoreThreadFactoryBlockingQueueDelayQueueLocksPhaser 完整答案

java.util.concurrent 包提供的 Executor 接口是用于执行新任务的简单接口。Executor 接口的 execute() 方法用于执行某个给定的命令。execute()方法的语法如下所示： void execute(Runnable command) 参考以下示例： import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.conc... 完整答案

java.util.concurrent.BlockingQueue 是 Queue 的子接口，支持诸如在插入新值之前等待空间可用性或在从中检索元素之前等待队列变为非空等操作。参考以下示例。 import java.util.Random; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; public class TestThread { ... 完整答案

生产者-消费者问题可以通过以下方式使用 BlockingQueue 来解决。 import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.logging.Level; import java.util.logging.Logger; public class ProducerConsumerProblem { p... 完整答案

Callable 接口和 Runnable 接口都被希望通过多个线程执行的类使用。但是，两者之间有两个主要区别： Callable <V> 接口可以返回结果，而 Runnable 接口不能返回任何结果。Callable <V> 接口可以抛出已检查异常，而 Runnable 接口不能抛出已检查异常。在 Java 5 之前不能使用 Callable <V> 接口，而可以使用 Runnable 接口。完整答案

原子动作是可以在一个任务的单个单元中执行的操作，而不会干扰其他操作。原子动作不能在任务之间停止。一旦开始，它只会在任务完成后填充停止。诸如 a++ 之类的增量操作不允许原子操作。对原始变量(long 和 double 除外)的所有读写操作都是原子操作。对 volatile 变量(包括 long 和 double)的所有读写操作都是原子操作。原子方法在 java.util.Concurrent 包中可用。完整答案

java.util.concurrent.locks.Lock 接口用作同步机制。它的工作方式类似于同步块。下面给出了锁和同步块之间的一些区别。 Lock 接口提供了等待线程将被授予访问权限的顺序保证，而同步块不保证它。如果未授予锁定，锁定接口提供超时选项，而同步块不提供。Lock 接口的方法，即 Lock() 和 Unlock() 可以在不同的方法中调用，而单个同步块必须完全包含在单个方法中。完整答案

ExecutorService 接口是 Executor 接口的子接口，增加了管理生命周期的功能。参考以下示例。 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final Str... 完整答案

关于线程，同步编程和异步编程的区别如下：同步编程：在同步编程模型中，分配一个线程来完成一项任务，因此线程开始处理它，并且只有在结束分配的任务后才可用于其他任务。异步编程：在异步编程中，一项工作可以由多个线程完成，因此它提供了各种线程的最大可用性。完整答案

Java Callable 接口：在 Java5 中，可调用接口由 java.util.concurrent 包提供。它类似于 Runnable 接口，但它可以返回结果，并且可以抛出异常。它还提供了用于执行线程的 run() 方法。Java Callable 可以返回任何使用 Generic 的对象。语法： public interface Callable<V> Java Future 接口：Java Future 接口给出并发进程的结果。Callable 接口返回 java.... 完整答案

ExecutorServcie 和 ScheduledExecutorService 都是 java.util.Concurrent 包的接口，但 scheduleExecutorService 提供了一些额外的方法来延迟或每隔固定时间执行 Runnable 和 Callable 任务。完整答案

Java FutureTask 类提供了 Future 接口的基本实现。只有一个任务执行完成才能得到结果，如果计算没有完成则阻塞get方法。如果执行完成，则不能重新开始，也不能取消。语法： public class FutureTask<V> extends Object implements RunnableFuture<V> 完整答案

集合框架是类和接口的组合，用于以对象的形式存储和操作数据。为此，它提供了：ArrayList、Vector、Stack、HashSet等各种类和List、Queue、Set等接口。完整答案

Array 和 Collection 在存储对象的引用和操作数据方面有些相似，但它们在很多方面有所不同。数组和集合之间的主要区别定义如下：数组始终是固定大小的，即用户不能根据自己的需要或在运行时增加或减少数组的长度，但在 Collection 中，可以根据需要动态更改大小。数组只能存储同种或相似类型的对象，但在Collection中可以存储异构对象。数组不能提供现成用户要求的方法，如排序、搜索等，但 Collection 包括现成的使用方法。完整答案

Collection框架实现了各种接口，Collection接口和Map接口(java.util.Map)是Java Collection Framework主要使用的接口。Collection Framework的接口列表如下： 1、Collection接口：集合(java.util.Collection)是主要接口，每个集合都必须实现这个接口。语法： public interface Collection<E>extends Iterable 其中<E>表示这个接口... 完整答案

编号 ArrayList Vector 1 ArrayList不同步 Vector是同步的 2 ArrayList 不是遗留类 Vector 是一个遗留类 3 ArrayList 将其大小增加了数组大小的 50% Vector 通过将数组大小加倍来增加其大小 4 ArrayList 不是线程安全的，因为它不同步。 Vector列表是线程安全的，因为它的每个方法都是同步的完整答案

ArrayList 和 LinkedList 的区别如下：编号 ArrayList LinkedList 1 ArrayList 使用动态数组 LinkedList 使用双向链表 2 ArrayList 操作效率不高，因为需要太多 LinkedList 对操作很有效 3 ArrayList 更适合存储和获取数据 LinkedList 更适合操作数据 4 ArrayList 提供随机访问 LinkedList 不提供随机访问 5 ArrayList 占用更少的内存开... 完整答案

Iterator 仅向前遍历元素，而 ListIterator 向前和向后遍历元素。编号 Iterator ListIterator 1 Iterator 只在前向遍历元素 ListIterator 向后和向前遍历元素 2 Iterator可以用在List、Set、Queue中 ListIterator 只能在 List 中使用 3 Iterator 只能在遍历集合时执行remove操作 ListIterator 可以执行：add,remove和 set 遍历集合时的操... 完整答案

迭代器和枚举的区别如下：编号迭代器枚举 1 Iterator可以遍历legacy和non-legacy元素枚举只能遍历遗留元素 2 迭代器是快速失败的枚举不是快速失败 3 Iterator 比 Enumeration 慢枚举比迭代器快 4 Iterator可以在遍历集合的同时进行remove操作 Enumeration 只能对集合进行遍历操作完整答案

List 和 Set 都扩展了集合接口。但是，两者之间存在一些差异，如下所示： List 可以包含重复的元素，而 Set 包含唯一的项目。List 是维护插入顺序的有序集合，而 Set 是不保留插入顺序的无序集合。List 接口包含一个遗留类，它是 Vector 类，而 Set 接口没有任何遗留类。List 接口可以允许 n 个空值，而 Set 接口只允许单个空值。完整答案

HashSet 和 TreeSet 这两个类都实现了 Set 接口。下面列出了两者之间的区别： HashSet 保持无序，而 TreeSet 保持升序。HashSet 由哈希表实现，而 TreeSet 由 Tree 结构实现。HashSet 的执行速度比 TreeSet 快。HashSet 由 HashMap 支持，而 TreeSet 由 TreeMap 支持。完整答案

Set 和 Map 之间的区别如下所示： Set 仅包含值，而 Map 包含键和值。Set 包含唯一值，而 Map 可以包含具有重复值的唯一键。Set 包含限一个空值，而 Map 可以包含单个空键和 n 个空值。完整答案

下面列出了 HashSet 和 HashMap 之间的区别： HashSet 仅包含值，而 HashMap 包含条目(键，值)。HashSet是可以迭代的，但是 HashMap 需要转换成 Set 才能迭代。HashSet 实现了 Set 接口，而 HashMap 实现了 Map 接口HashSet 不能有任何重复值，而 HashMap 可以包含具有唯一键的重复值。HashSet 包含唯一的单个空值，而 HashMap 可以保存具有 n 个空值的单个空键。完整答案

下面给出 HashMap 和 TreeMap 之间的区别： HashMap 保持无序，而 TreeMap 保持升序。HashMap 是通过哈希表实现的，而 TreeMap 是通过 Tree 结构实现的。HashMap 可以按 Key 或 value 排序，而 TreeMap 可以按 Key 排序。HashMap 可能包含具有多个 null 值和一个 null 键，而 TreeMap 不能包含 null 键但可以具有多个 null 值。完整答案

编号 HashMap Hashtable 1 HashMap 不同步哈希表是同步的 2 HashMap可以包含一个空键和多个 null 值 Hashtable 不能包含任何 null 键或 null 值 3 HashMap 不是线程安全的，所以它对非线程应用程序很有用 Hashtable 是线程安全的，可以在各个线程之间共享 4 HashMap 继承AbstractMap 类Hashtable 继承Dictionary 类完整答案

下面给出Collection 和 Collections 的区别： Collection 是一个接口，而 Collections 是一个类。Collection 接口为 List、Set 和 Queue 提供数据结构的标准功能。但是，Collections 类是对集合元素进行排序和同步的。Collection 接口提供了可用于数据结构的方法，而 Collections 类提供了可用于对集合进行各种操作的静态方法。完整答案

编号 Comparable Comparator 1 Comparable 只提供一种序列 Comparator 提供多种序列 2 提供 compareTo() 方法提供 compare() 的方法 3 位于 java.lang 包中位于 java.util 包中 4 如实现 Comparable 接口，实际类被修改实际类没有改变完整答案

BlockingQueue 是一个扩展 Queue 接口的接口。它在检索、插入、删除等操作中提供并发性。在检索任何元素时，它会等待队列非空。在存储元素时，它会等待可用空间。BlockingQueue 不能包含 null 元素，BlockingQueue 的实现是线程安全的。语法： public interface BlockingQueue<E> extends Queue <E> 完整答案

如果更改属性(Properties)文件中的值，则无需重新编译 java 类。因此，它使应用程序易于管理。它用于存储需要经常更改的信息。参考以下示例。 import java.util.*; import java.io.*; public class Test { public static void main(String[] args)throws Exception{ FileReader reader=new FileReader("d... 完整答案

hashCode()方法返回一个哈希码值(一个整数)。如果两个键(通过调用 equals() 方法)相同，则 hashCode() 方法返回相同的整数。但是，两个哈希码可能具有不同或相同的密钥。如果两个对象通过使用 equals() 方法没有产生相等的结果，那么 hashcode() 方法将为两个对象提供不同的整数结果。完整答案

equals()方法用于检查两个对象是否相同。如果想根据属性检验对象是否相等，则需要重写它。例如，Employee 是一个有 3 个数据成员的类：id、name 和salary。但是，想通过薪水检验员工对象的相等性。然后，需要重写 equals() 方法。完整答案

Collections 类提供了使 List、Set 或 Map 元素同步的方法： public static List synchronizedList(List l){} public static Set synchronizedSet(Set s){} public static SortedSet synchronizedSortedSet(SortedSet s){} public static Map synchronizedMap(Map m){} public static S... 完整答案

使用泛型集合有三个主要优点：如果使用泛型类，不需要类型转换。它是类型安全的，并在编译时进行检查。Generic 通过在编译时检测到错误来确认代码的稳定性。完整答案

具有相同哈希值的两个不同键称为哈希冲突。两个单独的条目将保存在一个哈希桶中以避免冲突。有两种方法可以避免哈希冲突。分离链开放寻址完整答案

Dictionary类提供了存储键值对的能力。完整答案

负载因子的默认大小为 0.75。默认容量计算为初始容量 * 负载因子。例如，16 * 0.75 = 12。所以，12 是 Map 的默认容量。完整答案

如果发生任何结构修改，Java 中立即抛出 ConcurrentmodificationException 的 Iterator 称为 Fail-fast 迭代器。Fail-fats 迭代器不需要任何额外的内存空间。完整答案

下面给出了 Array 和 ArrayList 之间的主要区别： SN Array ArrayList 1 数组是固定大小的，不能根据需要调整数组的大小。 ArrayList 不是固定大小的，可以动态改变大小。 2 数组是静态类型的。 ArrayList 是动态大小的。 3 数组可以存储原始数据类型以及对象。 ArrayList 不能存储原始数据类型，它只能存储对象。完整答案

数组的长度可以通过length属性获取，而ArrayList不支持length属性，但是可以使用size()方法来获取列表中对象的个数。查找数组的长度： Int [] array = new int[4]; System.out.println("The size of the array is " + array.length); 查找 ArrayList 的大小: ArrayList<String> list=new ArrayList<Strin... 完整答案

可以使用 Arrays 类的 asList() 方法将 Array 转换为 ArrayList。asList()方法是 Arrays 类的静态方法，接受 List 对象。参考以下语法： Arrays.asList(item) 可以使用 ArrayList 类的 toArray() 方法将 ArrayList 转换为 Array。请考虑使用以下语法将 ArrayList 转换为 List 对象。 List_object.toArray(new String[List_object.size()]... 完整答案

可以通过调用 Collections.unmodifiableCollection() 方法获取 java ArrayList Read-only。当将 ArrayList 定义为只读时，无法通过 add()、remove() 或 set() 方法对集合进行任何修改。完整答案

有两种方法可以从 ArrayList 中删除重复项：使用 HashSet：通过使用 HashSet，可以从 ArrayList 中删除重复元素，但它不会保留插入顺序。使用 LinkedHashSet：还可以使用 LinkedHashSet 代替 HashSet 来维护插入顺序。使用 LinkedHashSet 从 ArrayList 中删除重复元素的过程：将 ArrayList 的所有元素复制到 LinkedHashSet。使用 clear() 方法清空 ArrayList，这将删除列... 完整答案

要反转 ArrayList，可以使用 Collections 类的 reverse() 方法。参考以下示例。 import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.Iterator; import java.util.List; public class ReverseArrayList { public static ... 完整答案

要对 ArrayList 进行降序排序，可以使用 Collections 类的 reverseOrder()方法。参考以下示例。 import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.Comparator; import java.util.Iterator; import java.util.List; public class Reve... 完整答案

可以通过两种方式同步 ArrayList - Collections.synchronizedList()CopyOnWriteArrayList<T> 完整答案

LinkedLists 更适合用于更新操作，而 ArrayLists 更适合用于搜索操作。完整答案

JDBC 是一种 Java API，用于连接和执行对数据库的查询。JDBC API 使用 JDBC 驱动程序连接到数据库。JDBC API 可用于访问存储在任何关系数据库中的表格数据。完整答案

JDBC Driver 是一个软件组件，它使 Java 应用程序能够与数据库进行交互。有 4 种类型的 JDBC 驱动程序： JDBC-ODBC桥驱动：JDBC-ODBC桥驱动使用ODBC驱动连接数据库。JDBC-ODBC 桥驱动程序将 JDBC 方法调用转换为 ODBC 函数调用。由于瘦驱动程序，现在不鼓励这样做。它易于使用，可以轻松连接到任何数据库。Native-API 驱动程序(部分是 java 驱动程序)：Native API 驱动程序使用数据库的客户端库。驱动程序将 JDBC 方法调用... 完整答案

以下步骤用于数据库连接: 1、注册驱动类：Class类的forName()方法用于注册驱动类。此方法用于动态加载驱动程序类。参考以下示例来注册 OracleDriver 类。 Class.forName("oracle.jdbc.driver.OracleDriver"); 2、创建连接：DriverManager 类的 getConnection() 方法用于建立与数据库的连接。getConnection()方法的语法如下所示。 public static Connect... 完整答案

java.sql 包包含以下用于 JDBC API 的接口和类。接口： Connection：Connection对象是使用DriverManager类的getConnection()方法创建的。DriverManager 是连接的工厂。Statement：Statement 对象是使用 Connection 类的 createStatement() 方法创建的。Connection 接口是 Statement 的工厂。PreparedStatement：PrepareStatement 对... 完整答案

在 JDBC 中，Statement 用于向数据库发送 SQL 命令并从数据库接收数据。JDBC 语句提供了多种方法，例如：execute()、executeUpdate()、executeQuery() 等，可帮助与数据库进行交互。下表给出了三种类型的 JDBC 语句。 JDBC语句类型： Statement - Statement 是结果集的工厂。它用于对数据库的通用访问。它在运行时执行静态 SQL 查询。PreparedStatement 当需要在运行时向查询提供输入参数时，使用 Pr... 完整答案

Class.forName()方法返回 java.lang.Class 对象的对象。完整答案

Statement和PreparedStatement接口的区别如下： Statement PreparedStatement Statement 接口提供了对数据库执行查询的方法。Statement 接口是 ResultSet 的工厂；即它提供了获取 ResultSet 对象的工厂方法。 PreparedStatement 接口是 Statement 的子接口。它用于执行参数化查询。在 Statement 的情况下，每次运行程序时都会编译查询。对于 PreparedSt... 完整答案

通过使用 PreparedStatement 接口的 setNull() 方法，可以将空值设置为索引。该方法的语法如下所示。 void setNull(int parameterIndex, int sqlType) throws SQLException 完整答案

下面给出了使用 PreparedStatement 相较于 Statement 接口的好处：与 Statement 相比，PreparedStatement 的执行速度更快，因为每次运行代码时都需要编译 Statement，而 PreparedStatement 只编译一次，然后仅在运行时执行。PreparedStatement 可以执行参数化查询，而 Statement 只能运行静态查询。PreparedStatement 中使用的查询似乎每次都相似。因此，数据库可以重用以前的访问计划，而... 完整答案

execute、executeQuery 和 executeUpdate 的区别如下： execute executeQuery executeUpdate execute()方法可用于任何 SQL 语句(Select 和 Update 两者) executeQuery() 方法只能与 select 语句一起使用 executeUpdate 方法可用于更新/删除/插入数据库中的操作 execute()方法返回一个布尔类型值，其中 true 表示返回的 ResultSet 可以稍... 完整答案

ResultSet 是根据读码器的方向和它提供的结果的敏感度或不敏感度来分类的。ResultSet 共有三种通用类型： ResultSet.TYPE_Forward_ONLY - 光标只能向前移动。ResultSet.TYPE_SCROLL_INSENSITIVE - 光标可以双向移动(向前和向后)，ResultSet 对其他人对数据库所做的更改不敏感。ResultSet.TYPE_SCROLL_SENSITIVE - 光标可以双向移动，ResultSet 对其他人对数据库所做的更改很敏感。完整答案

ResultSet 和 RowSet 的区别如下： ResultSet RowSet ResultSet 无法序列化，因为它维护与数据库的连接 RowSet 与数据库断开连接，可以序列化 ResultSet 对象不是 JavaBean 对象 ResultSet 对象是一个 JavaBean 对象 ResultSet 由 Statement 接口的 executeQuery() 方法返回 Rowset 接口扩展了 ResultSet 接口，并通过调用 RowSetProvid... 完整答案

以下是创建和执行存储过程的步骤。在这里，使用存储过程创建表 user420 并向其中插入值。 1、在数据库中创建过程要调用存储过程，需要在数据库中创建它。在这里，假设存储过程如下所示： create or replace procedure "INSERTR" (id IN NUMBER, name IN VARCHAR2) is begin insert into user420 values(id,name); end; / 表结构如下： ... 完整答案

DriverManager类充当用户和驱动程序之间的接口。它跟踪可用的驱动程序并处理在数据库和适当的驱动程序之间建立连接。DriverManager类维护通过调用方法 DriverManager.registerDriver() 注册自己的驱动程序类的列表。完整答案

Connection 接口维护与数据库的会话。它可以用于事务管理。它提供了返回 Statement、PreparedStatement、CallableStatement 和 DatabaseMetaData 实例的工厂方法。完整答案

ResultSet 对象表示表格的一行。它可用于更改游标指针并从数据库中获取信息。默认情况下，ResultSet 对象只能向前移动并且不可更新。但是，可以通过在 createStatement(int, int) 方法中传递 TYPE_SCROLL_INSENSITIVE 或 TYPE_SCROLL_SENSITIVE 来使该对象向前和向后移动。完整答案

ResultSetMetaData 接口返回表的总列数、列名、列类型等信息。完整答案

DatabaseMetaData 接口返回数据库的信息，例如用户名、驱动程序名称、驱动程序版本、表数、视图数等。参考以下示例。 import java.sql.*; class Dbmd { public static void main(String args[]) { try { Class.forName("oracle.jdbc.driver.OracleDriver"); Connect... 完整答案

Connection 接口提供了事务管理的方法，例如：commit()、rollback()等。完整答案

通过使用 JDBC 中的批处理技术，可以执行多个查询。它使性能快速。java.sql.Statement 和 java.sql.PreparedStatement 接口提供了批处理的方法。JDBC 中的批处理需要以下步骤。加载驱动类创建连接创建声明批量添加查询执行批处理关闭连接参考以下示例以使用 Statement 接口执行批处理。 import java.sql.*; class FetchRecords { public static void main(String a... 完整答案

BLOB：Blob 可以定义为可变长度的二进制大对象，用于保存语音、图像和混合媒体等二进制数据组。它在 MySQL 数据库上最多可容纳 2GB 数据，在 Oracle 数据库上最多可容纳 128 GB。MySQL、Oracle 和 DB2 等许多数据库都支持 BLOB 来存储二进制数据(图像、视频、音频和混合媒体)。 CLOB：Clob 可以定义为可变长度、字符大的对象，用于保存基于字符的数据，例如许多数据库中的文件。它在 MySQL 数据库上最多可容纳 2 GB，在 Oracle 数据库上最多... 完整答案

锁是某种软件机制，通过它我们可以限制其他用户使用数据资源。JDBC 中给出了四种类型的锁，如下所述。行和键锁：当更新行时使用这些类型的锁。页面锁：这些类型的锁应用于页面。它们用于事务保留在进程中并且正在更新、删除或在表的一行中插入一些数据的情况。数据库服务器锁定包含该行的整个页面。页面锁可以由数据库服务器应用一次。表锁：表锁应用于表。它可以通过两种方式应用，即共享和独占。共享锁允许其他事务读取表但不更新它。但是，排他锁阻止其他人读取和写入表。数据库锁：数据库锁用于在数据库打开时防止来自其他事... 完整答案

通过使用 PreparedStatement 接口，可以存储和检索图像。创建一个包含两列即 NAME 和 PHOTO 的表。 CREATE TABLE "IMGTABLE" ( "NAME" VARCHAR2(4000), "PHOTO" BLOB ) 参考以下示例以将图像存储在数据库中： import java.sql.*; import java.io.*; public class Ins... 完整答案

PreparedStatement 接口的setCharacterStream()方法用于将字符信息设置到parameterIndex 中。为了将文件存储到数据库中，表中使用了 CLOB(字符大对象)数据类型。例如： CREATE TABLE "FILETABLE" ( "ID" NUMBER, "NAME" CLOB ) 示例代码： import java.io.*; impor... 完整答案

PreparedStatement 的 getClob()方法用于从数据库中获取文件信息。让我们看一下检索文件的示例的表结构。 CREATE TABLE "FILETABLE" ( "ID" NUMBER, "NAME" CLOB ) 下面给出了从 Oracle 数据库中检索文件的示例。 import java.io.*; import java.sql.*; public class ... 完整答案

存储过程和函数的区别如下：存储过程函数用于执行业务逻辑用于执行计算不能有返回类型必须有返回类型可能返回 0 个或多个值可能只返回一个值过程支持输入和输出参数函数仅支持输入参数使用 try/catch 块的异常处理可用于存储过程使用 try/catch 的异常处理不能在用户定义的函数中使用完整答案

为了维护数据库的完整性，需要确保 ACID 属性。ACID 属性意味着原子性、一致性、隔离性和持久性。在 JDBC 中，Connection 接口提供了 setAutoCommit()、commit() 和 rollback() 等方法来管理事务。让我们看一个 JDBC 中的事务管理示例。 import java.sql.*; class FetchRecords { public static void main(String args[]) throws Exception {... 完整答案

JDBC Rowset 是 ResultSet 的包装器。它像 ResultSet 一样保存表格数据，但使用起来简单灵活。RowSet接口的实现类如下： JdbcRowSetCachedRowSetWebRowSetJoinRowSetFilteredRowSet 完整答案

java.util.Date 和 java.sql.Date 的主要区别在于，java.sql.Date 表示没有时间信息的日期，而 java.util.Date 表示日期和时间信息。完整答案

setMaxRows(int i)方法限制了数据库可以使用查询返回的行数。这也可以在查询中完成，因为我们可以使用 MySQL 中的 limit 子句。完整答案

Java面试题和答案(2024年收集更新)

微信关注