Java 學習總結

時間 2019-11-09

標籤 java 學習總結欄目 Java 简体版

原文原文鏈接

Start：java

每一個 Java 程序至少應該有一個類，一般類名的第一個字母大寫。數組

若要使用數學方法須要用到 Math 類。隨機方法也在該類中。併發

一樣程序也是從 main 方法開始執行的。ide

然而 Java 的加號 + ，不只能夠用於數值之間，字符串之間，還能夠用於數值和字符串之間。ui

Java 容許兩個字符相加，例如：int i = 'a' + 'b';this

只是字符串常量不能夠跨行。url

Java 的輸入和輸出：spa

輸出: System.out.print("string") 不換行，或者 Sytem.out.println("string") 換行。.net

輸入: 輸入要稍微麻煩一些，須要導入 java.util.Scanner。如：import java.util.Scanner命令行

能夠用 Scanner 類建立它的對象，來讀取 System.in 的輸入。

例如：Scanner input = new Scanner(System.in)。

從鍵盤讀取各類數據類型，例如：

byte byteValue = input.nextByte();

short shortValue = input.nextShort();

int intValue = input.nextInt();

long longValue = input.nextLong();

float floatValue = input.nextFloat();

double doubleValue = input.nextDouble();

String string = input.next(); 這種讀取方式以碰到空格就結束。

String string = input.nextLine(); 這種讀取方式以碰到換行結束。

Java 提供了boolean 數據類型：表示 false 或 true。

Java 還有字符串的數據類型，例如：String message = "Welcome to java";

String 對象也有許多簡單的字符串操做方法。

標識符：

標識符是由字母，數字，下劃線 _ ，或美圓符號 $ 構成的字符序列，不能以數字開頭。

命名常量：final 數據類型數據名稱 = 常量值。

例如： final double PI = 3.1415926;

命名習慣：

使用小寫字母命名變量和方法，若是一個名字包含多個單詞，就把他們連起來，

第一個單詞的字母小寫，後面的每一個單詞首字母大寫，例如：blackCat。

類名中的每一個單詞首字母大寫，例如 ComputerScience。

大寫常量中的全部字母，多個單詞間用下劃線鏈接，例如：MAX_VALUE。

爲了提升程序可讀性，java 容許在數值直接量的兩個數字之間使用下劃線。例如：1000_000_000。

方法：

定義方法：修飾符返回值類型方法名(參數列表) { ...... }

例如：public static int max(int a,int b) {......}

數組：

聲明數組：元素類型[ ] 數組變量名; 元素類型[ ][ ] 數組變量名;

建立數組：new 元素類型[數組大小] ; new 元素類型[數組大小][數組大小];

也能夠一塊兒使用，例如：int[ ] ary = new int[10]; double[ ][ ] array = new double[10][10];

數組的大小，例如：ary.length。array.length;

爲數組設計的循環 forecah：

語法爲：for(元素類型元素名稱 : 數組名) { ......}

例如：for(int e : ary) { System.out.println(e) };

數組複製：

除了能夠用循環來複制外，Java 提供了一些方法來複制數組。

例如使用 java.lang.System 類的 arraycopy 方法來複制數組，語法爲：System.arraycopy(sourceArray,srcPos,targetArray,tarPos,length);

注意：該方法沒有遵循命名習慣。

另外，java.util.Arrays 類中有許多常見的數組操做方法，好比查找，排序等等。

數組值交換例子：

public static void main(String[] args)
        {
            int[] a = {1,2};
            swap(a[0],a[1]);
            System.out.printf("%d, %d\n",a[0],a[1]);
            swapArray(a);
            System.out.printf("%d, %d\n",a[0],a[1]);
        }
        
        public static void swap(int m,int n)
        {
            int temp = n;
            n = m;
            m = temp;
        }
        
        public static void swapArray(int[] array)
        {
            int temp = array[0];
            array[0] = array[1];
            array[1] = temp;
        }

運行結果爲：1，2 2，1。這是由於數組的引用傳遞給了方法。

命令行參數：

或許你已經注意到 main 方法的聲明不同凡響，它具備 String[ ] 類型參數 args。

很明顯 args 是一個字符串類型數組，所以能夠給它傳遞參數。

