前 21 个 Java 面试问题

“拆卸” public static void main(String args[])。

新生最流行的 Java 面试问题之一，而且非常简单。

• public是访问修饰符。我们用它来指定访问这个方法。这里修饰符是“public”，所以任何类都可以访问这个方法。

• static. 这个 Java 关键字意味着我们在不创建类的新对象的情况下使用此方法。

• Void是方法的返回类型。这意味着该方法不返回任何值。

• main是方法的名称。JVM“知道”它是应用程序的入口点（它应该有一个特定的签名）。Main是主要执行发生的方法。

• String args[]. 这是传递给 main 方法的参数。这里我们有 Java 应用程序在运行时接受的 String 类型的参数。您可以在终端上输入它们。

equals()和 和有什么不一样==？

首先，“ ==”是一个运算符，而equals()是一个方法。我们使用==运算符进行引用比较（或地址比较）和equals()方法进行内容比较。这意味着在比较对象中的值==时检查两个对象是否指向相同的内存位置。equals()

我们可以在没有方法的情况下执行程序吗main()？

很多java基础面试题真的很简单。像这个。简短的回答是：是的，我们可以。例如，我们可以使用静态块来做到这一点。

您可以使用静态块来初始化静态数据成员。它在方法之前执行main，在类加载时执行。

class Example{  
 Static{
System.out.println("static block is invoked");
}  
  public static void main(String args[]){  
   System.out.println("Now main method");  
  }  
}

输出是：

static block is invoked
Now main method

什么是immutable对象？你能创建immutable对象吗？

您不能immutable在创建后修改类的对象。因此，一旦创建它们，就无法更改它们。如果您尝试修改Immutable对象，您会得到一个新对象（克隆）并在创建时更改此克隆。

一个很好的例子是String，它是immutable用 Java 编写的。这意味着您不能更改对象本身，但可以更改对该对象的引用。

以下代码创建了多少个对象？

替代#4 的 Java 技术面试问题之一。

String s1="Hello";  
String s2="Hello";  
String s3="Hello";  

答案是“只有一个”，因为 Java 有一个字符串池。当我们使用 new() 运算符创建一个 String 对象时，它会在堆内存中创建一个新对象。如果我们使用 String 文字语法，就像在我们的示例中一样，它可能会从 String 池中返回一个现有对象（如果它已经存在）。

以下代码创建了多少个对象？

String s = new String("Hello");

有 2 个对象。一个在字符串常量池中（如果不存在的话），另一个在堆中。

StringJava 中的类和StringBuilder类之间有什么区别StringBuffer？

在顶级 Java 面试问题中有一位领导者。

首先String是一个不可变类。这意味着您不能在创建后修改其内容。WhileStringBuffer和StringBuilder是可变类，因此您可以稍后更改它们。如果我们更改String对象的内容，它会创建一个新字符串，因此不会修改原始字符串。这就是为什么 with 的性能StringBuffer优于 with 的原因String。

StringBuffer和StringBuilderthatStringBuffer的方法之间的主要区别是同步的，而StringBuilder's 不是。

String使用文字和使用运算符创建的有什么区别吗new()？

有。如果我们使用new()运算符创建一个 String，它会出现在堆和字符串池中（如果不存在的话）。如果您String使用文字创建一个，它会在字符串池中创建（如果不存在的话）。字符串池是堆内的一个存储区域，用于存储字符串文字。

您可以在 Java 中覆盖private或方法吗？static

新手的 java 棘手面试问题之一。您真的不能在 Java 中重写private或static方法。

您不能覆盖这些private方法，因为私有访问说明符的范围仅在类内。当你要覆盖某些东西时，我们应该有父类和子类。如果父类的方法是private，则子类不能使用它，子类中的方法将被视为新方法（不会被覆盖）。

Static方法也不能被覆盖，因为static方法是类本身的一部分，而不是类的任何对象的一部分。static当然，您可以在子类中声明具有相同签名的相同方法，但同样，它们将被视为新方法。

Abstract Class和之间的区别Interface

与 OOP 原则相关的流行 Java 开发人员面试问题之一。首先，在 Java 中interface定义一个行为并abstract class创建层次结构。

