面向新人的 Java 面试问题（1-50）

1. Java 是否独立于平台？如果是，那么如何独立？

是的，Java 是一种独立于平台的语言。与许多编程语言不同，javac 将程序编译为字节码或 .class 文件。此文件独立于正在运行的软件或硬件，但需要在操作系统中预先安装 JVM（Java 虚拟机）文件才能进一步执行字节码。

尽管JVM 依赖于平台，但是字节码可以在任何系统上创建，并且可以在任何其他系统中执行，无论使用什么硬件或软件，这使得 Java 独立于平台。

2. Java 最重要的功能有哪些？

Java 是现实世界中最著名、使用最广泛的语言之一，Java 的许多特性使其比任何其他语言都更好，其中一些特性如下：

Java-768 的功能

简单：Java 非常容易理解，语法
平台独立性： Java 是平台独立性的，这意味着我们可以在任何软件和硬件上运行相同的程序并获得相同的结果。
解释型：Java 是一种解释型语言，也是一种基于编译器的语言。
健壮：垃圾收集，异常处理等功能使语言变得健壮。
面向对象：Java 是一种面向对象的语言，支持类、对象、OOPS 的四大支柱等概念。
安全：由于我们可以直接与用户共享应用程序而无需共享实际程序，因此 Java 是一种安全的语言。
高性能： 比其他传统解释型编程语言更快。
动态：支持类和接口的动态加载。
分布式：Java 的特性使得我们能够通过从任何连接的机器调用方法来访问文件。
多线程：通过定义多个线程来同时处理多个任务
架构中立：它不依赖于架构。

3.什么是JVM？

JVM-768

JVM 代表 Java 虚拟机，它是一个 Java 解释器。它负责加载、验证和执行用 Java 创建的字节码。

尽管它依赖于平台，这意味着 JVM 软件对于不同的操作系统是不同的，但它在使 Java 平台独立方面起着至关重要的作用。

要了解有关该主题的更多信息，请参阅Java 中的 JVM。

4.什么是JIT？

JIT-768

JIT 代表（即时）编译器，是 JRE（Java 运行时环境）的一部分，用于在运行时提高 Java 应用程序的性能。下面逐步介绍 JIT 的使用：

源代码用javac编译成字节码
字节码进一步传递给JVM
JIT是JVM的一部分，JIT负责在运行时将字节码编译为本机机器码。
JIT 编译器始终处于启用状态，但在调用方法时激活。对于已编译的方法，JVM 直接调用已编译的代码，而不是对其进行解释。
当 JVM 调用已编译的代码时，它会提高执行的性能和速度。

要了解有关该主题的更多信息，请参阅Java 中的 JIT。

5.JVM 可用的内存存储有哪些？

JVM-区域-768

JVM 由下面几个内存存储组成：

类（方法）区：保存每个类的类级数据，例如运行时常量池，字段和方法数据以及方法的代码。
堆：创建对象或存储对象。用于在运行时为对象分配内存。
堆栈：存储在方法返回值和执行动态链接时需要的数据和部分结果
程序计数器寄存器：存储当前正在执行的Java虚拟机指令的地址。
本机方法栈：存储应用程序中使用的所有本机方法。

要了解有关该主题的更多信息，请参阅JVM 内存存储。

6.什么是类加载器？

类加载器是 JRE（Java 运行时环境）的一部分，在执行字节码或创建的 .class 文件期间，类加载器负责将 Java 类和接口动态加载到 JVM（Java 虚拟机）。由于类加载器的存在，Java 运行时系统不需要了解文件和文件系统。

要了解有关该主题的更多信息，请参阅Java 中的 ClassLoader。

7.JVM、JRE、JDK之间的区别。

JVM：JVM 也称为 Java 虚拟机，是 JRE 的一部分。JVM 是一种解释器，负责将字节码转换为机器可读的代码。JVM 本身依赖于平台，但它会解释字节码，这就是 Java 独立于平台的原因。

JRE：JRE 代表 Java 运行时环境，它是一个安装包，提供了在任何机器上运行 Java 程序或应用程序的环境。

JDK：JDK 代表 Java 开发工具包，提供开发和执行 Java 程序的环境。JDK 是一个软件包，包含两个东西：开发工具，提供开发 Java 程序的环境；JRE，执行 Java 程序或应用程序。