例如：

 public static void main(String[] args)
     {
         for(int i = 0; i < args.length; i++)
         {
             System.out.println(args[i]);
         }
     }

可經過 java 命令來運行該程序，例如：java display 1 2 3。

可變長度參數列表：

方法中的參數聲明：(類型名... 參數名) 注意：類型名後緊跟着省略號。

例如：public static int max(int... numbers) { ...... }

對象和類：

包含 main 方法的類稱爲主類。

訪問對象的數據和方法：

在建立一個對象後，它的數據和方法可使用點操做符 ( . ) 來訪問和調用，該操做符也稱爲對象成員訪問操做符。

若是一個引用類型的數據域沒有引用任何對象，那麼這個數據域就有一個特殊的 Java 值 null。

引用類型數據域的默認值是 null，數值類型數據域的默認值是 0，boolean 類型數據域的默認值是 false，

而 char類型數據域的默認值是 '\u0000'。可是，Java 沒有給方法中的局部變置陚默認值。

靜態變量，常量和方法：

靜態變量被類中全部對象所共享，靜態方法不能訪問類中的實例成員。、

實例方法便可訪問靜態變量或方法，也能夠訪問實例變量或方法。

可見性修飾符：

可見性修飾符能夠用於肯定一個類以及它的成員的可見性。

能夠在類、方法和數據域前使用 public 修飾符，表示它們能夠被任何其餘的類訪問。

若是沒有使用可見性修飾符，那麼則默認類、方法和數據域是能夠被同一個包中的任何一個類訪問的。

這稱做包私有 (package-private) 或包內訪問 (package-access)。

除了 public 和默承認見性修飾符，Java 還爲類成員提供 private 和 protected 修飾符。

private 修飾符：限定方法和數據域只能在它本身的類中被訪問。

修鈽符 private 只能應用在類的成員上。

修飾符 public 能夠應用在類或類的成員上。

在局部變量上使用修飾符 public 和 private 都會致使編譯構誤。

爲防止數據被篡改以及使類更易於維護，最好將數據域聲明爲私有的。

向方法傳遞對象參數：

能夠將對象傳遞給方法。同傳遞數組同樣，傳遞對象其實是傳遞對象的引用。

this 引用：

關鍵字 this 引用對象自身。它也能夠在構造方法內部用於調用同一個類的其餘構造方法。

this 關鍵字能夠用於引用類的隱藏數據域。隱藏的靜態變量能夠簡單地經過「類名 .靜態變量」的方式引用。

隱藏的實例變量就須要使用關鍵字 this 來引用。

使用 this 調用構造方法：
Java 要求在構造方法中，語句 this( 參數列表）應在任何其餘可執行語句以前出現。

若是一個類有多個構造方法，最好儘量使用 this(參數列表) 實現它們。

一般，無參數或參數少的構造方法能夠用 this(參數列表) 調用參數多的構造方法。

String 類：

String 對象是不可改變的。字符串一旦建立，內容不能再改變。

例如：String message = "Welcome to Java";

message = "Hello world!";

開始 message 引用字符串"Welcome to Java"，以後 message 引用字符串"Hello world"。

"Welcome to Java"字符串並無改變，只是不能夠再引用了。

另外，String 對象之間的比較，比較的是對象不是內容。

例如：String s1 = "Welcome to Java";

String s2 = new String("Welcome to Java");

String s3 = "Welcome to Java";

此時，s1 == s3，s1 != s2。

另外，該類提供了許多方法，能夠本身查閱。

StringBuilder類和 StringBuffer類：

StringBuilder 和 StringBuffer 相似於 String 類，區別在於 String 類是不可改變的。

— 般來講，只要使用字符串的地方，均可以使用StringBuilder/StringBuffer類。

StringBuilder/StringBuffer 類比 String類更靈活。

除了 StringBuffer 中修改緩衝區的方法是同步的，StringBuilder 類與 StringBuffer 類是很類似的。

若是是多任務併發訪問，就使用StringBuffer, 由於這種狀況下須要同步以防止 StringBuffer 崩潰。

而若是是單任務訪問，使用StringBuilder 會更有效。

一樣，該兩個類也提供了許多修改字符串的方法。

繼承和多態：

修飾符(public,private,protected) class 類名 extends 要擴展的類名 { ...... }

這樣就完成了繼承。若要初始要擴展類名裏的私有屬性，須要調用要擴展類名的初始話私有屬性的方法。

不能夠用 this 指針來初始化。

關鍵字 super：

關鍵字 super 指代父類，能夠用於調用父類中的普通方法和構造方法。

關鍵字 super 是指這個 super 關鍵字所在的類的父類。

關鍵字 super 能夠用於兩種途徑：

1) 調用父類的構造方法。

