Java专业人士的面试问题

Q1。解释JVM、JRE 和 JDK吗？
JVM（Java虚拟机）： JVM（Java虚拟机）充当运行Java应用程序的运行时引擎。 JVM 是实际调用Java代码中存在的 main 方法的那个。 JVM 是 JRE（Java运行时环境）的一部分。
JRE（Java Runtime Environment）： JRE是指可以执行Java字节码的运行时环境。它实现了 JVM（Java虚拟机）并提供了 JVM 在运行时使用的所有类库和其他支持文件。因此，JRE 是一个软件包，其中包含运行Java程序所需的内容。基本上，它是物理存在的 JVM 的实现。
JDK（Java Development Kit）：是Java程序编译、文档和打包的必备工具。 JDK 完全包括 JRE，其中包含用于Java程序员的工具。 Java开发工具包是免费提供的。除了 JRE，它还包括解释器/加载器、编译器 (javac)、存档器 (jar)、文档生成器 (javadoc) 和Java开发所需的其他工具。简而言之，它包含 JRE+ 开发工具。
Q2。解释 public static void main(String args[])。
Public： Public 是一个访问修饰符。 Public 意味着任何类都可以访问此方法。
static ：它是Java中的一个关键字，用于标识它是基于类的，即无需创建类的实例即可访问它。由于我们还希望在没有任何实例的情况下执行 main 方法，因此我们使用静态。
void：方法的返回类型。 void 定义不会返回任何值的方法。
main：这是JVM执行的第一个方法。方法的签名必须相同。
Q3。为什么Java是平台无关的？
平台无关实际上意味着“一次编写，随处运行”。 Java之所以这样称呼是因为它的字节码可以在任何系统上运行，而不管其底层操作系统如何。
Q4。为什么Java不是纯面向对象的？
Java不被认为是纯面向对象的，因为它支持原始数据类型，例如 boolean、byte、char、int、float、double、long、short。
Q5。定义类和对象。用一个使用Java的例子来解释它们。
类：类是用户定义的蓝图或原型，从中创建对象。它表示一种类型的所有对象共有的一组属性或方法。一般来说，类声明可以包括这些组件，按顺序：
超类（如果有）：类的父类（超类）的名称，如果有的话，前面有关键字extends。一个类只能扩展（子类）一个父类。
接口：由类实现的接口的逗号分隔列表（如果有的话），前面有关键字 implements。一个类可以实现多个接口。
对象：它是面向对象编程的基本单元，代表现实生活中的实体。一个典型的Java程序会创建许多对象，如您所知，这些对象通过调用方法进行交互。一个对象包括：
状态：它由对象的属性表示。它还反映了对象的属性。
行为：它由对象的方法表示。它还反映了一个对象对其他对象的响应。
身份：它为一个对象赋予一个唯一的名称，并使一个对象能够与其他对象交互。
例如：Employee 是一个类的例子
具有唯一标识的特定员工就是对象的一个示例。

class Employee
{
   // instance variables declaration
   // Methods definition
}

员工的对象是特定的员工

Employee empObj = new Employee();

Employee 的对象之一由“empObj”引用
Q6.什么是方法？提供方法的多个签名
Java方法是一组用于执行任务的语句。一个方法被放置在一个类中。
方法签名：方法的名称、返回类型和参数个数构成方法签名。
方法的签名中可以包含以下元素：
– 访问说明符 – 公共、私有、受保护等（非强制性）
– 访问修饰符 – 静态、同步等（非强制性）
– 返回类型 – void、int、String 等（强制）
– 方法名称 – show() (强制)
– 带或不带参数 – (int number, String name); （括号为必填项）
例子：

Java

class Test {
    void fun1() {}
    public double fun2(double x) {}
    public static void fun3() {}
    public static void fun4(String x) {}
}

Q7.解释实例变量和类变量的区别。
实例变量是每个对象/实例具有一个副本的变量。这意味着每个对象都会有一个副本。
类变量是每个类有一个副本的变量。类变量在对象中不会有副本。
例子 ：

Java

class Employee {
    int empNo;
    String empName, department;
    double salary;
    static int officePhone;
}

empObj1 引用的对象是通过使用以下内容创建的：
员工 empObj1 = 新员工（）；
实例变量 empObj1 和 empObj2 引用的对象具有单独的副本 empNo、empName、department 和 Salary。但是，officePhone 属于类（类变量），可以作为 Employee.officePhone 访问。
Q8。哪个类是所有类的超类？
Java.lang.Object 是所有Java类的根类，我们不需要扩展它。
Java中的构造函数是什么？
在Java中，构造函数是指用于初始化对象的代码块。它必须与类的名称相同。此外，它没有返回类型，并且在创建对象时自动调用。
如果一个类没有显式声明， Java编译器会自动提供一个无参数构造函数，也称为默认构造函数。
这个默认构造函数调用类父类的无参数构造函数（因为它只包含一个语句，即 super();），或者如果类没有其他父类则调用 Object 类构造函数（因为 Object 类是所有类的父类，直接或间接）。
有两种类型的构造函数：

1. 默认构造函数
2. 参数化构造函数

问题 10。在Java中创建对象有哪些不同的方法？
在Java中有许多不同的方法来创建对象。请参阅在Java中创建对象的 5 种不同方法
问题 11。静态方法和静态变量的目的是什么？
当需要在一个类的多个对象之间共享一个方法或变量而不是为每个对象创建单独的副本时，我们使用 static 关键字来使所有对象共享一个方法或变量。
静态变量：静态变量也称为类变量。
这些变量的声明方式与实例变量类似，不同之处在于静态变量是在任何方法构造函数或块之外的类中使用 static 关键字声明的。
与实例变量不同，无论我们创建了多少对象，每个类只能拥有一个静态变量的副本。
静态变量在程序执行开始时创建，并在执行结束时自动销毁。
要访问静态变量，我们不需要创建该类的对象。
静态方法：无需创建对象即可访问静态方法。只需使用类名即可访问该方法。静态方法只能访问静态变量，不能访问局部或全局非静态变量。
例如：

