Java基礎知識整理

面向對象和麪向過程的區別

面向過程
優勢: 性能比面向對象高,由於類調用時須要實例化,開銷比較大,比較消耗資源;好比單片機、嵌入式開發、Linux/Unix等通常採用面向過程開發,性能是最重要的因素。
缺點: 沒有面向對象易維護、易複用、易擴展java

面向對象
優勢: 易維護、易複用、易擴展,因爲面向對象有封裝、繼承、多態性的特性,能夠設計出低耦合的系統,使系統更加靈活、更加易於維護
缺點: 性能比面向過程低編程

獲取用鍵盤輸入經常使用的的兩種方法

  1. 經過 Scanner設計模式

    Scanner input = new Scanner(System.in);
    String s  = input.nextLine();
    input.close();
  2. 經過 BufferedReader數組

    BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); 
    String s = input.readLine();

Java 面向對象編程三大特性: 封裝 繼承 多態

封裝
把一個對象的屬性私有化,同時提供一些能夠被外界訪問的屬性的方法,若是屬性不想被外界訪問,咱們大可沒必要提供方法給外界訪問。可是若是一個類沒有提供給外界訪問的方法,那麼這個類也沒有什麼意義了。安全

繼承
繼承是使用已存在的類的定義做爲基礎創建新類的技術,新類的定義能夠增長新的數據或新的功能,也能夠用父類的功能,但不能選擇性地繼承父類。經過使用繼承咱們可以很是方便地複用之前的代碼。多線程

  1. 子類擁有父類非 private 的屬性和方法。
  2. 子類能夠擁有本身屬性和方法,即子類能夠對父類進行擴展。
  3. 子類能夠用本身的方式實現父類的方法。

多態
指程序中定義的引用變量所指向的具體類型和經過該引用變量發出的方法調用在編程時並不肯定,而是在程序運行期間才肯定,即一個引用變量到底會指向哪一個類的實例對象,該引用變量發出的方法調用究竟是哪一個類中實現的方法,必須在由程序運行期間才能決定。
在Java中有兩種形式能夠實現多態:繼承(多個子類對同一方法的重寫)和接口(實現接口並覆蓋接口中同一方法)。app

重載和重寫的區別

方法重載是指同一個類中的多個方法具備相同的名字,但這些方法具備不一樣的參數列表,即參數的數量或參數類型不能徹底相同
(相同名字,不一樣參數)框架

方法重寫是存在子父類之間的,子類定義的方法與父類中的方法具備相同的方法名字,相同的參數表和相同的返回類型
(相同名字,相同類型)(繼承)ide

爲何函數不能根據返回類型來區分重載

由於調用時不能指定類型信息
如:函數

float max(int a,int b)
int max(int a,int b)

當調用max(1,2)時,沒法肯定

抽象類(abstract)和接口(interface)

選擇使用接口和抽象類的依據抽象類是對最本質的抽象,接口是對動做的抽象
如:男人、女人是兩個類,那能夠抽象出一個類,人;人能夠吃東西,學習等等,這些行爲就是一個個接口

抽象的(abstract)方法是否可同時是靜態的(static),是否可同時是本地方法(native),是否可同時被synchronized?

都不能。抽象方法須要子類重寫,而靜態的方法是沒法被重寫的;本地方式是由本地代碼實現的方法,而抽象方法是沒有實現的;synchronized和方法的實現細節有關,抽象方法不涉及實現細節,所以都不能。

靜態變量和實例變量的區別

靜態變量:被static修飾的變量,也稱爲類的變量,屬於類,不屬於類的任何一個對象,一個類無論建立多少對象,靜態變量在內存只有一個拷貝,能夠實現讓多個對象共享內存
實例變量:必須依存某一實例,須要建立對象才能經過對象去訪問它。

String、StringBuffer、StringBulider

  1. String是引用類型,底層由char數組實現
  2. String:字符串常量,在修改時布改變自身,修改等於從新生成新的自符串對象;

StringBuffer:在修改時會改變對象自身,每次操做都是對StringBuffer對象自己進行修改,不是生成新的對象,使用場景是:對字符串常常改變狀況下,主要方法:append()

  1. 線程安全:

