基本語法（一）程式的基本結構 Java程式的基本形式 Java語言是面向對象的語言。Java程式主要以類的形式存在，也叫Class，類也是Java程式的最小程式單位。 Java程式要求所有執行語句、方法都必須放在類里。最簡單的Java程式：在上面的 Hello 類中，只是一個空類的定義，沒有任 ...

基本語法（一）

程式的基本結構

Java程式的基本形式

Java語言是面向對象的語言。Java程式主要以類的形式存在，也叫Class，類也是Java程式的最小程式單位。

Java程式要求所有執行語句、方法都必須放在類里。

最簡單的Java程式：

class Hello {
}

在上面的 Hello 類中，只是一個空類的定義，沒有任何的類成分，可以通過編譯，但執行時會報錯誤提示。

因為規定某個類如果需要被解釋器直接解釋執行，需要包含 main() 程式入口方法，而且還要使用 public static 來修飾，返回值類型還要設置為void，另外此方法的參數還得是 String[] args 字元串數組。

public static void main(String[] args) {
  System.out.println("hello");
}

將來，就算我們 Java 程式慢慢變複雜了，但對一個 Java 程式來講，只需要在一個類中有一個作為“入口”的 main 方法就好，其他的類都會被 main()方法直接或者間接調用。

Java程式的運行機制

電腦高級語言按程式的執行方式有兩種：編譯型和解釋型。

編譯型：
有專門的編譯器，針對不同的操作系統，將源代碼直接編譯成當前系統硬體執行的機器碼，然後包裝成當前系統能識別且可執行的程式格式。所生成的可執行性程式能夠在特定的系統平臺上運行，不受開發環境限制。如果是想在不同的系統平臺上執行，就需要將源代碼直接放到不同系統平臺中的編譯器里再度編譯，方可執行。
常見的編譯型語言有：C、C++、Swift、Kotlin、Objective-C 等等。

解釋型：
有專門的解釋器，對源程式逐行解釋成當前系統平臺的機器碼並立即執行的語言。解釋型語言，每次執行的時候，都需要進行一次編譯，相當於把編譯型語言中的編譯和解釋過程混合到一起同時完成。所以，它的效率比較低，還不能脫離解釋器獨立運行。但它的優點是，跨平臺運行特別簡單，只要對應的平臺上有相關的解釋器即可。
常見的解釋型語言有：JavaScript、Ruby、Python 等等。

JVM初識

Java 語言非常特殊，Java 源程式也會經過編譯，但編譯後不會生成特定平臺的機器碼，而是會生成一種與平臺無關的位元組碼文件。但位元組碼文件不可執行，如果要執行，需要使用 Java 解釋型器來解釋執行。所以，Java 程式的執行過程，必須經過先編譯、後解釋兩個步驟。可認為，Java 語言既是編譯型語言，也是解釋型語言。

運行過程：

Java源文件(xxx.java)通過javac指令進行編譯，得到位元組碼文件(xxx.class)。
位元組碼文件通過java指令解釋執行，位元組碼經過JVM(解釋器)的處理後生成電腦可以直接執行的機器碼，至此java程式才能得以正確運行。

編程規範

Java源文件的命名規則

Java 程式的源文件的擴展名為：xxx.java
如果類使用 public 進行修飾，則文件名要和類名一致。一個 Java 源文件中，可以定義多個 class，相互之間完全獨立，但一個類中只能有一個 public 修飾的類。
一般情況下，建議一個 Java 源文件，只定義一個 Java 類即可。而且，最好源文件名與 public 所修飾的類名一致。

Java語言的大小寫問題

Java語言嚴格區分大小寫，對大小寫敏感。

Java語言規定的“關鍵字”單詞全部都是小寫的。

路徑中的空格問題

文件夾命名時，文件夾名稱千萬不能有空格。（切記！！！切記！！！切記！！！）

main()方法問題

一個 Java 程式，如果要運行它的話，必須包含 main() 方法，具體格式如下：

public static void main(String[] args) {
  // 需要執行的代碼語句
  System.out.println("hello lucaswangdev");
}

標識符

常見分隔符：