我们可以static在类中声明变量和方法吗abstract？

是的，可以static在方法中声明变量和方法abstract。不需要使对象访问静态上下文。所以我们可以abstract通过类名访问类内部声明的静态上下文abstract。

JVM分配了哪些类型的内存区域？

类区存储每个类的结构，例如，运行时常量池、字段、方法数据以及方法的所有代码。

堆是一个运行时数据区域，内存分配给对象。

堆栈存储帧。它包含局部变量和部分结果，并参与方法调用和返回。每个线程都有一个私有的 JVM 堆栈，与线程同时创建。每次调用方法时都会创建一个新框架。框架在其方法调用完成时被销毁。

程序计数器寄存器包含当前正在执行的 Java 虚拟机指令的地址。

本机方法堆栈包含应用程序中使用的所有本机方法。

为什么java中不允许多重继承？

这真的很复杂。想象三个类A, B,C和C继承Aand B。现在，A类B具有相同的方法，您可以从子类对象调用它……哪个？A的还是B？这里我们有歧义。

如果您尝试继承两个类，Java 会呈现编译时错误。

我们可以重载该main()方法吗？

当然，通过使用方法重载，我们可以main在 Java 程序中拥有许多方法。试试看！

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

没有。构造函数不能声明为 afinal因为它不能被继承。所以将构造函数声明为final. 但是，如果您尝试这样做，Java 编译器会向您抛出一个错误。

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

不，我们不能这样做。接口不能是final因为接口应该由某个类根据其定义来实现。所以做接口是没有意义的final。但是，如果您尝试这样做，编译器将显示错误。

static binding和 和有什么不一样dynamic binding？

可以由编译器binding在编译时解析的调用static或早期绑定。Binding所有static,private和final方法都是在编译时完成的。

在Dynamic binding编译器中无法选择要调用的方法。覆盖是一个完美的例子dynamic binding。重写父类和子类具有相同的方法。

Static Binding
class Cat{  
 private void talk()
{System.out.println("cat is mewing...");
}  
  
 public static void main(String args[]){  
  Cat cat=new Cat();  
  cat.talk();  
 }  
}  
Dynamic Binding
class Animal{  
 void talk(){
System.out.println("animal is talking...");
}  
}  
  
class Cat extends Animal{  
 void talk(){
System.out.println("cat is talking...");
}    
 public static void main(String args[]){  
  Animal animal=new Cat();  
  animal.talk();  
 }  
}

如何在 Java 中创建只读类？

您可以通过将所有类的字段设为私有来实现。只读类只有 getter 方法，这些方法将类的私有属性返回给方法main。您无法修改此属性，原因是缺少 setter 方法。

public class HockeyPlayer{    
private String team ="Maple leaf";    
public String getTeam(){    
return team;    
}    
}

如何在 Java 中创建只写类？

同样，您应该制作所有课程的字段private。现在，您的只写类应该只有 setter 方法而没有 getter。因此，我们无法读取类的属性。

public class HockeyPlayer{       
private String team;    
public void setTeam(String college){    
this.team = team;    
}    
}    

每个try块后面必须跟一个catch块，不是吗？

没有。这不是必须的。每个try块可以没有catch块。它后面可以跟一个 catch 块或 finally 块，甚至根本没有它们。

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

输出：

Exception in thread main java.lang.ArithmeticException:/ by zero
the other part of the program...

class Main {
        public static void main(String[] args) throws IOException {
            try(InputStreamReader inputStreamReader = new InputStreamReader(System.in);
                BufferedReader reader = new BufferedReader(inputStreamReader)){
                System.out.println("test");
            }
        }
    }

输出：

test

throw和关键字有什么区别throws？

Throws用于声明异常，因此它的工作方式类似于块try-catch。Throw关键字用于从方法或任何其他代码块中显式抛出异常。

Throw后跟一个Exception类的实例，throws 后跟异常类名。

Throw在方法体中用于抛出异常。Throws在方法签名中用于声明方法中存在的语句中可能发生的异常。

允许一次抛出一个异常，但您可以通过使用throw关键字声明它们来处理多个异常。您可以声明多个异常，例如，public void method()throws IOException, SQLException。