String:定義對象後不可變,線程安全
StringBuffer:線程安全,對調用的方法加入同步鎖,執行效率較慢,適用於多線程下操做字符串緩衝區大量數據
StringBuilderer:線程不安全,適用於單線程下操做字符串緩衝區大量數據

  1. 當咱們使用"+"時,編譯器轉換成了StringBuilder,因此不要在for語句內使用;同時儘可能不要"+"和StringBuilder一塊兒使用

對於三者使用的總結
操做少許的數據 String
單線程操做字符串緩衝區下操做大量數據 StringBuilder
多線程操做字符串緩衝區下操做大量數據 StringBuffer

一個類的構造方法的做用是什麼 若一個類沒有聲明構造方法,該程序能正確執行嗎 ?爲何?

主要做用是完成對類對象的初始化工做。能夠執行。由於一個類即便沒有聲明構造方法也會有默認的不帶參數的構造方法。

== 與 equals(重要)

== : 它的做用是判斷兩個對象的地址是否是相等。即,判斷兩個對象是否是同一個對象。。(基本數據類型比較的是值,引用數據類型比較的是內存地址)
equals() : 它的做用也是判斷兩個對象是否相等。但它通常有兩種使用狀況:
狀況1:類沒有覆蓋 equals() 方法。則經過 equals() 比較該類的兩個對象時,等價於經過「==」比較這兩個對象。
狀況2:類覆蓋了 equals() 方法。通常,咱們都覆蓋 equals() 方法來兩個對象的內容相等;若它們的內容相等,則返回 true (即,認爲這兩個對象相等)。

public class test1 {

    public static void main(String[] args) {

        String a = new String("ab"); // a 爲一個引用

        String b = new String("ab"); // b爲另外一個引用,對象的內容同樣

        String aa = "ab"; // 放在常量池中

        String bb = "ab"; // 從常量池中查找

        if (aa == bb) // true

            System.out.println("aa==bb");

        if (a == b) // false,非同一對象

            System.out.println("a==b");

        if (a.equals(b)) // true

            System.out.println("a.equals(b)");

        if (42 == 42.0) { // true

            System.out.println("true");

        }

    }

}

說明

  • String 中的 equals 方法是被重寫過的,由於 object 的 equals 方法是比較的對象的內存地址,而 String 的 equals 方法比較的是對象的值。
  • 當建立 String 類型的對象時,虛擬機會在常量池中查找有沒有已經存在的值和要建立的值相同的對象,若是有就把它賦給當前引用。若是沒有就在常量池中從新建立一個 String 對象。

hashCode 與 equals (重要)

  1. 若是兩個對象相等,則hashcode必定也是相同的
  2. 兩個對象相等,對兩個對象分別調用equals方法都返回true
  3. 兩個對象有相同的hashcode值,它們也不必定是相等的
  4. 所以,equals 方法被覆蓋過,則 hashCode 方法也必須被覆蓋
  5. hashCode() 的默認行爲是對堆上的對象產生獨特值。若是沒有重寫 hashCode(),則該 class 的兩個對象不管如何都不會相等(即便這兩個對象指向相同的數據)

length,length(),size()三者的區別

  • length屬性:用於獲取數組長度
int ar[] = new int{1,2,3}
/**
* 數組用length屬性取得長度
*/
int lenAr = ar.length;//此處lenAr=3
System.out.println("Arr length:"+lenAr);
  • length()方法:用於獲取字符串長度
String str = "Hello World Java";

/**
* 字符串用length()方法取得長度
*/

int lenStr = str.length();//此處lenStr=16
System.out.println("Str length():"+lenStr);
  • size()方法:用於獲取泛型集合有多少個元素
/**
* Collection是整個類集之中單值保存的最大父接口,因此使用時須要用具體子類實例化
*/
Collection<String> col = new ArrayList<String>();
col.add("Hello");
col.add("World");
col.add("Java");
/**
* 類集框架用size()方法取元素個數
*/
int sizeCol = col.size();//此處sizeCol=3
System.out.println("Col size:"+sizeCol);

List的三個子類的特色

  • ArrayList 底層是數組,查詢快,增刪慢
  • LinkedList 底層是鏈表,增刪快,查詢慢
  • voctor 底層是數組,線程安全,增刪慢,查詢慢

如何實現數組和 List 之間的轉換

List轉換成爲數組:調用ArrayList的toArray方法。
數組轉換成爲List:調用Arrays的asList方法。

