阿里Java軟件開發工程師Java基礎面試題集合

1.如果main方法被聲明爲private會怎樣？
能正常編譯，但運行時會提示“main方法不是public”，運行報錯，private的權限不足。

拓展：
public 公共的，誰都可以調用
private 是私有的，不能被其他類或方法調用
protected 是受保護的，子類，父類可以調用

2.Java裏的傳引用和傳值的區別是什麼？
1)、“傳值”傳遞的是一個值，而“傳引用”傳遞的是指向一個另一塊內存空間的地址；

2)、“傳值”實際是將一個值的拷貝傳遞至方法內部，這個值的原始數據是不會改變的，無論你內部進行的是何種操作，都不會改變這個源數據的值；而“傳引用”傳遞進去的則是指向一個對象的地址，那麼在方法內部進行實際操作的時候，就很可能會改變該對象的屬性值（當然具體是否改變，還需要結合具體的業務）。

int、long、float、double、char、boolean、short、byte.這8種基本的數據類型作爲參數進行傳遞是，都是進行的傳值。String也是傳值

3.如果要重寫一個對象的equals方法，還要考慮什麼？
hashCode。
在重寫父類的equals方法時，也重寫hashcode方法，使相等的兩個對象獲取的HashCode也相等，這樣當此對象做Map類中的Key時，兩個equals爲true的對象其獲取的value都是同一個，比較符合實際。

4.Java的”一次編寫，處處運行”是如何實現的？
Java程序會被編譯成字節碼組成的class文件，這些字節碼可以運行在任何平臺，因此Java是平臺獨立的。

Hello.java- -編譯 ->Hello.class- ClassLoader裝載- ->JVM- ->字節碼驗證

->對字節碼逐行解析- ->執行
->JIT（即時編譯） - ->執行

5.說明一下public static void main(String args[])這段聲明裏每個關鍵字的作用

用來定義主函數/主方法 – 作爲程序的入口
public – 公開的
static – 靜態的
void – 無/空，沒有返回值的
main – 方法名
() – 是方法的標誌
String[] args – 是方法的參數
String是命令行傳進參數的類型
args是指命令行傳進的字符串數組
{ Java代碼 }

6.==與equals的區別
==比較兩個對象在內存裏是不是同一個對象，就是說在內存裏的存儲位置一致。兩個String對象存儲的值是一樣的，但有可能在內存裏存儲在不同的地方 .

比較的是引用而equals方法比較的是內容。public boolean equals(Object obj) 這個方法是由Object對象提供的，可以由子類進行重寫。默認的實現只有當對象和自身進行比較時纔會返回true,這個時候和是等價的。String, BitSet, Date, 和File都對equals方法進行了重寫，對兩個String對象而言，值相等意味着它們包含同樣的字符序列。對於基本類型的包裝類來說，值相等意味着對應的基本類型的值一樣。

public class EqualsTest {
               public static void main(String[] args) {
                               String s1 = “abc”;
                               String s2 = s1;
                               String s5 = “abc”;
                               String s3 = new String(”abc”);
                               String s4 = new String(”abc”);
                               System.out.println(”== comparison : ” + (s1 == s5));
                               System.out.println(”== comparison : ” + (s1 == s2));
                               System.out.println(”Using equals method : ” + s1.equals(s2));
                               System.out.println(”== comparison : ” + s3 == s4);
                               System.out.println(”Using equals method : ” + s3.equals(s4));
               }
}
結果：
== comparison : true
== comparison : true
Using equals method : true
false
Using equals method :true

7.如果去掉了main方法的static修飾符會怎樣？
程序能正常編譯。運行時會拋NoSuchMethodError異常。

拓展：

在類中，變量的前面有修飾符static稱爲靜態變量（類變量），方法的前面有修飾符static稱爲靜態方法（類方法）。靜態方法和靜態變量是屬於某一個類，而不屬於類的對象。
如果一個方法沒有用static來修飾的話就說明這是一個成員方法，只能通過對象來調用這個方法
在Java程序運行時，是沒有實例化任何對象的，只能通過調用類方法來運行main方法，所以會用static來修飾

