Java語言基礎

（一）Java編譯運行程序

?編譯期：Java源檔案經過編譯生成.class位元組碼檔案
?運行期：JVM加載.class并運行.class
?特點：跨平臺，一次編譯到處使用(跨平臺特性如下圖)

（二）JVM、JRE、JDK

?JVM：(Java Virtual Machine）,Java虛擬機
?JRE：(Java Runtime Environment）,Java運行環境，除包含JVM外還包含運行Java程式所必須的環境，JRE = JVM + Java系統類別庫
?JDK：(Java Development Kit）,Java開發工具包，JDK = JRE + 編譯運行等命令工具

• 說明:
  • 運行Java程式最小環境為JRE
  • 開發Java程式最小的環境為JDK

（三）變數的命名

?在程式執行程序中，其值能被改變的量稱為變數，其值不能改變的量稱為常量，變數與常量的命名都必須使用合法的識別符號，

    變數的命名應遵循以下規則：
      -只能包含字母、數字、_和$符，并且不能以數字開頭
      -嚴格區分大小寫
      -不能使用關鍵字
      -允許中文命名，但不建議，建議"英文的見名知意"、"小駝峰命名法"

（四）代碼注釋

??通過在程式代碼中添加注釋可以提高程式代碼的可讀性和可維護性，幫助程式員更好的閱讀和理解程式，Java語言提供 3 種添加注釋的方法，分別為單行注釋、多行注釋和檔案注釋，

• 單行注釋
  “//”為單行注釋標記，從符號“//”開始直到換行為止的所有內容均為注釋而被編譯器忽略，語法如下：

      //注釋內容
  
      例如，以下代碼為宣告 int 型變數添加注釋：
      int age;    //宣告 int 變數用于保存年齡資訊
  

• 多行注釋
  “/* */”為多行注釋標記，符號“/*”與“*/”之間的所有內容均為注釋內容，注釋中的內容可以換行，語法如下：

    /*
    注釋內容 1
    注釋內容 2
    ...
    */
  
    //多行注釋中可以嵌套單行注釋，但是多行注釋中不可以嵌套多行注釋
  

• 檔案注釋

  “/** */”為檔案注釋標記，符號“/**”與“*/”之間的所有內容均為注釋內容，注釋中的內容可以換行，在檔案注釋出現在宣告（如類的宣告、類的成員變數的宣告、類的成員方法的宣告、類的成員方法的宣告等）之前時，會被Javadoc檔案工具讀取作為Javadoc的檔案內容，檔案注釋的格式與多行注釋的格式相同，

（五）Java資料型別

1、Java語言提供了四類八種基本資料型別：

  整數型別：byte、short、int、long
  浮點數型別：float、double
  布爾型別：boolean
  字符型別：char

2、簡述java的8種基本資料型別：

byte:     位元組型，用于存盤整數，占用 1 個位元組，范圍 -128 ~ 127，默認值是 0
short：   短整型，用于存盤整數，占用 2 個位元組，范圍 -32768 ~ 32767，默認值是 0
int：     整型，用于存盤整數，占用 4 個位元組，范圍 -2^31 ~ 2^31-1，默認值是 0
long：    長整型，用于存盤較大的整數，占用 8 個位元組，范圍 -2^63 ~ 2^63-1，默認值是 0L
float:    單精度浮點數，用于存盤小數，占用 4 個位元組，不能表示精確的值，默認值是 0.0F
double：  雙精度浮點數，用于存盤小數，占用 8 個位元組，不能表示精確的值，默認值是 0.0D
boolean： 布爾型，用于存盤 true 和 false，占用 1 個位元組，默認值是 false
char：    字符型，采用 Unicode 字符集編碼，用于存盤單個字符，占用 2 個位元組，范圍 0 ~ 65535

  舉個栗子：
  byte a = 100;byte b = -50;

  short s = 1000;short r = -20000;

  int a = 100000;int b = -200000;  //1)整數直接量默認為int型別，但不能超出范圍，若超出范圍則發生編譯錯誤 2)兩個整數相除，結果還是整數,小數位無條件舍棄 3)運算時若超出范圍，則發生溢位，溢位是需要避免的

  long a = 100000L;Long b = -200000L;  //長整型直接量需要在數字后加 L 或者 l,運算時若可能溢位，建議在第一個數字后加L

  //浮點數直接量默認為double型別，若想表示float，需在數字后加F 或 f
  //double 或 float型資料參與運算時，有可能出現舍入誤差，精確場合不能使用
  float f = 3.14F;   //3.14F為float型直接量

  double d = 3.14;    //3.14為浮點數直接量，默認為double型

  boolean b1 = true;boolean b2 = false;  //true 和 false 都是布爾型別的直接量

  char letter = 'A';  //char型別，字符型直接量必須放到單引號里面，單引號里面必須有字符，只能有一個字符,特殊符號需要通過\來轉義，例如：char c = '\\' 表示字符 \ ;

3、資料型別間的轉換

• 小到大依次為:byte-short/char-int-long-float-double
• 自動/隱式型別轉換：由小到大
• 強制型別轉換：語法（要轉換成為的資料型別）變數，由大到小，強轉有可能發生溢位或丟失精度

  int a = 5;
  long b = a; //自動型別轉換
  int c = (int) b; //強制型別轉換

  long d = 5;
  double e = 5;
  long f = 10000000000L;
  int g = (int) f;
  System.out.println(g);  //1410065408    強轉有可能會記憶體溢位
  double h = 23.34545;
  int i = (int) h;
  System.out.println(i);  //23    強轉有可能會丟失精度

  //整數直接量可以直接賦值給byte、short、char，但是不能超出范圍
  //byte、short、char型的資料參與運算，系統會將其自動轉換為int再運算
  byte b = 3;
  byte b1 = 5;
  byte b2 = (byte) (b + b1);
  System.out.println(b2);

  System.out.println('2' + '2');//100.'2'的碼50 加上 '2'的碼50 ，得100

（六）Java中的運算子

• 算數運算子：+、——、*、/、%、++、--
• 關系運算子：>、<、>=、<=、==、!=
• 邏輯運算子：&&、||、！
• 賦值運算子：=、+=、-=、*=、/=、%=
• 字串連接符：+
• 條件運算子：boolean ？ 數1 : 數2

  算數運算子自增（++）、自減（--）使用的兩種不同情況：
  單獨使用時：在前在后都是會使值自增1
  被使用時：a++/a--  ————————先賦值，再運算
            ++a/--a   ————————先運算，再賦值
        
public class OperatorDemo {
    public static void main(String[] args) {
            //自增、自減運算演示

            //單獨使用時，都會自增/自減1
            int a = 5, b = 10;
            a++;
            b++;
            System.out.println("a = " + a); //6
            System.out.println("b = " + b); //11

            //被使用時，運算子在前，先運算后賦值；運算子在后，先賦值后運算
            int c = 20, d = 20;
            int e = c++;
            int f = ++d;
            System.out.println("e = " + e); //20
            System.out.println("f = " + f); //21
    }
}

（七）Java中的流程控制

1、程式結構

• 順序結構：按照書寫順序執行的陳述句構成的程式段,從上往下執行，每句必走
• 分支結構：有條件的執行不同的陳述句，并非每句都走
• 回圈結構：回圈條件滿足的情況下，反復執行一段相同或相似的代碼

2、if條件陳述句
?主要用于告訴程式在某個條件成立的情況下執行某段陳述句，語法結構和執行程序如下：

1)語法:
     if(boolean){
        陳述句塊;
      }
2)執行程序:
      判斷boolean的值:
      若為true，則執行陳述句塊(if結束)
      若為false，則if直接結束

3、if...else陳述句
?如果滿足某種條件，就進行某種處理，否則就進行另一種處理，語法結構和執行程序如下：

1)語法:
    if(boolean){
       陳述句塊1
    }else{
       陳述句塊2
    }