在 Java 語言中，常見的分隔符主要有：分號、花括弧、方括弧、圓括弧、空格、圓點等。

分號

在寫代碼的時候，每一句代碼的結束，都需要使用分號來標明。

System.out.println("每一句代碼，都是用分號來結束的");

花括弧

花括弧，主要是用來定義一個代碼塊。代碼塊，指的就是使用“{”符號作為開始，和“}”符號作為結束，所包含的一

段代碼，在邏輯上是一個整體。

{
  	System.out.println("I");
    System.out.println("Love");
    System.out.println("Java");
}

方括弧

方括弧，主要是用來訪問數組元素，經常緊跟數組變數名，方括弧中主要指定數組元素的索引值。

String[] names = {"張三", "李四", "王五"};
System.out.println(names[1]); // 李四

圓括弧

定義方法的時候，可以用來聲明所有的形參。
```
public void setName(String name){...}
```
調用方法的時候，可以用來傳遞實參。
```
setName("jiajia");
```
在計算的時候，提升計算的優先順序。
```
int num = 2 * (3 + 5);
```
對類型進行強制轉換。
```
int num2 = (int) 3.14;
```

空格

空格，主要用於分隔一條語句中的不同部分。

圓點

圓點，一般用作類/對象和它的成員（包括成員變數、方法和內部類之間的分隔符），表明調用某個類或某個實例的指定成員。

標識符命名規則

標識符，主要是用於給程式中變數、類、方法命名的符號。Java 語言的標識符，必須以字母、下劃線、美元符開頭，後面可以跟任意數目的字母、數字、下劃線和美元符。

在書寫的時候，特別要註意大小寫的問題。

具體書寫規則如下：

可以由字母、數字、下劃線和美元符組成，其中不能以數字開頭。
不能是 Java 關鍵字和保留字，但可以包含關鍵字和保留字。
不能包含空格。
只能包含美元符號，不能包含其他 @、#、% 等特殊符號。

約定：

標識符要符合語義信息
包名所有字母小寫
類名每個首字母大寫其他小寫
變數和方法第一個單詞小寫第二個開始首字母大寫
常量所有首字母大寫

關鍵字

Java 中的關鍵字，是一些具有特殊用途的單詞，也叫 keyword。所有的關鍵字都是小寫的，在書寫的時候要特別註意。另外true 、false和null都不是關鍵字，而是特殊的直接量。

數據類型

數據類型分類

Java 語言是強類型語言，強類型主是指：

所有的變數，必須先聲明，後使用；
指定的變數只能接類型與之匹配的值。

每個變數、每個表達式，在編譯時，就已經被確定對應的類型。類型，能夠限制一個變數能被賦的值，能夠限制一個表達式可以產生的值，這就可以限制了在這些值上可以進行的一些操作和操作的意義。

語法格式：

type varName [= varValue];

int age;
String name = "lucaswangdev";

Java 支持的數據類型主要有兩種：**基本數據類型 **和 引用數據類型。

基本數據類型

如何使用？

當你表示整數時就用 int（年齡、商品數量等），如果是小數就用 double（商品價格、身高等）。
當你表示時間數值、文件、記憶體大小（程式中以位元組為單位統計大小的）就用 long，對於那些較大的數據也使用 long。
如果在 I/O 操作和網路編程中，涉及內容傳遞，或者編碼轉換時使用 byte。
如果在邏輯判斷中，則需要使用 boolean 值作為判斷條件，要麼 true，要麼 false。
當你需要處理中文的時候，使用 char。

整型

整型主要指的是以下四種類型：byte、short、int、long。

【註意】在指定 long 型整數的時候，需要在這個整數值後增加字母 L，也可以是小寫 l。

// 100為byte類型
byte num = 100;

// 777L為long類型
long bigNumber = 777L;

什麼是變數？變數有什麼用？

編程的本質，就是對記憶體中數據的訪問和修改。程式所用的數據都會保存在記憶體中，開發者需要一種方式去訪問或修改記憶體中的數據。