8.爲什麼oracle type4驅動被稱作瘦驅動？
oracle提供了一個type 4 JDBC驅動，被稱爲瘦驅動。
這個驅動包含了一個oracle自己完全用Java實現的一個TCP/IP的Net8的實現，因此它是平臺獨立的，可以在運行時由瀏覽器下載，不依賴任何客戶端的oracle實現。客戶端連接字符串用的是TCP/IP的地址端口，而不是數據庫名的tnsname。

9.介紹一下finalize方法
final: 常量聲明。 finally: 處理異常。 finalize: 幫助進行垃圾回收。

接口裏聲明的變量默認是final的。final類無法繼承，也就是沒有子類。這麼做是出於基礎類型的安全考慮，比如String和Integer。這樣也使得編譯器進行一些優化，更容易保證線程的安全性。final方法無法重寫。final變量的值不能改變。finalize()方法在一個對象被銷燬和回收前會被調用。finally,通常用於異常處理，不管有沒有異常被拋出都會執行到。比如，關閉連接通常放到finally塊中完成。

10.什麼是Java API？
（Application Programming Interface,應用程序編程接口）是一些預先定義的函數，目的是提供應用程序與開發人員基於某軟件或硬件的以訪問一組例程的能力，而又無需訪問源碼，或理解內部工作機制的細節。

拓展：
GUI API包含的類分爲三個部分:組件類(component class) 容器類(container class),和輔助類(helper class)

組件類是用來創建用戶圖形界面的,例如JButton,JLabel,JTextField.
容器類是用來包含其他組件的,例如JFrame,JPanel
輔助類是用來支持GUI組件的,例如Color,Font

11.GregorianCalendar類是什麼東西？
GregorianCalendar提供了西方傳統日曆(公曆)的支持。

12.ResourceBundle類是什麼?
ResourceBundle用來存儲指定語言環境的資源，應用程序可以根據運行時的語言環境來加載這些資源，從而提供不同語言的展示。

13.爲什麼Java裏沒有全局變量?
全局變量是全局可見的，Java不支持全局可見的變量，因爲：全局變量破壞了引用透明性原則。全局變量導致了命名空間的衝突。

14.如何將String類型轉化成Number類型？
Integer類的valueOf方法可以將String轉成Number。下面是代碼示例：、
String numString = “1000″;
int id=Integer.valueOf(numString).intValue();

15.SimpleTimeZone類是什麼?
SimpleTimeZone提供公曆日期支持。

16.while循環和do循環有什麼不同？
while結構在循環的開始判斷下一個迭代是否應該繼續。do/while結構在循環的結尾來判斷是否將繼續下一輪迭代。do結構至少會執行一次循環體。

17.Locale類是什麼？
Locale類用來根據語言環境來動態調整程序的輸出。、

18.面向對象編程的原則是什麼?
主要有三點，多態，繼承和封裝。

封裝性，把相關的數據封裝成一個“類”組件
繼承性，是子類自動共享父類屬性和方法，這是類之間的一種關係
多態，增強軟件的靈活性和重用性

19.介紹下繼承的原則
繼承使得一個對象可以獲取另一個對象的屬性。使用繼承可以讓已經測試完備的功能得以複用，並且可以一次修改，所有繼承的地方都同時生效。

20.什麼是隱式的類型轉化?
隱式的類型轉化就是簡單的一個類型賦值給另一個類型，沒有顯式的告訴編譯器發生了轉化。並不是所有的類型都支持隱式的類型轉化。

隱式轉換（也就是自動轉換）就是小轉大：例如double a=1;1是一個整型，但是在賦度值和運算的時候會自動轉換成回double a=1.00這種情況，顯示轉換（也叫強制轉換）答就是大轉小：例如int a = (int)12.4,這種裝換會丟失精度

21.sizeof是Java的關鍵字嗎?
不是，sizeof是C/C++裏面的關鍵字。

22.native方法是什麼?
native方法主要用於加載文件和動態鏈接庫，是非Java代碼實現的方法，需要用c語言重寫。