2) 調用父類的方法。

之因此引入該關鍵字，是由於父類的構造方法不會被子類繼承。

調用父類構造方法的語法是：super() 或者 super(parameters)

語句 super() 調用父類的無參構造方法，而語句 super(parameters) 調用與參數匹配的父類的構造方法。

語句 super() 和 super(parameters) 必須出如今子類構造方法的第一行，這是顯式調用父類構造方法的惟一方式。

構造方法鏈：

構造方法能夠調用重載的構造方法或父類的構造方法。

若是它們都沒有被顯式地調用，編譯器就會自動地將 super() 做爲構造方法的第一條語句。

在任何狀況下，構造一個類的實例時，將會調用沿着繼承鏈的全部父類的構造方法。

當構造一個子類的對象時，子類構造方法會在完成本身的任務以前，首先調用它的父類的構造方法。

若是父類繼承自其餘類，那麼父類構造方法又會在完成本身的任務以前，調用它自己的父類的構造方法。

這個過程持續到沿着這個繼承體系結構的最後一個構造方法被調用爲止。這就是構造方法鏈。

調用父類方法：

關鍵字 super 不只能夠引用父類的構造方法，也能夠引用父類的方法。所用語法以下：

super.方法名(參數);

方法重寫：

子類從父類中繼承方法。有時，子類須要修改父類中定義的方法的實現，這稱做方法重寫。

要重寫一個方法，須要在子類中使用和父類同樣的簽名以及同樣的返回值類型來對該方法進行定義。

方法重寫與重載：

重載意味着使用一樣的名字可是不一樣的簽名來定義多個方法。重寫意味着在子類中提供一個對方法的新的實現。

例如：重寫

public static void main(String[] args)
    {
        A a = new A();
        a.p(10);
        a.p(10.0);
    }

public static class B
    {
        public void p(double i)
        {
            System.out.println(i*2);
        }
    }

public static class A extends B
    {
        public void p(double i)
        {
            System.out.println(i);
        }
    }

運行結果爲：10.0，10.0。

例如：重載

public static void main(String[] args)
    {
        A a = new A();
        a.p(10);
        a.p(10.0);
    }

public static class B
    {
        public void p(double i)
        {
            System.out.println(i*2);
        }
    }

public static class A extends B
    {
        public void p(int i)
        {
            System.out.println(i);
        }
    }

運行結果：10，20.0。

爲了不錯誤，可使用一個特殊的 Java 語法，稱爲重寫標註, 在子類的方法前面放一個 @Override。

該標註表示被標註的方法必須重寫父類的一個方法。若是具備該標註的方法沒有重寫父類的方法，編譯器將報告一個錯誤。

Object 類：

Java 中的全部類都繼承自 java.lang.Object 類。

若是在定義一個類時沒有指定繼承性，那麼這個類的父類就被默認爲是 Object。

多態：

多態意味着父類的變量能夠指向子類對象。

面向對象程序設計的三大支柱是封裝、繼承和多態。

繼承關係使一個子類繼承父類的特徵，而且附加一些新特徵。

子類是它的父類的特殊化，每一個子類的實例都是其父類的實例，可是反過來就不成立。

所以，總能夠將子類的實例傳給須要父類型的參數。

使用父類對象的地方均可以使用子類的對象。這就是一般所說的多態。

簡單來講，多態意味着父類型的變量能夠引用子類型的對象。

動態綁定：

抽象的說：實例可使用聲明類型或它的子類型的構造方法建立。變量的實際類型是被變量引用的對象的實際類。

假如啊：

People 類裏有 goToWC() 方法吧，Man類和 Women類是繼承於 People類的。

這兩個類裏都對 goToWC() 方法進行了改造。

例如：People boy = new Man(); 或者 People girl = new Women();

