第二章 Java基礎語法

阿新 • • 發佈：2021-09-14

1.關鍵字和保留字

關鍵字（keyword）的定義和特點
定義：被Java語言賦予了特殊含義，用做專門用途的字串（單詞）
特點：關鍵字中所有字母均為小寫
官方地址：https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

保留字（reserved word）
現有Java版本尚未使用，但以後版本可以作為關鍵字使用。自己命名識別符號時要避免使用這些保留字，如：goto、const等。

2.識別符號（Identifier）

識別符號：
Java對各種變數、方法和類等要素命名時使用的字元序列稱為識別符號。
技巧：凡是自己可以起名字的地方都叫識別符號。
定義合法識別符號規則：
1.由26個英文字母大小寫、數字0-9、_或$組成
2.數字不可以開頭
3.不可以使用關鍵字或保留字，但能包含關鍵字和保留字
4.Java中嚴格區分大小寫，長度無限制
5.識別符號不能包含空格
Java中的名稱命名規範：
包名：多單片語成時所有字母都小寫：xxxyyyzzz
類名、介面名：多單片語成時，所有單詞的首字母大寫：XxxYyyZzz
變數名、方法名：多單片語成時，第一個單詞首字母小寫，第二個單詞開始每個單詞首字母大寫：xxxYyyZzz
常量名：所有字母都大寫，多單詞時每個單詞用下劃線連線：XXX_YYY_ZZZ
注意1：在起名字時，為了提高閱讀性，要儘量有意義：“見名知意”

注意2：Java採用unicode字符集，因此識別符號也可以使用漢字宣告，但是不建議使用

3.變數

3.1 變數的介紹

變數的概念：
- 記憶體中的一個儲存區域
- 該變數的資料可以在同一類型範圍內不斷變化
- 變數是程式中最基本的儲存單元。包含變數型別、變數名和儲存的
變數的作用：
用於在記憶體中保留資料。
使用變數的注意點：
- Java中每個變數都必須先宣告，後使用
- 使用變數名來訪問這塊區域的資料
- 變數的作用域：其定義的一對{}內
- 變數只有在作用域內才有效
- 同一個作用域內，不能定義重名的變數

public class VariableTest {
  public static void main(String[] args) {
    //變數的定義
    int myNumber = 10;
    //變數的使用
    System.out.println(muNumber);
    
    //變數的定義
    int myAge;
    //變數的賦值
    myAge = 21;
    //變數的使用
    System.out.println(myAge);
  }
}

3.2 變數的分類

按資料型別來分
對於每一種資料都定義了明確的具體資料型別（強型別語言），在Java中分配了不同大小的記憶體空間。

按宣告位置的不同來分
1.在方法體外，類體內宣告的變數稱為成員變數。
2.在方法體內部宣告的變數稱為區域性變數。

注意：兩者在初始化值方面的異同：
同：都有宣告週期異：區域性變數除形參外，需顯式初始化

3.3 整型

Java各整數型別的資料有固定的表示範圍和欄位長度，不受具體OS的影響，以保證Java程式的可移植性。
Java整型變數的預設型別是int，宣告long型變數需要在變數後加'l'或'L'。

public class VariableTest {
  public static void main(string[] args) {
    //byte範圍為-128~127
    byte b1 = -128;
    byte b2 = 15;
    byte b3 = 127;
    //編譯不通過，超出了byte所能表示的範圍
    //byte b4 = 128;
    System.out.println(b1);
    System.out.println(b2);
    short s1 = 999;
    //通常定義整型變數時，使用int型別
    int i1 = 20;
    //定義long型變數，必須以'l'或'L'結尾
    long l1 = 3255648214L;
    System.out.println(l1);
  }
}

3.4 浮點型別