Java

public class StaticMethod {
    public static void printMe()
    {
        System.out.println("Static Method access directly by class name!");
    }
}
public class MainClass {
    public static void main(String args[])
    {
        StaticMethod.printMe();
    }
}

问题 12。为什么静态方法不能访问非静态变量或方法？
Ans）静态方法不能访问非静态变量或方法，因为可以在不实例化类的情况下访问静态方法，因此如果未实例化类，则不会初始化变量，因此无法从静态方法访问。
Q13.什么是静态类？
如果一个类的所有变量和方法都是静态的，并且构造函数是私有的，那么这个类就可以说是静态类。将构造函数设为私有将阻止类被实例化。所以访问的唯一可能性是只使用类名。
问题 14。变量有多少种？解释。
Java中有三种类型的变量：

1. 局部变量
2. 实例变量
3. 静态变量

局部变量：在块、方法或构造函数中定义的变量称为局部变量。
这些变量在进入块或调用函数时创建，并在退出块或调用从函数返回时销毁。
这些变量的作用域只存在于声明变量的块中。即我们只能在该块内访问这些变量。

Java

// Java program to demonstrate local variables
public class LocalVariable
{
    public void getLocalVarValue()
    {  
        // local variable age
        int localVar = 0;
        localVar = localVar + 11;
        System.out.println("value of local variable" +
                                 " is: " + localVar);
    }
    public static void main(String args[])
    {
        LocalVariable obj = new LocalVariable();
        obj.getLocalVarValue();
    }
}

输出：

value of local variable is: 11

在上面的程序中，变量 localVar 是函数getLocalVarValue() 的局部变量。如果我们在 getLocalVarValue()函数之外使用变量 localVar ，编译器将产生错误：
“找不到符号 localVar”。
实例变量：实例变量是非静态变量，在任何方法、构造函数或块之外的类中声明。
由于实例变量是在类中声明的，因此这些变量在创建类的对象时创建，并在对象被销毁时销毁。
与局部变量不同，我们可以对实例变量使用访问说明符。如果我们不指定任何访问说明符，则将使用默认访问说明符。

Java

// Java program to demonstrate instance variables
public class InstanceVariable {
    int instanceVarId;
    String instanceVarName;
    public static void main(String args[])
    {
        InstanceVariable obj = new InstanceVariable();
        obj.instanceVarId = 0001;
        obj.instanceVarName = "InstanceVariable1";
        System.out.println("Displaying first Object:");
        System.out.println("instanceVarId==" + obj.instanceVarId);
        System.out.println("instanceVarName==" + obj.instanceVarName);
 
        InstanceVariable obj1 = new InstanceVariable();
        obj1.instanceVarId = 0002;
        obj1.instanceVarName = "InstanceVariable2";
        System.out.println("Displaying Second Object:");
        System.out.println("instanceVarId==" + obj1.instanceVarId);
        System.out.println("instanceVarName==" + obj1.instanceVarName);
    }
}

输出：

Displaying first Object:
instanceVarId==1
instanceVarName==InstanceVariable1
Displaying Second Object:
instanceVarId==2
instanceVarName==InstanceVariable2

在上述程序中，变量即instanceVarId、instanceVarName 是实例变量。如果我们在上面的程序中有多个对象，每个对象都有自己的实例变量副本。从上面的输出可以清楚地看出，每个对象都有自己的实例变量副本。
静态变量：静态变量也称为类变量。

• 这些变量的声明方式与实例变量类似，不同之处在于静态变量是在任何方法构造函数或块之外的类中使用 static 关键字声明的。
• 与实例变量不同，无论我们创建了多少对象，每个类只能拥有一个静态变量的副本。
• 静态变量在程序执行开始时创建，并在执行结束时自动销毁。

要访问静态变量，我们不需要创建该类的对象，我们可以简单地访问该变量：

Java

// Java program to demonstrate static variables
public class StaticVar {
    private static int count = 0;
    private int nonStaticCount = 0;
 
    public void incrementCounter()
    {
        count++;
        nonStaticCount++;
    }
    public static int getStaticCount()
    {
        return count;
    }
    public int getNonStaticCount()
    {
        return nonStaticCount;
    }
    public static void main(String args[])
    {
        StaticVar stVarObj1 = new StaticVar();
        StaticVar stVarObj2 = new StaticVar();
        stVarObj1.incrementCounter();
        stVarObj2.incrementCounter();
        System.out.println("Static count for stVarObj1: " +
                               stVarObj1.getStaticCount());
        System.out.println("NonStatic count for stVarObj1: " +
                                 stVarObj1.getNonStaticCount());
        System.out.println("Static count for stVarObj2: " +
                                 stVarObj2.getStaticCount());
        System.out.println("NonStatic count for stVarObj2: " +
                                 stVarObj2.getNonStaticCount());
    }
}

输出：

Static count for stVarObj1: 2
NonStatic count for stVarObj1: 1
Static count for stVarObj2: 2
NonStatic count for stVarObj2: 1

在上述程序中，stVarObj1 和 stVarObj2 共享静态变量计数的相同实例，因此如果值增加一个对象，增加的值将反映在 stVarObj1 和 stVarObj2 上。