兩個隊列模擬一個堆棧,隊列是先進先出的,堆棧是先進後出的

思路:隊列a和b

入棧:a隊列爲空,b爲空,將「a,b,c,d,e」先放入a中,a進棧爲「a,b,c,d,e」  
  出棧:將a隊列依次加入ArrayList集合c中,以倒序的方法,將c中的集合取出,放入b中,再將b隊列出列
public static void main(String[] args) {
        Queue<String> a = new LinkedList<>();
        Queue<String> b = new LinkedList<>();
        List<String> c = new ArrayList<>();

        a.offer("a");
        a.offer("b");
        a.offer("c");
        a.offer("d");
        a.offer("e");
        System.out.print("進棧:");
        for(String s:a){
            c.add(s);
            System.out.print(s);
        }

        for(int i=c.size()-1;i>=0;i--){
            b.offer(c.get(i));
        }

        System.out.println();
        System.out.print("出棧:");
        for(String s:b){
            System.out.print(s);
        }
    }

隊列offer,add 區別

一些隊列有大小限制,所以若是想在一個滿的隊列中加入一個新項,多出的項就會被拒絕。
這時新的 offer 方法就能夠起做用了。它不是對調用 add() 方法拋出一個 unchecked 異常,而只是獲得由 offer() 返回的 false。

poll,remove 區別:

remove() 和 poll() 方法都是從隊列中刪除第一個元素。remove() 的行爲與 Collection 接口的版本類似, 可是新的 poll() 方法在用空集合調用時不是拋出異常,只是返回 null。所以新的方法更適合容易出現異常條件的狀況。

peek,element區別:

element() 和 peek() 用於在隊列的頭部查詢元素。與 remove() 方法相似,在隊列爲空時, element() 拋出一個異常,而 peek() 返回 null。

HashMap和HashTable的區別

  • HashMap是線程不安全的,是Map的一個子接口,是將鍵映射到值的對象,不容許鍵值重複,容許空鍵和空值,因爲非線程安全,HashMap的效率要較HashTable高
  • HashTable是線程安全的一個集合,不容許null做爲一個key或者value值,是線程安全的

異常處理

在 Java 中,全部的異常都有一個共同的祖先java.lang包中的 Throwable類。
Throwable: 有兩個重要的子類:Exception(異常) 和 Error(錯誤) ,兩者都是 Java 異常處理的重要子類,各自都包含大量子類。
Error(錯誤):是程序沒法處理的錯誤,表示運行應用程序中較嚴重問題。大多數錯誤與代碼編寫者執行的操做無關,而表示代碼運行時 JVM(Java 虛擬機)出現的問題
Exception(異常):是程序自己能夠處理的異常

  • RuntimeException。RuntimeException 異常由Java虛擬機拋出。
  • NullPointerException(要訪問的變量沒有引用任何對象時,拋出該異常)
  • ArithmeticException(算術運算異常,一個整數除以0時,拋出該異常)
  • ArrayIndexOutOfBoundsException (下標越界異常)。
  • SQLException,SQL異常,通常都是SQL語句錯誤

==異常和錯誤的區別:異常能被程序自己能夠處理,錯誤是沒法處理==

throw和throws區別

  • throw:
    throw在方法體內,表示拋出異常,執行throw必定是拋出了某種異常
  • throws :
    throws跟在方法聲明的後面,表示可能出現某種異常

try和finally的返回值

  1. 若是try有返回值,就把返回值保存到局部變量中;
  2. 執行jsr指令跳到finally語句裏執行;
  3. 執行完finally語句後,返回以前保存在局部變量表裏的值。
  4. 若是try,finally語句裏均有return,忽略try的return,而使用finally的return

迭代器 Iterator

迭代器是一種設計模式,它是一個對象,它能夠遍歷並選擇序列中的對象,而開發人員不須要了解該序列的底層結構。迭代器一般被稱爲「輕量級」對象,由於建立它的代價小。
使用:

  1. 使用方法iterator()要求容器返回一個Iterator。第一次調用Iterator的next()方法時,它返回序列的第一個元素。注意:iterator()方法是java.lang.Iterable接口,被Collection繼承。
  2. 使用next()得到序列中的下一個元素。
  3. 使用hasNext()檢查序列中是否還有元素。
  4. 使用remove()將迭代器新返回的元素刪除。
相關文章
相關標籤/搜索