數據溢出會出現什麼情況？

    public static void main(String[] args) {
        // 最大值和最小值
         int max = 2147483647;
         int min = -2147483647;
        // 最大值 +1
         System.out.println(max + 1);
        // 最小值 -1
         System.out.println(min - 1);
    }

// 解決方法1：		
public static void main(String[] args) {
    // 最大值和最小值
    long max = 2147483647;
    long min = -2147483647;
    // 最大值 +1
    System.out.println(max + 1);
    // 最小值 -1
    System.out.println(min - 1);
}

// 解決方法2：		
public static void main(String[] args) {
    // 最大值和最小值
    int max = 2147483647;
    int min = -2147483647;
    // 最大值 +1
    System.out.println(max + 1L);
    // 最小值 -1
    System.out.println(min - 1L);
}

字元型

字元型，一般用來表示單個的字元，並需要使用一對單引號（''）包含起來。

字元型的三種表示形式：

指定單個字元，比如‘A’、‘1’、‘i’ 等。
指定轉義字元，比如‘\n’、‘\r’ 等。
指定 Unicode 值，比如 ‘\uXXX’ 等。

常用轉義字元：

\b 退格
\f 換頁
\n 換行
\r 回車
\t 下個tab
\ ' 單引號 ‘
\ " 雙引號 "

浮點型

Java 的浮點類型有兩種：float 和 double。

Double

Java 語言的浮點類型，預設是 double 類型，也可以在一個浮點數後加 d 或 D（不過沒必要）。

double 是雙精度浮點數，一個 double 類型的數值占 8 位元組、64 位。

double 型數值，第 1 位是符號位，接下來的 11 位表示指數，再接下來 52位表示尾數。

Float

float 是單精度浮點數，一個 float 類型的數值占 4 位元組、32 位。

float 型數值，第 1 位是符號位，接下來的 8 位表示指數，再接下來 23 位表示尾數。

如果想把一個浮點數當作 float 類型使用，則需要其後加上 f 或 F。

布爾型

布爾型，也叫 boolean 型，只有兩個值：真（true）和假（false）。 boolean 類型的值或變數主要用作旗標來進行流程式控制制，常用在以下幾種流程中：

if 條件流程式控制制語句
while 迴圈流程式控制制語句
do…while 迴圈流程式控制制語句
for 迴圈流程式控制制語句
三目運算

基本數據類型轉換

自動類型轉換

如果系統支持把某種基本類型的值直接賦給另一種基本類型的變數，這種方式就是自動類型轉換。

就好比，有兩個瓶子，將小瓶中盛滿的水導入空著的大瓶子，不會溢出來。

int ii = 88;
// int ii 轉float
float ff = ii;

byte bb = 5;
// byte轉char會報錯
char cc = bb;

// byte可以轉換成double,輸出 5.0
double dd = bb;
System.out.println(dd);

註意：

把任何基本類型的值 + 字元串值的時候，都會自動被轉成字元串類型（引用數據類型）。

// 不管是什麼數據類型，只要跟字元串相連，最終都變成字元串
String str = 6.66f + "";
System.out.println(str);
// 從左往右運算，列印 6Java
System.out.println(1 + 2 + 3 + "Java");
// 從左往右運算，全都轉成字元串了，列印 Java123
System.out.println("Java" + 1 + 2 + 3);

自動轉換：

// 一個整數，預設就是 int 類型
// 一個浮點數，預設就是 double 類型

// 左邊是 long 類型，右邊是預設的 int 類型，左右不一樣
// 等號代表賦值，將右側的int常量，交給左側的long變數進行存儲
// int -> long，符合了數據範圍從小到大的要求
// 這一行代碼發生了自動類型轉換。
long num1 = 100;
System.out.println(num1);
System.out.println(Utils.getType(num1)); //class java.lang.Long

// 100 // 左邊是double類型，右邊是float類型，左右不一樣
// float -> double，符合從小到大的規則
// 也發生了自動類型轉換
double num2 = 2.5F;
System.out.println(num2); // 2.5
System.out.println(Utils.getType(num2)); //class java.lang.Double