23.在System.out.println()裏面,System, out, println分別是什麼?
System是系統提供的預定義的final類，out是一個PrintStream對象，println是out對象裏面一個重載的方法。

向控制檯打印指定內容
System – 發出系統指令
out – 向外輸出的動作
println – 打印後換行
() – 是方法的標誌

24.封裝，繼承和多態是什麼？
封裝是指隱藏對象的屬性和實現細節
僅僅對外提供公共的訪問方式。
好處：
1、提高安全性
2、提高重用性

//創建學生類--描述學生事物 屬性+行爲

public class Student {
      
//    屬性   -- 成員變量
       private String name;//被私有化的資源無法訪問
      
       //提供公共的訪問方式 --setXxx()進行設置值
       public void setName(String n) {
              name = n;//給成員變量name賦值
       }
      
       //提供公共的訪問方式 --getXxx()進行獲取值
       public String getName(){
              return name;//把name屬性的值，返回調用位置
       }
      
      
       //TODO  封裝以下屬性，並提供公共的set()/get()
       int sno;//學號
       String subject;//學科
       double score;//成績
       int age;
       String addr;
      
      
//    行爲  -- 成員方法
       //通過private關鍵字，實現封裝，私有化資源
       private void study() {
              System.out.println("正在學習");
       }
      
       public void eat() {
              System.out.println("正在吃飯");
       }
      
}

//測試學生類的使用
public class Test4_Student {
 
       public static void main(String[] args) {
              //TODO 創建學生對象測試
              Student s = new Student();
              //設置屬性值
//           s.name="蔡徐坤";//被私有化的資源無法訪問
              s.setName("蔡徐坤");//私有化後可以訪問公共的set()設置值
              s.age=20;
              s.subject="java";
              s.sno=1;
              s.score=20;
              s.addr="北京";
             
              //打印屬性值
//           System.out.println(s.name);//被私有化的資源無法訪問
              //私有化後可以訪問公共的get()獲取值
              System.out.println(s.getName()+"=========");
              System.out.println(s.age);
              System.out.println(s.subject);
              System.out.println(s.sno);
              System.out.println(s.score);
              System.out.println(s.addr);
             
              //調用功能
              s.eat();
//           s.study();//被私有化的資源，本類之外的類都無法訪問
             
       }
 
}

繼承是從已有的類中派生出新的類，新的類能吸收已有類的數據屬性和行爲，並能擴展新的能力。
Java繼承是使用已存在的類的定義作爲基類/父類/超類，新類的定義可以增加新的數據或新的功能，也可以用父類的功能。
但不能選擇性地繼承父類(超類，基類)。
這種技術使得複用以前的代碼非常容易，能夠大大縮短開發週期，降低開發費用。

//繼承的入門案例
public class Test6_Extends {
       public static void main(String[] args) {

              //TODO 創建子類Dog對象測試
              Dog d = new Dog();
              d.eat();//2.1、可以使用父類的所有功能
             
              //TODO 創建DaHuang類對象測試
              DaHuang huang = new DaHuang();
              huang.eat();//4.1、繼承可以傳遞
              //5、父類的私有成員，子類無法繼承
//           System.out.println(huang.sum);
             
       }
}
//創建父類
class Animal{
       public void eat() {
              System.out.println("吃啥都行");
       }
}

//創建子類
//1、extends關鍵字用來表示繼承關係
//3、java中只支持單繼承 , 是 is a 的關係 , 子類要強制繼承父類，才能用父類的功能
class Dog extends Animal{  //耦合性強--兩者的關係就是強制依賴
       //2、子類繼承父類就能無償使用，因爲相當於把父類的功能複製了一份
       private int sum = 10;
      
}
//創建孫子類
class DaHuang extends Dog{
       //4、繼承可以傳遞,Animal的功能也能用
}

多態指同一個實體同時具有多種形式。
它是面向對象程序設計（OOP）的一個重要特徵。
主要是指同一個對象，在不同時刻，代表的對象不一樣，指的是對象的多種形態。
好處是可以把不同的子類對象都當作父類來看，可以屏蔽不同子類對象之間的差異，
寫出通用的代碼，做出通用的編程，統一調用標準。