此時調用 boy 或者 girl 的 goToWC() 方法，調用的將是 Man類或 Women類裏的 goToWC() 方法，而不是 People 類裏的。

這就是動態綁定的意思了。

ArrayList類：

Java 提供 ArrayList類來存儲不限定個數的對象。

ArrayList是一種泛型類，建立一個 ArrayLis 類對象時，能夠指定一個具體的類型來替換該對象。

例如：ArrayList<String> cities = new ArrayList<String>();

或者：ArrayList<java.util.Date> dates = new ArrayList<java.util.Date>();

能夠這樣簡化：ArrayList<String> cities = new ArrayList<>();

修飾符：

使用 private修飾符能夠徹底隱藏類的成員，這樣，就不能從類外直接訪問它們。

不使用修飾符就表示容許同一個包裏的任何類直接訪問類的成員，可是其餘包中的類不能夠訪問。

使用protected 修飾符容許任何包中的子類或同一包中的類訪問類的成員。

使用 public 修飾符容許任意類訪問類的成員。

修飾符 private 和 protected 只能用於類的成員。

public 修飾符和默認修飾符(也就是沒有修飾符)既能夠用於類的成員，也能夠用於類。

子類能夠重寫它的父類的 protected 方法，並把它的可見性改成 public。

可是，子類不能削弱父類中定義的方法的可訪問性。

例如：若是一個方法在父類中定義爲 public, 在子類中也必須定義爲 public。

防止擴展和重寫：

一個被 final 修飾的類和方法都不能被擴展。被 final 修飾的數據域是一個常數。

有時候，可能但願防止類擴展。在這種狀況下，使用 final 修飾符代表一個類是最終的，是不能做爲父類的。

修飾符 public、protected、private、static、 abstract以及 final 能夠用在類和類的成員(數據和方法)上，

只有 final 修飾符還能夠用在方法中的局部變量上。方法內的最終局部變量就是常量。

異常類型：

異常是對象，而對象都採用類來定義。異常的根類是 java.lang.Throwable。

例如：ArithmeticException 是除以 0 異常。更多的異常類型請本身查閱文檔。

異常處理：

Java 的異常處理模型基於三種操做：聲明一個異常、拋出一個異常、捕獲一個異常。

捕獲異常：

try
{ ...... }
catch(異常類型 異常類型的對象)
{ ...... }
catch(異常類型 異常類型的對象)
{ ...... }
catch(異常類型 異常類型的對象)
{ ...... }
.
.
.

若是 try 塊中的某條語句拋出一個異常，Java 就會跳過 try塊中剩餘的語句，而後開始査找處理這個異常的代碼的過程。

處理這個異常的代碼稱爲異常處理器 ; 能夠從當前的方法開始，沿着方法調用鏈，按照異常的反向傳播方向找到這個處理器。

從第一個到最後一個逐個檢査 catch 塊，判斷在 catch 塊中的異常類實例是不是該異常對象的類型。

若是是，就將該異常對象陚值給所聲明的變量，而後執行 catch 塊中的代碼。

若是沒有發現異常處理器，Java 會退出這個方法，把異常傳遞給調用這個方法的方法，繼續一樣的過程來査找處理器。

若是在調用的方法鏈中找不處處理器，程序就會終止而且在控制檯上打印出錯信息。尋找處理器的過程稱爲捕獲異常。

聲明異常：

Java 解釋器調用 main 方法開始執行一個程序。每一個方法都必須聲明它可能拋出的必檢異常的類型，這稱爲聲明異常。

爲了在方法中聲明一個異常，就要在方法頭中使用關鍵字 throws。

例如：public void myMethod() throws ArithmeticException { ...... }

關鍵字 throws 代表 myMethod 方法可齙會拋出異常 ArithmeticException 。

若是方法可能會拋出多個異常，就能夠在關鍵字 throws 後添加一個用逗號分隔的異常列表：

public void myMethod() throws ArithmeticException,IndexOutOfBoundsException,...

若是方法沒有在父類中聲明異常，那麼就不能在子類中對其進行繼承來聲明異常。

拋出異常：

檢測到錯誤的程序能夠建立一個合適的異常類型的實例並拋出它，這就稱爲拋出異常。