要了解有关该主题的更多信息，请参阅JVM、JRE 和 JDK 之间的区别。

8.Java和C++有什么区别？

基础	C++	Java
平台	C++ 依赖于平台	Java 是平台独立的
应用	C++主要用于系统编程	Java 主要用于应用程序编程
硬件	C++ 更接近硬件	Java 与硬件的交互不太紧密
全局范围	C++ 支持全局和命名空间范围。	Java 不支持全局范围。
不支持	Java 支持但 C++ 不支持的功能包括：线程支持文档注释无符号右移(>>>)	C++ 支持但 Java 不支持的功能包括：转到指针通过引用调用结构和联合多重继承虚拟函数
哎呀	C++ 是一种面向对象的语言。它不是一个单一的根层次结构。	Java 也是一种面向对象语言。它具有单根层次结构，因为所有内容都源自单个类 (java.lang.Object)。
继承树	C++ 总是创建一个新的继承树。	Java 使用单一继承树，因为 Java 中的类是 Java 中对象类的子类。

9. 解释 Java 中的 public static void main(String args[])。

Main_function

与 C、C++ 等其他编程语言不同，在 Java 中，我们将主函数声明为 public static void main (String args[])。术语的含义如下：

public：public 是访问修饰符，用于说明谁可以访问元素或方法以及限制是什么。它负责使 main 函数全局可用。它被公开，以便 JVM 可以从类外部调用它，因为它不存在于当前类中。
static：static 是一个关键字，这样我们就可以在不启动类的情况下使用该元素，从而避免不必要的内存分配。
void：void 是一个关键字，用于指定方法不返回任何内容。由于主函数不返回任何内容，因此我们使用 void。
main：main 表示声明的函数是主函数。它帮助 JVM 识别声明的函数是主函数。
String args[]：存储Java命令行参数，是java.lang.String类类型的数组。

10.什么是 Java 字符串池？

Java 字符串池是堆内存中的一个位置，用于存储程序中定义的所有字符串。堆栈中有一个单独的位置，用于存储存储字符串的变量。每当我们创建一个新的字符串对象时，JVM 都会检查字符串池中是否存在该对象，如果池中存在字符串，则与变量共享相同的对象引用，否则将创建一个新对象。

Java-字符串-池-768

例子：

String str1="Hello";
// "Hello" will be stored in String Pool
// str1 will be stored in stack memory

11.如果我们不将 main 声明为静态，会发生什么？

我们可以不使用静态声明主方法，并且不会出现任何错误。但是，主方法不会被视为应用程序或程序的入口点。

12. Java 中的包是什么？

Java 中的包可以定义为相关类型的类、接口等的分组，提供对保护和命名空间管理的访问。

13.为什么要使用包？

Java 中使用包是为了防止命名冲突、控制访问以及使类、接口等的搜索/定位和使用更加容易。

14.Java 中的包有什么优点？

在 Java 中定义包有各种优点。

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

15.Java中有多少种类型的包？

Java 中有两种类型的包

用户定义的包
内置包

16. 解释 Java 中的不同数据类型。

Java 中有以下两种数据类型：

原始数据类型
非原始数据类型或对象数据类型

原始数据类型：原始数据是没有特殊功能的单个值。有 8 种原始数据类型：

boolean：存储值为 true 或 false
字节：存储 8 位有符号二进制补码整数
char：存储单个 16 位 Unicode 字符
short：存储 16 位有符号二进制补码整数
int：存储 32 位有符号二进制补码整数
long：存储 64 位二进制补码整数
float：存储单精度 32 位 IEEE 754 浮点数
double：存储双精度 64 位 IEEE 754 浮点数

非原始数据类型：引用数据类型将包含变量值的内存地址，因为它无法直接将值存储在内存中。非原始类型如下：

Strings
Array
Class
Object
Interface

17.何时使用字节数据类型？

字节是 8 位有符号二进制补码整数。字节支持的最小值为 -128，最大值为 127。它用于需要节省内存且所需数字限制在 -128 到 127 之间的情况。

18.我们可以在 Java 中声明指针吗？

不，Java 不提供对指针的支持。因为 Java 需要更安全，因为 Java 中没有提供指针的功能。