//多態的入門案例
public class Test5_DuoTai {
    public static void main(String[] args) {
      
		//TODO 創建父類對象測
       Fu f = new Fu();f.eat();//爸爸在吃肉
       //TODO 創建子類對象測
       Zi z = new Zi();z.eat();//兒子在喝湯
      
		//TODO 創建多態對象測
       //1、多態：統一調用標準，統一隻能調用父類提供的功能
       Fu f2 = new Zi();//父類引用， 指向 子類對象
       //2、編譯看左邊--想要保存，需要調用左邊的功能
       //3、運行看右邊  -- 運行的結果，怎麼幹活的，看右邊看子類的實現方式
       f2.eat();//調用的是父類的eat()，但是結果是子類重寫後的效果
       f2.show();

    }
}

//創建父類
class Fu{
    public void eat() {
       System.out.println("爸爸在吃肉");
    }

    public void show() {
       System.out.println("兒子在喝湯");
    }
}

//創建子類
//4、多態的前提1：發生繼承關係
class Zi extends Fu{
    //5、多態的前提2：發生方法重寫
    public void eat() {
       System.out.println("兒子在喝湯");
    }

}

25.顯式的類型轉化是什麼?
顯式的類型轉化是明確告訴了編譯器來進行對象的轉化。
顯示轉換（也叫強制轉換）答就是大轉小：例如int a = (int)12.4,這種裝換會丟失精度

代碼示例：
long i = 700.20;
int j = (int) i; //Explicit casting

26.什麼是Java虛擬機?
虛擬機是一種抽象化的計算機，通過在實際的計算機上仿真模擬各種計算機功能來實現的。Java虛擬機有自己完善的硬體架構，如處理器、堆棧、寄存器等，還具有相應的指令系統。

27.類型向下轉換是什麼?
向下轉換：就是父類轉爲子類；
向上轉換：子類轉換爲父類

     package com.wensefu.other1;  
    public class Girl {  
        public void smile(){  
            System.out.println("girl smile()...");  
        }  
    }  
    class MMGirl extends Girl{  
          
        @Override  
        public void smile() {  
              
            System.out.println("MMirl smile sounds sweet...");  
        }  
        public void c(){  
            System.out.println("MMirl c()...");  
        }  
    }  
    class Main{  
          
        public static void main(String[] args) {  
              
            Girl g1=new MMGirl(); //向上轉型  
            g1.smile();  
              
            MMGirl mmg=(MMGirl)g1; //向下轉型,編譯和運行皆不會出錯  
            mmg.smile();  
            mmg.c();  
              
              
            Girl g2=new Girl();  
    //      MMGirl mmg1=(MMGirl)g2; //不安全的向下轉型,編譯無錯但會運行會出錯  
    //      mmg1.smile();  
    //      mmg1.c();  
    /*output: 
    * CGirl smile sounds sweet... 
    * CGirl smile sounds sweet... 
    * CGirl c()... 
    * Exception in thread "main" java.lang.ClassCastException: com.wensefu.other1.Girl 
    * at com.wensefu.other1.Main.main(Girl.java:36) 
    */  
            if(g2 instanceof MMGirl){  
                MMGirl mmg1=(MMGirl)g2;   
                mmg1.smile();  
                mmg1.c();  
            }  
              
        }  
    }

28.Java的訪問修飾符是什麼?
訪問權限修飾符是表明類成員的訪問權限類型的關鍵字。使用這些關鍵字來限定程序的方法或者變量的訪問權限。它們包含：
public: 所有類都可以訪問
protected: 同一個包內以及所有子類都可以訪問
private: 只有歸屬的類才能訪問默認: 歸屬類及相同包下的子類可以訪問
不寫時爲默認：當前類和同一個package

29.所有類的父類是什麼？
Object

30.Java的基礎類型有哪些？
byte，char，short，int，float，double，boolean。

