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]);
    }
Tags:

VirMach 便宜 VPS

QNews

QNews