假如程序發現除數爲 0，就能夠建立一個 ArithmeticException 實例並拋出它。

例如：ArithmeticException ex = new ArithmeticException("錯誤提示信息");

throw ex;

或者：throw new ArithmeticException("除數爲 0 錯誤");

finally 字句：

不管異常是否產生，finally 子句老是會被執行的。

try
{ ...... }
catch(異常類型 異常類型的對象)
{ ...... }
catch(異常類型 異常類型的對象)
{ ...... }
catch(異常類型 異常類型的對象)
{ ...... }
.
.
.
finally
{ ...... }

在任何狀況下，finally塊中的代碼都會執行，不論 try 塊中是否出現異常或者是否被捕獲。

考慮下面三種可能出現的狀況：

一、若是 try 塊中沒有出現異常，執行 finally{ ...... }，而後執行 try 語句的下一條語句。

二、若是 try 塊中有一條語句引發異常，並被 catch 塊捕獲，而後跳過 try 塊的其餘語句，執行 catch 塊和 finally 子句。

執行 try語句以後的下一條語句。

三、若是 try 塊中有一條語句引發異常，可是沒有被任何 catch 塊捕獲，就會跳過 try 塊中的其餘語句，執行 finally 子句，

而且將異常傳遞給這個方法的調用者。即便在到達 finally 塊以前有一個 return 語句，finally 塊仍是會執行。

建立自定義異常類：

Java 提供至關多的異常類，儘可能使用它們而不要建立本身的異常類。

然而，若是進到一個不能用預約義異常類恰當描述的問題，那就能夠經過派生 Exception 類或其子類，來建立本身的異常類。

File 類：

java.io.File 類有一些對文件操做的相關方法，可是不支持建立及讀寫文件相關的操做。

使用 Scanner 類從文件中讀取文本數據，使用 PrintWriter 類向文本文件寫入數據。

java.io.File 對象能夠綁定一個文件。例如：java.io.File file = new java.io.File("test.txt");

使用 PrintWriter 寫數據：

首先，必須爲一個文本文件建立一個 PrintWriter 對象：PrintWriter output = new PrintWriter(fileName 或者 java.io.File 對象);

而後，能夠調用PrinterWriter 對象上的 print、println 和 printf 方法向文件寫入數據。

使用 Scanner 讀數據：

Scanner input = new Scanner(fileName 或者 java.io.File 對象);

接下來就能夠像從鍵盤讀入那樣讀入了。

行分隔符字符串是由系統定義的，在 Windows 平臺上 \r\n, 而在 UNIX 平臺上是 \n。

爲了獲得特定平臺上的行分隔符，使用 String lineSeparator = System.getProperty('line.separator");

若是從鍵盤輸入，每行就以回車鍵結束，它對應於 \n 字符。

while( input.hasNext() ) { ...... } 保持循環直到到了文件末尾。

從 Web 上讀取數據：

爲了讀取一個文件，首先要使用 java.net.URL 類的這個構造方法，爲該文件建立一個 URL 對象。

例如：URL url = new URL("http://www.cnblogs.com/M-Anonymous/");

前綴 http:// 是必需的，不然將會引發 MaiformedURLException 運行錯誤，必須說明或處理該錯誤。

建立一個 URL 對象後，可使用URL 類中定義的 openStream() 方法來打開輸入流和用輸人流建立以下 Scanner 對象。

Scanner input = new Scanner( url.openStream() );

如今能夠從輸人流中讀取數據了，如同從本地文件中讀取同樣。

例如：

    public static void main(String[] args)
    {
        System.out.println("Enter a URL: ");
        Scanner input1 = new Scanner(System.in);
        String URLString = input1.next();
        try
        {
            int count = 0;
            java.net.URL url = new java.net.URL(URLString);
            Scanner input2 = new Scanner(url.openStream());
            while(input2.hasNextLine())
            {
                String line = input2.nextLine();
                count += line.length();
            }    
            System.out.println("The file size is " + count + "characters");    
            input1.close();
            input2.close();
            
        }
        catch(java.net.MalformedURLException ex)
        {
            System.out.println("Invalid URL");
        }
        catch(java.io.IOException ex)
        {
            System.out.println("I/O Errors: no such file");
        }

    }