// 左邊是float類型，右邊是long類型，左右不一樣
// long --> float，範圍是float更大一些，符合從 小到大的規則
float num3 = 30L;
System.out.println(num3); // 30.0
System.out.println(Utils.getType(num3)); // class java.lang.Float

強制類型轉換

強制轉換，類似將大瓶子的水直接導入一個空的小瓶中，會引起溢出，數據丟失。

強制轉換：

//左邊是int類型，右邊是long類型，不一樣
//long --> int，不是從小到大
//不能發生自動類型轉換！
//格式：範圍小的類型 範圍小的變數名 = (範圍小的類型) 原本範圍大的數據;
int num = (int) 100L;
System.out.println(num);

// long強制轉換成為int類型
int num2 = (int) 6000000000L;
System.out.println(num2);// 1705032704

// double --> int，強制類型轉換
int num3 = (int) 3.99; // 3，這並不是四捨五入，所有的小數位都會被捨棄掉
System.out.println(num3);

// 這是一個字元型變數，裡面是大寫字母A
char c1 = 'A'; // 66，也就是大寫字母A被當做65進行處理
System.out.println(c1 + 1);
// 電腦的底層會用一個數字（二進位）來代表字元A， 就是65
// 一旦char類型進行了數學運算，那麼字元就會按照一 定的規則翻譯成為一個數字

byte num4 = 40; // 註意！右側的數值大小不能超過 左側的類型範圍
byte num5 = 50;
// byte + byte --> int + int --> int
int result1 = num4 + num5;
System.out.println(result1); // 90

short num6 = 60;
// byte + short --> int + int --> int
// int強制轉換為short：註意必須保證邏輯上真實大小 本來就沒有超過short範圍，否則會發生數據溢出
short result2 = (short) (num4 + num6);
System.out.println(result2); // 100

類型判斷

9種預定義的基本類型Class對象，8個基本類型和void，這些都有Java虛擬機創建的，並且具有相同的名稱。

//public native boolean isPrimitive();

System.out.println(byte.class.isPrimitive()); // true
System.out.println(short.class.isPrimitive());// true
System.out.println(int.class.isPrimitive());// true
System.out.println(long.class.isPrimitive());// true
System.out.println(float.class.isPrimitive());// true
System.out.println(double.class.isPrimitive());// true
System.out.println(char.class.isPrimitive());// true
System.out.println(boolean.class.isPrimitive());// true
System.out.println(void.class.isPrimitive());

類型判斷的方法：

//獲取變數類型方法
public static String getType(Object object){
    return object.getClass().toString();
}

運算符

算術運算符

算術運算符主要是基本的數學運算：加、減、乘、除和求餘等

// 加法
int a = 11;
int b = 12;
int sum = a + b;

//減法
int c = 15;
int d = 10;
int sub = c - d;

// 乘法
int e = 2;
int f = 3;
int multiply = e * f;

// 除法
int g = 18;
int h = 9;
int div = g / h;
System.out.println("div = " +div);

double i = 3.0;
double j = g / i;
System.out.println("j = " + j);

//如果除數是0.0，則得到正無窮大， Infinity
//如果除數是-0.0，則得到負無窮大， -Infinity
double k = g / 0.0;
System.out.println("k = " + k); // k = Infinity

// java.lang.ArithmeticException: / by zero
//int l = g / 0;
//System.out.println("l = " + l);

// 取餘
// 前者除以後者，得到一個整除的結果後剩下的值就是餘數
int m = 5;
int n = 2;
int o = m % n;
System.out.println("o = " + o);

// 對 0.0 求餘，則得到非數
Object p = m % 0.0;
System.out.println("p = " + p);

自加和自減

自加，用 ++ 表示，它是單目運算符，只能操作一個操作數。自加運算符只能操作單個數值型（整型、浮點型等）的變數，不能操作常量或表達式。

運算符可以出現在操作數的左邊，也可以出現在右邊，但特別要註意，出現左邊和右邊的最終效果是不一樣的。

如果把 ++ 放在左邊，則先把操作數加 1；然後才把操作數放入表達式中運算。

如果把 ++ 放在右邊，則先把操作數放入表達式中運算，然後才把操作數加1。

++a
a = a + 1;
return a;