與整數型別相似，Java浮點型別也有固定的表示範圍和欄位長度，不受具體OS的影響。
浮點型常量有兩種表示方式：
- 十進位制形式：如，5.12、512.0f、.512（必須有小數點）
- 科學計數法形式：如，5.12e2、512E2、100E-2
float：單精度，尾數可以精確到7位有效數字。很多情況下，精度很難滿足需求
double：雙精度，精度是float的兩倍，通常採用此型別
Java的浮點型常量預設為double型別，宣告float型別的變數，變數後需加'f'或'F'

public class VariableTest {
  public static void main() {
    double d1 = 123.4;
    System.out.println(d1 + 1);
    //定義float變數時，必須以'f'或'F'結尾
    float f1 = 123.4F;
    System.out.println(f1);
  }
}

3.5 字元型別

char型資料通常用來表示“字元”（2位元組）
Java中所有字元都使用Unicode編碼，故一個字元可以儲存一個字母、一個漢字或其他書面語的一個字元。
字元型變數的三種表示形式：
- 字元型別的變數是使用''括起來的單個字元，如：char c1 = 'a';
- Java還允許使用轉義字元''來將其後的字元轉變為特殊字元常量，例如：char c2 = '\n';
- 直接使用Unicode值來表示字元常量，例如：'\uXXXX',其中XXXX表示一個十六進位制整數，如\u000a表示\n。
- char型別的變數是可以進行運算的。因為它們都有對應的Unicode碼。

public class VariableTest {
  public static void main(String[] args) {
    //字元型：char（1字元 = 2位元組）
    //定義char型別變數，通常使用一對''，內部只能寫一個字元
    char c1 = 'a';
    //編譯不通過
    //char c1 = 'AB';
    char c2 = '中';
    //1.宣告一個字元變數
    char c3 = '1';
    //2.使用轉義字元
    char c4 = '\n';  //換行符
    c4 = '\t';      //製表符
    System.out.print("Hello" + c5);
    System.out.println("World");
    //3.使用Unicode值表示字元常量
    char c5 = '\u0043';
    System.out.println(c5);  //輸出c
    
  }
}

3.6 布林型別

public class VariableTest {
  public static void main(String[] args) {
    //布林型別的值只有true或false
    boolean b1 = true;
    System.out.println(b1);
    boolean isMarried = true;
    //布林型別的變數常常用在條件判斷、迴圈結構中使用
    if(isMarried) {
      System.out.println("你就不能參加單身party了！很遺憾");
    } else {
        System.out.println("你應該多談談女朋友！");
      }
  }
}

3.7 自動型別轉換

/*
  前提：這裡只討論7種基本資料型別之間的相互轉換，不包括boolean型別
  自動型別轉換：
    結論：當容量小的資料型別的變數和容量大的資料型別做運算時，結果自動提升為容量大的資料型別
    特別地，當byte、short、char三種資料型別的資料做運算時，結果為int型
    byte、char、short --> int --> long --> float --> double
*/
public class VariableTest {
  public static void main(String[] args) {
    byte b1 = 2;
    int i1 = 129;
    //編譯不通過
    //byte b2 = b1+ i1;
    int i2 = b1 + i1;
    long l1 = b1 + i1;
    System.out.println(i2);
    float f1 = b1 + i1;
    System.out.println(f1);
    
    short s1 = 123;
    double d1 = s1;
    System.out.println(d1);
    
    //***********************
    char c1 = 'a';
    int i3 = 10;
    int i4 = c1 + i3;
    System.out.println(i4);

    short s2 = 10;
    //char c2 = c1 + s2;    //編譯不通過

    byte b2 = 10;
    //char c3 = c1 + b2;    //編譯不通過
    
    //short s3 = b1 + b2;  //編譯不通過
    
  }
}

3.8 強制型別轉換