2)執行程序:
    判斷boolean的值:
    若為true，則執行陳述句塊1(整個結束)
    若為false，則執行陳述句塊2(整個結束)
3)說明:
    陳述句塊1和陳述句塊2，必走其中之一-----------2選1

4、if...else...if陳述句
?針對某一事物的多種情況進行處理，通常表現為“如果滿足某種條件就進行某種處理，如果滿足另一種條件就進行另一種處理”，語法結構和執行程序如下：

1)語法:
    if(boolean-1){
       陳述句塊1
    }else if(boolean-2){
       陳述句塊2
    }else if(boolean-3){
       陳述句塊3
    }else{
       陳述句塊4
    }
2)執行程序:
     判斷boolean-1，若為true則執行陳述句塊1(結束)，若為false則
     再判斷boolean-2，若為true則執行陳述句塊2(結束)，若為false則
     再判斷boolean-3，若為true則執行陳述句塊3(結束)，若為false則執行陳述句塊4(結束)
3)說明:
     陳述句塊1/2/3/4，只能執行其中之一---------多選1

5、switch...case陳述句
?根據不同的值給出輸出陳述句，實作多選一的效果，相比較而言，效率高，結構清晰，但是只能對整數判斷相等，swich...case能作用在byte、short、int、char、String、列舉等型別的變數上，語法如下：