31.靜態類型有什麼特點？
靜態變量是和類綁定到一起的，而不是類的實例對象。每一個實例對象都共享同樣一份靜態變量。也就是說，一個類的靜態變量只有一份，不管它有多少個對象。類變量或者說靜態變量是通過static這個關鍵字來聲明的。類變量通常被用作常量。靜態變量通常通過類名字來進行訪問。當程序運行的時候這個變量就會創建直到程序結束後纔會被銷燬。類變量的作用域和實例變量是一樣的。它的初始值和成員變量也是一樣的，當變量沒被初始化的時候根據它的數據類型，會有一個默認值。類似的，靜態方法是屬於類的方法，而不是類對象，它的調用並不作用於類對象，也不需要創建任何的類實例。靜態方法本身就是final的，因爲重寫只會發生在類實例上，靜態方法是和類綁定在一起的，不是對象。父類的靜態方法會被子類的靜態方法屏蔽，只要原來方法沒有聲明爲final。非靜態方法不能重寫靜態方法，也就是說，你不能在子類中把一個靜態方法改成實例方法。
非靜態變量在每一個對象實例上都有單獨的一份值。

32.&操作符和&&操作符有什麼區別?
當一個&表達式在求值的時候，兩個操作數都會被求值，&&更像是一個操作符的快捷方式。當一個&&表達式求值的時候，先計算第一個操作數，如果它返回true纔會計算第二個操作數。如果第一個操作數取值爲fale,第二個操作數就不會被求值。

33.Java始如何處理整型的溢出和下溢的？
Java根據類型的大小，將計算結果中的對應低階字節存儲到對應的值裏面。

34.public static void寫成static public void會怎樣？
程序正常編譯及運行。

35.聲明變量和定義變量有什麼不同？
聲明變量我們只提供變量的類型和名字，並沒有進行初始化。定義包括聲明和初始化兩個階段String s;只是變量聲明，String s = new String(“bob”); 或者String s = “bob”;是變量定義。

36.Java支持哪種參數傳遞類型？
Java參數都是進行傳值。對於對象而言，傳遞的值是對象的引用，也就是說原始引用和參數引用的那個拷貝，都是指向同一個對象。

37.對象封裝的原則是什麼？
封裝是將數據及操作數據的代碼綁定到一個獨立的單元。這樣保障了數據的安全，防止外部代碼的錯誤使用。對象允許程序和數據進行封裝，以減少潛在的干涉。對封裝的另一個理解是作爲數據及代碼的保護層，防止保護層外代碼的隨意訪問。

38.你怎麼理解變量？
變量是一塊命名的內存區域，以便程序進行訪問。變量用來存儲數據，隨着程序的執行，存儲的數據也可能跟着改變。

39.數值提升是什麼?
數值提升是指數據從一個較小的數據類型轉換成爲一個更大的數據類型，以便進行整型或者浮點型運算。在數值提升的過程中，byte,char,short值會被轉化成int類型。需要的時候int類型也可能被提升成long。long和float則有可能會被轉換成double類型

40.Java的類型轉化是什麼?
從一個數據類型轉換成另一個數據類型叫做類型轉換。Java有兩種類型轉換的方式，一個是顯式的類型轉換，一個是隱式的。

41.main方法的參數裏面，字符串數組的第一個參數是什麼?
數組是空的，沒有任何元素。不像C或者C++，第一個元素默認是程序名。如果命令行沒有提供任何參數的話，main方法中的String數組爲空,但不是null。

42.怎麼判斷數組是null還是爲空?
輸出array.length的值，如果是0,說明數組爲空。如果是null的話，會拋出空指針異常。

43.程序中可以允許多個類同時擁有都有main方法嗎?
可以。當程序運行的時候，我們會指定運行的類名。JVM只會在你指定的類中查找main方法。因此多個類擁有main方法並不存在命名衝突的問題。

44.靜態變量在什麼時候加載？編譯期還是運行期？靜態代碼塊加載的時機呢？
當類加載器將類加載到JVM中的時候就會創建靜態變量，這跟對象是否創建無關。靜態變量加載的時候就會分配內存空間。靜態代碼塊的代碼只會在類第一次初始化的時候執行一次。一個類可以有多個靜態代碼塊，它並不是類的成員，也沒有返回值，並且不能直接調用。靜態代碼塊不能包含this或者super,它們通常被用初始化靜態變量。

