前 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使用文字創建一個，它將在字符串池中創建（如果尚不存在）。字符串池是堆內的一個存儲區域，用於存儲字符串文字。

您可以在 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。