/*
  強制型別轉換：自動型別轉換的逆運算
    1.需要使用強轉符：()
    2.注意點：強制型別轉換可能會導致精度損失
*/
public class VariableTest {
  public static void main(String[] args) {
    //精度損失舉例1
    double d1 = 12.3;
    int i1 = (int)d1;  //截斷操作
    System.out.println(i1);
    
    //沒有精度損失
    long l1 = 123;
    short s1 = (short)l1;
    
    //精度損失舉例2
    int i2 = 128;
    byte b1 = (byte)i2;
    System.out.println(b1);  //輸出-128
    
    //1.編碼情況1：
    long l2 = 12345;
    System.out.println(l2);  //預設int --> long（自動型別轉換）
    //編譯報錯，超出了int型的範圍
    //long l3 = 132546875564236442; 
    long l3 =  132546875564236442L;
    
    //********************************
    float f1 = 12.3;  //編譯報錯

    //2.編碼情況2：
    //整型變數預設是int
    //浮點型變數預設是double
    byte b1 = 12;
    //byte b2 = b1 + 1;      //編譯報錯
    //float f1 = b1 + 12.3;  //編譯報錯
    
  }  
  
}

3.9 String型別

/**
  String型別變數的使用:
    1.String型別屬於引用資料型別，翻譯為字串
    2.使用String型別變數時，使用一對""
    3.String型別可以和8種基本資料型別的變數做運算，且運算只能時是連線運算：+，結果為String型別
    4.
*/
public class StringTest {
  public static void main(String[] args) {
    String s1 = "Hello World";
    String s2 = "a";
    String s3 = "";
    System.out.println(s1);
    char c1 = '';  //編譯報錯
     
    //************
    int number = 1001;
    String numberStr = "學號：";
    String info = number + numberStr;  //+：連線運算
    boolean b1 = true;
    String info1 = info + b1;  //+：連線運算
    System.out.println(info);
    
    //**************
    //String str1 = 123;  //編譯報錯
    String str1 = 123 + "";
    System.out.println(str1);
    
    //int num1 = str1;  //編譯報錯
    //int num1 = (int)str1;  //編譯報錯
    int num1 = Integer.parseInt(str1);
    System.out.println(num1);  //輸出123
  }
}

4.運算子

運算子是一種特殊的符號，用以表示資料的運算、賦值和比較等。

算術運算子
賦值運算子
比較運算子（關係運算符）
邏輯運算子
位運算子
三元運算子

4.1 算術運算子

public class AriTest {
  public static void main() {
    // /：除法操作
    int num1 = 12;
    int num2 = 5;
    int result1 = num1 / num2;
    System.out.println(result1);  //輸出結果為2

    int result2 = num1 / num2 * num2;
    System.out.println(result2);  //輸出結果為10
    
    double result3 = num1 / num2;
    System.out.println(result3);  //輸出結果為2.0
    
    double result4 = num1 / num2 + 0.0;  //輸出結果為2.0
    double result5 = num1 / (num2 + 0.0);  //輸出結果為2.4
    double result6 = (double)num1 / num2;  //輸出結果為2.4
    double result7 = (double)(num1 / num2);  //輸出結果為2.0

    // %：取餘操作
    //結果的符號與被模數相同
    int m1 = 12;
    int n1 = 5;
    System.out.println("m1 % n1 :" + m1 % n1);  //輸出結果為2

    int m2 = 12;
    int n2 = -5;
    System.out.println("m2 % n2 :" + m2 % n2);  //輸出結果為2

    int m3 = -12;
    int n3 = 5;
    System.out.println("m3 % n3 :" + m3 % n3);  //輸出結果為-2
    
    int m4 = -12;
    int n4 = -5;
    System.out.println("m4 % n4 :" + m4 % n4);  //輸出結果為-2
    
    //(前)++：先自增1，後運算
    //(後)++：先運算，後自增1
    int a1 = 10;
    int b1 = ++a1;
    System.out.println("a1 = " + a1 + ",b1 =" + b1);  //輸出結果為11，11
    int a2 = 10;
    int b2 = a2++;
    System.out.println("a2 = " + a2 + ",b2 =" + b2);  //輸出結果為11，10
    
    //(前)--：先自減1，後運算
    //(後)--：先運算，後自減1
    int a3 = 10;
    int b3 = --a3;
    System.out.println("a3 = " + a3 + ",b3 =" + b3);  //輸出結果為9，9
    int a4 = 10;
    int b4 = a4--;
    System.out.println("a4 = " + a4 + ",b4 =" + b4);  //輸出結果為9，10
  }
}