19.Java 中字节数据类型的默认值是什么？

Java 中字节数据类型的默认值是 0。

20. Java 中 float 和 double 数据类型的默认值是什么？

在 Java 中，浮点数的默认值为 0.0f，双精度数的默认值为 0.0d。

21.Java 中的 Wrapper 类是什么？

包装器，一般是指一个大实体封装了一个小实体。在 Java 中，包装器类是一个封装了原始数据类型的对象类。

原始数据类型是可以创建更多数据类型的基础。例如，整数可以进一步构造长整型、字节型、短整型等。另一方面，字符串不能，因此它不是原始的。

回到包装器类，Java 包含 8 个包装器类。它们是 Boolean、Byte、Short、Integer、Character、Long、Float 和 Double。此外，还可以在 Java 中创建自定义包装器类，这类似于 C 编程语言中的结构概念。我们使用所需的数据类型创建自己的包装器类。

22.为什么我们需要包装类？

包装类是一个封装原始数据类型的对象类，我们需要它们的原因如下：

包装器类是最终的且不可变的
提供valueOf()、parseInt()等方法。
它提供了自动装箱和拆箱的功能。

23.区分实例变量和局部变量。

实例变量	局部变数
在方法外声明，由方法直接调用。	在方法内声明。
具有默认值。	无默认值
它可以在整个课堂中使用。	范围仅限于方法。

24. Java 中分配给变量和实例的默认值是什么？

在 Java 中，当我们尚未初始化实例变量时，编译器会使用默认值初始化它们。实例和变量的默认值取决于它们的数据类型。一些常见的默认数据类型包括：

数字类型（byte、short、int、long、float 和 double）的默认值为 0。
布尔类型的默认值为 false。
对象类型（类、接口和数组）的默认值为空。
空字符“u0000”是 char 类型的默认值。

// Java Program to demonstrate use of default values
import java.io.*;
class GFG {
    // static values
    static byte b;
    static int i;
    static long l;
    static short s;
    static boolean bool;
    static char c;
    static String str;
    static Object object;
    static float f;
    static double d;
    static int[] Arr;
    public static void main(String[] args)
    {
        // byte value
        System.out.println("byte value" + b);
        // short value
        System.out.println("short value" + s);
        // int value
        System.out.println("int value" + i);
        // long value
        System.out.println("long value" + l);
        System.out.println("boolean value" + bool);
        System.out.println("char value" + c);
        System.out.println("float value" + f);
        System.out.println("double value" + d);
        System.out.println("string value" + str);
        System.out.println("object value" + object);
        System.out.println("Array value" + Arr);
    }
}

输出：

byte value0
short value0
int value0
long value0
boolean valuefalse
char value
float value0.0
double value0.0
string valuenull
object valuenull
Array valuenull

25.什么是类变量？

在 Java 中，类变量（也称为静态变量）是在类内声明但在任何方法、构造函数或块之外的变量。类变量使用 static 关键字声明，它们由类的所有实例（对象）以及类本身共享。无论从一个类派生出多少个对象，每个类变量都只存在一次。

例子：

// Java program to demonstrate use of Clas Variable
class GFG {
    public static int ctr = 0;
    public GFG() { ctr++; }
    public static void main(String[] args)
    {
        GFG obj1 = new GFG();
        GFG obj2 = new GFG();
        GFG obj3 = new GFG();
        System.out.println("Number of objects created are "
                           + GFG.ctr);
    }
}

输出

Number of objects created are 3

26. 局部变量存储的默认值是什么？

局部变量没有默认值。此外，原始变量和对象也没有任何默认值。

27. 解释实例变量和类变量之间的区别。

实例变量：没有静态修饰符的类变量称为实例变量，通常由类的所有实例共享。这些变量可以在多个对象之间具有不同的值。实例变量的内容完全独立于一个对象实例，因为它们与类的特定对象实例相关。

例子：

// Java Program to demonstrate Instance Variable
import java.io.*;
class GFG {
    private String name;
    public void setName(String name) { this.name = name; }
    public String getName() { return name; }
    public static void main(String[] args)
    {
        GFG obj = new GFG();
        obj.setName("John");
        System.out.println("Name " + obj.getName());
    }
}

输出

Name John