45.一個類能擁有多個main方法嗎？
可以，但只能有一個main方法擁有以下簽名：
public static void main(String[] args) {}
否則程序將無法通過編譯。編譯器會警告你main方法已經存在。

46.簡單的介紹下JVM是如何工作的?
JVM是一臺抽象的計算機，就像真實的計算機那樣，它們會先將.java文件編譯成.class文件（.class文件就是字節碼文件）,然後用它的解釋器來加載字節碼。

Hello.java- -編譯 ->Hello.class- ClassLoader裝載- ->JVM- ->字節碼驗證

47.如何原地交換兩個變量的值？
先把兩個值相加賦值給第一個變量，然後用得到的結果減去第二個變量，賦值給第二個變量。再用第一個變量減去第二個變量，同時賦值給第一個變量。代碼如下：
int a=5,b=10;a=a+b; b=a-b; a=a-b;
使用異或操作也可以交換。第一個方法還可能會引起溢出。異或的方法如下：
int a = 5; int b = 10;
a = a ^ b;
b = a ^ b;
a = a ^ b;

48.什麼是數據的封裝
數據封裝的一種方式是在類中創建set和get方法來訪問對象的數據變量。一般來說變量是private的，而get和set方法是public的。封裝還可以用來在存儲數據時進行數據驗證，或者對數據進行計算，或者用作自省（比如在struts中使用javabean）。把數據和功能封裝到一個獨立的結構中稱爲數據封裝。封裝其實就是把數據和關聯的操作方法封裝到一個獨立的單元中，這樣使用關聯的這些方法才能對數據進行訪問操作。封裝提供的是數據安全性,它其實就是一種隱藏數據的方式。

49.什麼是反射API？它是如何實現的？
反射是指在運行時能查看一個類的狀態及特徵，並能進行動態管理的功能。這些功能是通過一些內建類的反射API提供的，比如Class,Method,Field, Constructors等。使用的例子：使用Java反射API的getName方法可以獲取到類名。

50.JVM自身會維護緩存嗎，是不是在堆中進行對象分配，操作系統的堆還是JVM自己管理的堆？爲什麼？
是的，JVM自身會管理緩存，它在堆中創建對象，然後在棧中引用這些對象。

51.虛擬內存是什麼?
虛擬內存又叫延伸內存，實際上並不存在真實的物理內存。

52.方法可以同時即是static又是synchronized的嗎?
可以。如果這樣做的話，JVM會獲取和這個對象關聯的java.lang.Class實例上的鎖。這樣做等於：
synchronized(XXH.class) {
}

53.String和StringTokenizer的區別是什麼？
StringTokenizer是一個用來分割字符串的工具類。

StringTokenizer st = new StringTokenizer(”Hello World”);
while (st.hasMoreTokens()) {
    System.out.println(st.nextToken());
}
輸出：
Hello
World

54.transient變量有什麼特點?
transient變量不會進行序列化。例如一個實現Serializable接口的類在序列化到ObjectStream的時候，transient類型的變量不會被寫入流中，同時，反序列化回來的時候，對應變量的值爲null。

55.哪些容器使用Border佈局作爲它們的默認佈局?
Window, Frame, Dialog。

56.怎麼理解什麼是同步?
同步用來控制共享資源在多個線程間的訪問，以保證同一時間內只有一個線程能訪問到這個資源。在非同步保護的多線程程序裏面，一個線程正在修改一個共享變量的時候，可能有另一個線程也在使用或者更新它的值。同步避免了髒數據的產生。

阿里Java軟件開發工程師Java基礎面試題集合

認知提升的方法

螞蟻面試：Springcloud核心組件的底層原理，你知道多少？

java入門 | HelloWorld -- welcome to join us

java入門 | 八大基礎類型

阿里Java軟件開發工程師Java基礎面試題集合

RabbitMQ學習：RabbitMQ的六種工作模式之簡單和工作模式(三)

Github 上傳、更新、刪除項目以及修改commit

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結