4.2 賦值運算子

符號：=

當“=”兩側資料型別不一致時，可以使用自動型別轉換和強制型別轉換原則進行處理。
支援連續賦值

擴充套件賦值運算子：+=、-=、*=、/=、%=

public class SetValueTest {
  public static void main(String[] args) {
    int i1 = 10;
    int j1 = 15;
    
    //連續賦值
    int i2 = j2 = 10;
    
    int i3 = 10,j3 = 15;
    
    //**************************
    int num1 = 10;
    num1 += 2;  //等價於num1 = num1 + 2
    System.out.println(num1);  //輸出結果為12
    
    int num2 = 12;
    num2 %= 5;
    System.out.println(num2);  //輸出結果為2
    
    short s1 = 10;
    //s1 = s1 + 2;  //編譯失敗
    s1 += 2;  //不會改變變數本身的資料型別
    System.out.println(s1);
  }
}

4.3 比較運算子

比較運算子的結果都是boolean，也就是說要麼是true、要麼是false
比較運算子“==”不能誤寫成“=”

public class CompareTest {
  public static void main(String[] args) {
    int i = 10;
    int j = 20;
    System.out.println(i == j);  //false
    System.out.println(i = j);  //20
    
    boolean b1 = true;
    boolean b2 = false;
    System.out.println(b1 == b2);  //false
    System.out.println(b2 = b1);   //true
  }
}

4.4 邏輯運算子

& —— 邏輯與| —— 邏輯或! —— 邏輯非
&& —— 短路與|| —— 短路或^ —— 邏輯異或

public class LogicTest {
  public static void main(String[] args) {
    //區分：& 和 &&
    boolean b1 = true;
    int num1 = 10;
    if (b1 & (num1++ > 0)) {
      System.out.println("我現在在北京");
    } else {
        System.out.println("我現在在上海");
      }

    boolean b2 = true;
    b2 = false;
    int num2 = 10;
    if (b2 && (num2++ > 0)) {
      System.out.println("我現在在北京");
    } else {
        System.out.println("我現在在上海");
      }
  }
}

4.5 位運算子

位運算子是直接對整數的二進位制進行的運算

4.6 三元運算子

格式
(條件表示式)?表示式1:表示式2;
說明：
1.如果條件表示式的值為true，則返回表示式1的值，否則返回表示式2的值。
2.表示式1和表示式2需要可以統一為同種型別
三元運算子和if-else的聯絡和區別：
1）三元運算子可以簡化if-else語句
2）三元運算子要求必須返回一個結果
3）if後的程式碼塊可有多個語句

public class Test {
  public static void main(String[] args) {
    //獲取兩個整數的最大值
    int m = 12;
    int n = 5;
    int max = (m > n) ? m : n;
    System.out.println(max);

    //******************
    String maxStr = (m > n) ? "m大" : ((m == n)?"m和n相等":"n大");
    System.out.println(maxStr);
    
    //******************
    //獲取三個整數的最大值
    int n1 = 12;
    int n2 = 8;
    int n3 = 30;
    int max1 = (n1 > n2) ? n1 : n2;
    int max2 = (max1 > n3) ? max1 : n3;
    System.out.println("三個數中的最大數為：" + max2);
    
    int max3 = (((n1 > n2) ? n1 : n2) > n3) ? ((n1 > n2) ? n1 : n2) : n3;  //不推薦
    //改寫為if-else
    if(m > n) {
      System.out.println("最大值為：" + m);
    } else {
        System.out.println("最小值為：" + n);
      }
  }
}