类变量： 类变量可以在类级别的任何地方使用关键字 static 声明。这些变量在应用于各种对象时只能有一个值。这些变量可以由所有类成员共享，因为它们不与类的任何特定对象相关联。

例子：

// Java Program to demonstrate Class Variable
import java.io.*;
class GFG {
    // class variable
    private static final double PI = 3.14159;
    private double radius;
    public GFG(double radius) { this.radius = radius; }
    public double getArea() { return PI * radius * radius; }
    public static void main(String[] args)
    {
        GFG obj = new GFG(5.0);
        System.out.println("Area of circle: "
                           + obj.getArea());
    }
}

输出

Area of circle: 78.53975

28.什么是静态变量？

static 关键字用于共享给定类的相同变量或方法。静态变量是一旦声明就会创建该变量的单个副本并在类级别的所有对象之间共享的变量。

29.System.out、System.err和System.in有什么区别？

System.out –它是一个用于写入字符的 PrintStream，或者可以说它可以输出我们想要在命令行界面控制台/终端上写入的数据。

例子：

// Java Program to implement
// System.out
import java.io.*;
// Driver Class
class GFG {
    // Main Function
    public static void main(String[] args)
    {
        // Use of System.out
        System.out.println("");
    }
}

System.err –用于显示错误消息。

例子：

// Java program to demonstrate
// System.err
import java.io.*;
// Driver Class
class GFG {
    // Main function
    public static void main(String[] args)
    {
        // Printing error
        System.err.println(
            "This is how we throw error with System.err");
    }
}

输出：

This is how we throw error with System.err

尽管 System.err 有很多相似之处，但它们也有很多不同之处，让我们来检查一下。

系统输出	系统错误
它将按照系统的标准进行打印。	它将打印到标准错误。
它主要用于在控制台上显示结果。	它主要用于输出错误文本。
它以默认（黑色）颜色在控制台上输出。	它还在控制台上提供输出，但大多数 IDE 都将其设为红色以示区分。

System.in –它是一个用于从终端窗口读取输入的 InputStream。我们不能直接使用 System.in，因此我们使用 Scanner 类通过 system.in 获取输入。

例子：

// Java Program to demonstrate
// System.in
import java.util.*;
// Driver Class
class Main {
    // Main Function
    public static void main(String[] args)
    {
        // Scanner class with System.in
        Scanner sc = new Scanner(System.in);
        // Taking input from the user
        int x = sc.nextInt();
        int y = sc.nextInt();
        // Printing the output
        System.out.printf("Addition: %d", x + y);
    }
}

输出：

3
4
Addition: 7

30.你对IO流是如何理解的？

2-768

Java 在其 I/O 包中提供了各种流，可帮助用户执行所有输入输出操作。这些流支持所有类型的对象、数据类型、字符、文件等，以完全执行 I/O 操作。

31.Reader/Writer类层次结构和InputStream/OutputStream类层次结构有什么区别？

它们之间的主要区别在于字节流数据由输入/输出流类读取和写入。字符由 Reader 和 Writer 类处理。与接受字符数组作为参数的 Reader/Writer 类相比，输入/输出流类方法接受字节数组。与输入/输出流相比，Reader/Writer 类效率更高，可处理所有 Unicode 字符，并且对内部化非常有用。除非您这样做，否则请使用 Reader/Writer 类代替二进制数据（例如图片）。

例子：

// Java Program to demonstrate Reading Writing Binary Data
// with InputStream/OutputStream
import java.io.*;