a++
temp = a;
a = a + 1;
return temp;

x++ increments the value of variable x after processing the current statement.
++x increments the value of variable x before processing the current statement.

So just decide on the logic you write.
x += ++i will increment i and add i+1 to x. 
x += i++ will add i to x, then increment i.

例：

int a = 66;
// 先將 a 的值，放入表達式中進行運算，然後再給 a 加 1
int b = a++ + 10;
// 先將 a 加上 1，然後將新得到的值，再放入表達式中進行運算
int c = ++a + 10;
System.out.println("a = " + a); // 68
System.out.println("b = " + b); // 76
System.out.println("c = " + c); // 78

複雜數學運算

一般我們使用 java.lang.Math 類的工具方法來完成複雜的數學運算，比如有乘方、開方等。

Math 類中包含了非常多的靜態方法，用於完成各種複雜的數學運算。

int a = 12;
// 乘方
double b = Math.pow(a, 10);
// 平方根
double c = Math.sqrt(a);
// 隨機數
double d = Math.random();
// 三角函數：sin
double e = Math.sin(2.34);
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
System.out.println("d = " + d);
System.out.println("e = " + e);
//        a = 12
//        b = 6.1917364224E10
//        c = 3.4641016151377544
//        d = 0.24282712973853993
//        e = 0.7184647930691261

特殊的 + 號

特別要註意，+ 號除了是加號以外，它還可以作為字元串的連接符運算符使用。

int year = 2020;
String str = "年";
System.out.println(year + str);

賦值運算符

Java 使用 = 號作為賦值符號，用於為變數指定變數值。

int a = 12; 
char b = ‘h’; 
boolean c = true; 
// 將變數 a 賦值給 d 變數 
int d = a;

特別要註意，賦值運算符是從右向左執行計算的，程式先計算得到 = 右邊的值，然後將該值“交給” = 左邊的變數，變數相當一個容器，可以接收被賦的值。

位運算符

&：按位與，當兩位同時為 1 時才返回 1。

|：按位或，只要有一位為 1 即可返回 1。

~：按位非，單目運算符，將操作數的每個位（包括符號位）全部取反。

^：按位異或，當兩位相同時返回 0，不同時返回 1。

<<：左移運算符，將操作數的二進位碼整體左移指定位數，左移後右邊空

出來的位以 0 填充。

>>：右移運算符，把第一個操作數的二進位碼右移指定位數後，左邊空出

來的位置以原來的符號位填充。

>>>：無符號右移運算符。把第一個操作數的二進位碼右移指定的位數後，

左邊空出來的位置，總是以 0 來填充。

比較運算符

主要用於判斷兩個變數或常量的大小，比較運算的結果是一個布爾值（true 或 false）。

>：大於

>=：大於等於

<：小於

<=：小於等於

==：等於。

如果進行比較的兩個操作數，都是數值類型，即使它們的數據類型不同，只要它們的值相等，就會返回 true。

如果兩個操作數都是引用類型，那麼只有當兩個引用變數的類型具有父子

關係時才可以比較，而且這兩個引用必須指向同一個對象才會返回 true。

!=：不等於

邏輯運算符

&&：與，前後兩個操作數必須都是 true 才返回 true，否則返回 false。

&：不短路與，作用與 && 相同，但不會短路。

||：或，只要兩個操作數中有一個是 true，就可以返回 true，否則返回

false。

|：不短路或，作用與 || 相同，但不會短路。

!：非，只需要一個操作數，如果操作數為 true，則返回 true。

^：異或，當兩個操作數不同時才返回 true，相同時返回 false。

System.out.println(6 > 3 && '7' > 22);
System.out.println(6 >= 7 || 'h' > 'b');
System.out.println(6 >= 7 ^ 'h' > 'b');
int a = 6;
int b = 12;
if (a > 3 | b++ > 12) {
    System.out.println("a 的值：" + a);
    System.out.println("b 的值：" + b);
}
int c = 6;
int d = 12;
if (c > 3 || d++ > 12) {
    System.out.println("c 的值：" + c);
    System.out.println("d 的值：" + d);
}

三目運算符