switch(用于判斷的引數){
case 常量運算式1:	陳述句1;	break;
case 常量運算式2:	陳述句2;	break;
...
case 常量運算式n:	陳述句n;	break;
default:    陳述句n+1;	break;
}

6、while回圈陳述句
?利用一個條件來控制是否要繼續反復執行一個陳述句，先判斷后執行，有可能一次也不執行，語法如下：

1)語法:
    while(boolean){
      陳述句塊-------------反復執行的代碼
    }
2)執行程序:
     先判斷boolean的值，若為true則執行陳述句塊，
     再判斷boolean的值，若為true則再執行陳述句塊，
     再判斷boolean的值，若為true則再執行陳述句塊，
     如此反復，直到boolean的值為false時，while回圈結束

7、do...while回圈陳述句
?類似于while陳述句，但是do...while陳述句是先執行再判斷，陳述句塊至少執行一次，語法如下：

語法:
    do{
       陳述句塊-------------反復執行的代碼
    }while(boolean)；

8、for回圈陳述句
?用來重復執行某條陳述句，知道條件得到滿足(應用率最高)，語法如下：

1)語法:
  //   1     2    3
  for(要素1;要素2;要素3){
     陳述句塊/回圈體--------------反復執行的代碼  4
  }
2)執行程序:
  1243243243243243...2

說明：break 和 continue 關鍵字的區別：
    break：跳出回圈，結束整個回圈，開始執行回圈之后的陳述句，可應用在Switch和回圈陳述句中，
    continue：跳過回圈體中剩余陳述句，進入下一次回圈，只能應用在回圈中，

（八）陣列

• 陣列是一種參考型別，是相同資料型別元素的集合

   //宣告整型陣列arr，包含10個元素，每個元素都是int型別，默認值為0
   int[] arr = new int[10];

• 初始化：----初始化陣列中的資料

   int[] arr = new int[3]; 
   int[] arr = {1,4,7}; 
   int[] arr = new int[]{1,4,7}; 
   int[] arr;
   //arr = {1,4,7}; //編譯錯誤，此方式只能宣告同時初始化
   arr = new int[]{1,4,7}; //正確

• 訪問：----訪問的是陣列中的元素
  通過(陣列名.length)可以獲取陣列的長度(元素個數)

   int[] arr = new int[3];
   System.out.println(arr.length); //3

• 通過下標/索引來訪問陣列中的元素，下標從0開始，最大到(陣列長度-1)

   int[] arr = new int[3];
   System.out.println(arr[0]); //0，輸出第1個元素的值
   arr[0] = 100; //給第1個元素賦值為100
   arr[1] = 200; //給第2個元素賦值為200
   arr[2] = 300; //給第3個元素賦值為300
   //arr[3] = 400; //運行時會發生陣列下標越界例外
   System.out.println(arr[arr.length-1]); //300，輸出最后一個元素的值

• 陣列的遍歷/迭代：從頭到尾挨個走一遍

    int[] arr = new int[10];
    for(int i=0;i<arr.length;i++){ //遍歷arr陣列
      arr[i] = (int)(Math.random()*100); //給每個元素賦值為0到99之間的亂數
      System.out.println(arr[i]); //輸出每個元素的值
      //arr[i]:代表的是arr中的每一個元素
    }

• 陣列的復制
  System.arraycopy(a,1,b,0,4);

    int[] a = {10,20,30,40,50};
    int[] b = new int[6]; //0,0,0,0,0,0
    //a:源陣列
    //1:源陣列的起始下標
    //b:目標陣列
    //0:目標陣列的起始下標
    //4:要復制的元素個數
    System.arraycopy(a,1,b,0,4); //靈活性好
    for(int i=0;i<b.length;i++){
        System.out.println(b[i]);
    }

• 陣列的擴容
  int[] b = Arrays.copyOf(a,6);
  a = Arrays.copyOf(a,a.length+1);

    //陣列的擴容
    int[] a = {10,20,30,40,50};
    //陣列的擴容(創建了一個更大的新的陣列，并將資料復制進去了)
    a = Arrays.copyOf(a,a.length+1);
    for(int i=0;i<a.length;i++){
        System.out.println(a[i]);
    }

• 陣列的排序: Arrays.sort(arr);

    int[] arr = new int[10];
    for(int i=0;i<arr.length;i++){
        arr[i] = (int)(Math.random()*100);
        System.out.println(arr[i]);
    }
    Arrays.sort(arr); //對arr進行升序排列
    System.out.println("排序后:");
    for(int i=0;i<arr.length;i++){  
        System.out.println(arr[i]);
    }

標籤：Java

上一篇：Java8 新特性，打破你對介面的認知

下一篇：HashMap原始碼個人理解