class GFG {
    public static void main(String[] args) {
        try {
            // Writing binary data to a file using OutputStream
            byte[] data = {(byte) 0xe0, 0x4f, (byte) 0xd0, 0x20, (byte) 0xea};
            OutputStream os = new FileOutputStream("data.bin");
            os.write(data);
            os.close();

            // Reading binary data from a file using InputStream
            InputStream is = new FileInputStream("data.bin");
            byte[] newData = new byte[5];

            is.read(newData);
            is.close();

            // Printing the read data
            for (byte b : newData) {
                System.out.print(b+" ");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

输出

-32 79 -48 32 -22

32. 各流派的超级最多课程有哪些？

所有的流类可以分为两种，即字节流类和字符流类。字节流类又分为输入流类和输出流类。字符流类又分为读取流类和写入流类。所有输入流类的最上级类是 java.io.InputStream，所有输出流类的最上级类是 java.io.OutPutStream。同样，所有读取流类的最上级类是 java.io.Reader，所有写入流类的最上级类是 java.io.Writer。

33.什么是FileInputStream和FileOutputStream？

为了读取和写入数据，Java 提供了 I/O 流。流表示输入源或输出目标，可以是文件、I/O 设备、另一个程序等。Java中的FileInputStream用于从文件中读取数据作为字节流。它主要用于读取二进制数据，例如图像、音频文件或序列化对象。

例子：

File file = new File("path_of_the_file");
FileInputStream inputStream = new FileInputStream(file);

在 Java 中，FileOutputStream函数用于将数据逐字节写入给定的文件或文件描述符。通常，使用 FileOutputStream 将原始字节数据（例如图片）写入文件。

例子：

File file = new File("path_of_the_file");
FileOutputStream outputStream = new FileOutputStream(file);

34.使用BufferedInputStream和BufferedOutputStream类的目的是什么？

当我们处理文件或流时，为了提高程序的输入/输出性能，我们需要使用 BufferedInputStream 和 BufferedOutputStream 类。这两个类都提供缓冲功能，这意味着在写入文件或从流中读取数据之前，数据将存储在缓冲区中。它还减少了我们的操作系统需要与网络或磁盘交互的次数。缓冲允许程序写入大量数据，而不是将其分成小块写入。这也减少了访问网络或磁盘的开销。

BufferedInputStream(InputStream inp); 
//用于创建缓冲输入流并保存参数。

BufferedOutputStream(OutputStream output); 
// 用于创建具有默认大小的新缓冲区。

35.什么是FilterStreams？

流过滤器或过滤流返回由与给定谓词匹配的此流元素组成的流。在工作 filter() 时，它实际上并不执行过滤，而是创建一个新流，在遍历时，该新流包含与给定谓词匹配的初始流元素。

例子：

FileInputStream fis = new FileInoutStream("file_path");
FilterInputStream = new BufferedInputStream(is);

36.什么是 I/O 过滤器？

I/O 过滤器也定义为输入输出过滤器，是一个从一个流读取数据并将数据写入输入和输出源的对象。它使用 java.io 包来使用此过滤器。

37. 有多少种方法可以从控制台获取输入？

下面提到了两种从 Java 控制台获取输入的方法：

使用命令行参数
使用缓冲读取器类
使用控制台类
使用扫描仪类

下面给出了演示每种方法用法的程序。

例子：

// Java Program to implement input
// using Command line argument
import java.io.*;
class GFG {
    public static void main(String[] args)
    {
        // check if length of args array is
        // greater than 0
        if (args.length &gt; 0) {
            System.out.println(
                "The command line arguments are:");
            // iterating the args array and printing
            // the command line arguments
            for (String val : args)
                System.out.println(val);
        }
        else
            System.out.println("No command line "
                               + "arguments found.");
    }
}
// Use below commands to run the code
// javac GFG.java
// java Main GeeksforGeeks

// Java Program to implement
// Buffer Reader Class
import java.io.*;
class GFG {
    public static void main(String[] args)
        throws IOException
    {
        // Enter data using BufferReader
        BufferedReader read = new BufferedReader(
            new InputStreamReader(System.in));
        // Reading data using readLine
        String x = read.readLine();
        // Printing the read line
        System.out.println(x);
    }
}

输出

null

// Java program to implement input
// Using Console Class
public class GfG {
    public static void main(String[] args)
    {
        // Using Console to input data from user
        String x = System.console().readLine();
        System.out.println("You entered string " + x);
    }
}


// Java program to demonstrate
// working of Scanner in Java
import java.util.Scanner;
class GfG {
    public static void main(String args[])
    {
        // Using Scanner for Getting Input from User
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        System.out.println("You entered string " + str);
    }
}

Output:

GeeksforGeeks

38. print、println 和 printf 使用上的区别。

print、println 和 printf 都用于打印元素，但 print 会打印所有元素，且光标仍在同一行。println 将光标移至下一行。使用 printf 时，我们也可以使用格式标识符。

39.什么是运算符？

运算符是用于对变量和值执行某些运算的特殊类型的符号。

40. Java 中有多少种类型的运算符？

Java 中所有类型的运算符如下：

算术运算符
一元运算符
赋值运算符
关系运算符
逻辑运算符
三元运算符
按位运算符
移位运算符
运算符实例

根据 Java 运算符优先级，后缀运算符被视为具有最高优先级。

41. 解释 >> 和 >>> 运算符之间的区别。

诸如 >> 和 >>> 之类的运算符看起来相同，但作用略有不同。>> 运算符用于移位符号位，而 >>> 运算符用于移出零填充位。

例子：

import java.io.*;

// Driver
class GFG {
    public static void main(String[] args) {
        int a = -16, b = 1;
        // Use of >>
        System.out.println(a >> b);
        a = -17;
        b = 1;
        // Use of >>>
        System.out.println(a >>> b);
    }
}

输出

-8 
2147483639

42. 哪个 Java 运算符是右结合的？

只有一个右结合运算符，即 = 运算符。

43.什么是点运算符？

Java 中的点运算符用于访问类对象的实例变量和方法。它还用于访问包中的类和子包。

44. 什么是协变返回类型？

协变返回类型指定返回类型可以与子类同向变化。子类中重写方法的返回类型可以不同，但子类的返回类型应为父类返回类型的子类型，因此重写方法会根据返回类型发生变化。

我们使用协变返回类型是因为以下原因：

避免类层次结构中存在的令人困惑的类型转换，并使代码具有可读性、可用性和可维护性。
在重写方法时可以自由地拥有更具体的返回类型。
帮助防止返回时出现运行时 ClassCastException。

45. 什么是 temporary 关键字？

如果我们不想在文件中保存特定变量的值，则在序列化时使用 temporary 关键字。当 JVM 遇到 temporary 关键字时，它会忽略变量的原始值并保存该变量数据类型的默认值。

46.sleep()和wait()方法有什么区别？

睡觉（）	等待（）
sleep()方法属于线程类。	Wait() 方法属于对象类。
睡眠不会释放当前线程持有的锁。	wait() 释放锁，允许其他线程获取它。
此方法是静态方法。	此方法不是静态方法。
Sleep() 不会引发 InterruptedException。	如果线程在等待时被中断，则会显示 InterruptedException。
主要用于将线程延迟特定的时间段。	主要用于暂停一个线程直到被另一个线程通知。
Sleep() 有两个重载方法： sleep(long millis)millis：毫秒 sleep(long millis, int nanos) nanos：纳秒	Wait() 有三种重载方法：等待（）等待（长时间超时）等待（长时间超时，int 纳秒）

47.String和StringBuffer有什么区别？

细绳	字符串缓冲区
存储一系列字符。	提供处理字符串的功能。
它是不可变的。	它是可变的（可以被修改并且可以对其执行其他字符串操作。）
字符串中没有线程操作。	它是线程安全的（两个线程不能同时调用StringBuffer的方法）

48.StringBuffer和StringBuilder有什么区别？

字符串缓冲区	字符串生成器
StringBuffer 提供处理字符串的功能。	StringBuilder 是一个用于构建可变字符串的类。
它是线程安全的（两个线程不能同时调用StringBuffer的方法）	它不是线程安全的（两个线程可以同时调用方法）
由于是同步的，所以相对较慢。	非同步，实现速度更快

49. 当需要对数据进行大量更新时，应该优先选择 String 还是 String Buffer？

与 StringBuffer 相比，StringBuilder 更胜一筹，因为其速度更快；但是，由于 StringBuffer 对象能够提供更高的线程安全性，因此更受青睐。

50.为什么StringBuffer被称为可变的？

Java 中的 StringBuffer 类用于表示可变的字符串。它提供了一种不可变 String 类的替代方案，使您能够更改字符串的内容而无需不断创建新对象。可变（可修改）字符串是在 StringBuffer 类的帮助下创建的。Java 中的 StringBuffer 类与 String 类相同，只是它是可变的。

例子：

// Java Program to demonstrate use of stringbuffer
public class StringBufferExample {
    public static void main(String[] args)
    {
        StringBuffer s = new StringBuffer();
        s.append("Geeks");
        s.append("for");
        s.append("Geeks");
        String message = s.toString();
        System.out.println(message);
    }
}

输出