最近比較煩，點背的時候，喝涼水都是塞牙的，其實我也很想趕項目，把后臺接口寫好，但是我還是姥姥實實的把基礎語法搞個大概在說吧；

做什么還是理解著做才比較有效率，最近我也是夠了，說我筆記本內存太小，太慢，影響工作，我自己加了條8G金士頓；你說之前突然我的本不能上網，說是我win8.1系統的問題，我重裝了win10企業版，誰知道不兼容，一裝軟件就崩；后來換成win10 專業版，好家伙照樣崩；最后又裝了win 8家庭版，在windows上從win8升win10專業版，換沒弄公司軟件，這次看著到挺像那么回事，我特么終于體會到了隔壁小伙筆記本天天崩的痛楚了；

昨天下班，自行車爆了，補個胎就算了，今天內外胎一起崩，要不是我氣場還行，早跳車了，然后換了個里外胎，大爺咱倆可是老熟人了，以后修車全靠您老人家了，雖然我聽不懂這個上海老大爺說的話，還好咱能比劃，也是醉了；

我上后臺，關鍵靠理解，不然今天會明天忘，到時候搞不定，不用人說我自個挖個坑把自個埋了，這點危機意識還是懟有的；

閑話不多說，看Java基礎語法吧，本人學Java通過imooc，以下知識點均來自慕課網教程，如有不足之處，請指正，我的郵箱: zhouminghang@baosight.com

理解Java中的標識符？

標識符就是用于給 Java 程序中變量、類、方法等命名的符號;

諸如：

使用標識符時，需要遵守幾條規則：

1. 標識符由字母、數字、下劃線（_）、美元符（$）組成;
   不能包含 @、%、空格等其它特殊字符;
   不能以數字開頭;

譬如：123name 就是不合法de

2. 標識符不能是 Java 關鍵字和保留字，但可以包含關鍵字和保留字;
   保留字：Java 預留的關鍵字，以后的升級版本中有可能作為關鍵字；

如：不可以使用 void 作為標識符，但是 Myvoid 可以

3. 標識符嚴格區分大小寫;

例如： admin和 Admin是兩個不同的標識符！

4. 標識符的命名最好能反映出其作用，做到見名知意；

java中變量的使用規則

變量：故名思意，就是能夠變化的值，它就相當于一個存儲空間，用來存放我們想要存放的東西，你可以隨便存什么都行；

在 Java 中，變量是由：變量類型、變量名以及變量值三部分組成；

變量的聲明寫法：

// 第一種： 聲明 + 賦值；
 變量類型 變量名 = 變量值；
    或
// 第二種： 先聲明，后賦值；
  變量類型 變量名；
  變量名 = 變量值；

舉個例子：

String myName = "adminZz";
// or
int myAge;
myAge= 23;

注意：

java是強類型語言，聲明變量前，必須指明變量類型；
它不像JavaScript（弱類型語言），所有類型的變量通過var聲明即可,而不必指明變量的類型；

Java中的數據(變量/常量)類型有哪些：

其實和JavaScript中的數據類型是差不多的，都包含基本數據類型和引用數據類型，只不過Java分的更加細致；

Java 語言是一種強類型語言。通俗點說就是，在 Java 中存儲的數據都是有類型的，而且必須在編譯時就確定其類型;

Java 中有兩類數據類型：

在 Java 的領域里，基本數據類型變量存的是數據本身，而引用類型變量存的是保存數據的空間地址;

說白了，基本數據類型變量里存儲的是直接放在抽屜里的東西，而引用數據類型變量里存儲的是這個抽屜的鑰匙，鑰匙和抽屜一一對應;

插個題外話：

類似著比較，JavaScript中的基本數據類型存放是數據本身，而相對復雜的引用數據則存放的是它所對應的內存地址,有點像C語言中的指針，前者存放在棧內存中，后者存放在堆內存中,后者在聲明的時候，會在空間中開辟一個內存，然后通過物理地址，對其所要存放的數據進行讀取或者修改操作（個人拙見）;

常用的數據類型如下：

舉個栗子如下：

int myAge = 23;//整型進行算數運算時，結果也為整形，只保留整數位，不進行四舍五入操作；
double myWeight = 130.0;//帶小數位
float myHeight = 172.2f;// 以f結尾
char mySex = '男';//char類型的值，用單引號，注意字節長度不能超過2字節，不然會報錯；
String myName = "zmh"; //String首字符大寫，值要加雙引號；
boolean iLikePrograming = true;//布爾不二，true OR false；

注意：

• Java 中的標點符號都是英文的；
• 在寫標點符號的時候要特別注意單雙引號和分號，不然你就等著一行一行調試代碼吧；

在定義變量類型是你不得不考慮的溢出問題===》字節問題

這個可以在程序里面運行，看結果就可以了；

Java中 變量名 的命名規則：

其實和標識符的規則是一樣的：

• 由字母，數字，下劃線（_），美元符($)組成，數字不能開頭；
• 不能包含其他特殊字符，如%, @ 等等；
• 不能使用保留字和關鍵字,但可以包含保留字和關鍵字（一般取得變量名都有意義，沒人無聊會去包含兩者的字段）；
• 不限長度，區分大小寫；

建議養成以下編碼習慣：

1、變量名由多單詞組成時，第一個單詞的首字母小寫，其后單詞的首字母大寫，俗稱駱駝式命名法（也稱駝峰命名法）;

如 myAge;

2、變量命名時，盡量簡短且能清楚的表達變量的作用，做到見名知意;

如：定義變量名 stuName 保存“學生姓名”信息

注意： Java 變量名的長度沒有限制，但 Java 語言是區分大小寫的，所以 price 和 Price 是兩個完全不同的變量;

Java中的關鍵字：

Java 語言中有一些具有特殊用途的詞被稱為關鍵字;

關鍵字對 Java 的編譯器有著特殊的意義，在程序中應用時一定要慎重;

Java 中常用關鍵字(不必死記硬背，大概知道有這個東西就行，命名變量的時候不要沖突)：

注意：Java 關鍵字是區分大小寫的；

變量值需要注意的地方：

• 1、Java 中的變量需要先聲明后使用;

• 2、變量使用時，可以聲明變量的同時進行初始化(賦初值)；

  • 也可以先聲明后賦值;

• 3、變量中每次只能賦一個值，但可以修改多次;

• 4、main 方法中定義的變量必須先賦值，然后才能輸出;

• 5、雖然語法中沒有提示錯誤，但在實際開發中，變量名不建議使用中文，容易產生安全隱患，譬如后期跨平臺操作時出現亂碼等等;

總結如下可能會報錯的幾種情況：

public static void main(String[] args){
   
     System.out.println("我的名字是" + myName); // 報錯，變量未聲明就使用；
    
     
     String myName_Test = "zmh";  // 變量：聲明的同時賦值   
 

     char sex ;
     sex = '男';// 或者：先聲明后賦值；
     System.out.println("我叫" + myName_Test + "，我是個" + sex +"孩子。");//我叫zmh，我是個男孩子。
        
  
    String myHobby = "啤酒炸雞"，"漂移板"；
    System.out.println("我喜歡" + myHobby); // 報錯 變量一次只能賦一個值，不能一次賦多個值；
   
  
    String myFruit = "apple";
    myFruit = "pitaya";  // 但可以多次修改變量的值，如下：
    System.out.println("我喜歡吃" + myFruit);//我喜歡吃pitaya
 
    
    String myHome;
    System.out.println("我的故鄉是" + myHome)； // 報錯：變量輸出前未賦值



    String 姓名 = "adminZz";// 不建議使用中文來命名變量，雖然不會報錯，但在跨平臺是會出現亂碼問題；
   };

java中的自動類型轉換

在 Java 程序中，不同的基本數據類型的數據之間經常需要進行相互轉換；

  int price = 20;
  double price_change = price;
  System.out.println(price_change);//20.0

代碼中 int 型變量 price 可以直接為 double 型變量 price_change 完成賦值操作，運行結果為： 20.0

這種轉換稱為自動類型轉換;

自動類型轉換需要滿足如下特定條件：

1. 目標類型能與源類型 兼容;

如 : double 型兼容 int 型，但是 char 型不能兼容 int 型;

2. 目標類型字節長度大于源類型;

如: double 類型長度為 8 字節， int 類型為 4 字節，因此 double 類型的變量里直接可以存放 int 類型的數據，但反過來int里面放double就不可以了，因為溢出了;

Java中的強制類型轉換

例如，當程序中需要將 double 型變量的值賦給一個 int 型變量，該如何實現呢？

顯然，這種轉換是不會自動進行的！

因為 int 型的存儲范圍比 double 型的小。此時就需要通過強制類型轉換來實現了。

語法：

使用小括號，小括號里面標清要強制轉換成那種類型的數據；

( 數據類型 ) 數值

舉個栗子：

// 將double轉換成int
double num1 = 125.6;
int num2 = (int) num1;
System.out.println(num1);//125.6
System.out.println(num2);//125

注意：
由上可知，通過強制類型轉換將 125.6 賦值給 int 型變量后，結果為 125，數值上并未進行四舍五入，而是直接將小數位截斷;

• 所以強制類型轉換可能會造成數據的丟失，一定要慎重！

Java常量的應用

常量，就是一種特殊的變量，它的值被設定后，在程序運行過程中不允許改變；

語法：

final 常量類型 常量名 = 常量值;

使用常量的好處：

程序中使用常量可以提高代碼的可維護性;

例如，在項目開發時，我們需要指定用戶的性別，此時可以定義一個常量 SEX，賦值為 "男"，在需要指定用戶性別的地方直接調用此常量即可，避免了由于用戶的不規范賦值導致程序出錯的情況。

注意：

常量名一般使用大寫字符;

Java中de注釋

在編寫程序時，經常需要添加一些注釋，用以描述某段代碼的作用。

一般來說，對于一份規范的程序源代碼而言，注釋應該占到源代碼的 1/3 以上。

因此，注釋是程序源代碼的重要組成部分，一定要加以重視！

Java 中注釋有三種類型：單行注釋、多行注釋、文檔注釋;

三種注釋的寫法如下：

• 單行注釋：
  • 單行注釋以//開頭，行末結束；

    // 這是單行注釋  

• 多行注釋：
  • 多行注釋以/*開頭，*/結束；

/*
* 這是多行注釋；
* 可以包含多行內容；
*/

• 文檔注釋：
  • 文檔注釋以/**開頭，以*/結束；

/**
* 這是文檔注釋
* @author zmh
* @version v1.0
*/

可以使用快捷鍵，ctrl+/是（將選中行）單行注釋，ctrl+shift+/是（將選中部分）多行注釋;

注意：

被注釋的代碼塊在程序運行時是不會被執行的;

我們可以通過 javadoc 命令從文檔注釋中提取內容，生成程序的 API 幫助文檔。

打開首頁，查看下生成的 API 文檔

PS：使用文檔注釋時還可以使用 javadoc 標記，生成更詳細的文檔信息：

     @author 標明開發該類模塊的作者

       @version 標明該類模塊的版本

       @see 參考轉向，也就是相關主題

       @param 對方法中某參數的說明

       @return 對方法返回值的說明

       @exception 對方法可能拋出的異常進行說明

什么是運算符

運算符是一種“功能”符號，用以通知 Java 進行相關的運算;

例如，我們需要將變量 age 的值設置為 20 ，這時候就需要一個“=”，告訴程序需要進行賦值操作。

Java 語言中常用的運算符可分為如下幾種：

• ? 算術運算符

• ? 賦值運算符

• ? 比較運算符

• ? 邏輯運算符

• ? 條件運算符

Java中的算術運算符

算術運算符主要用于進行基本的算術運算，如加法、減法、乘法、除法等;

Java 中常用的算術運算符：

其中，++ 和 -- 既可以出現在操作數的左邊，也可以出現在右邊，但結果是不同的；
記住口訣：同JavaScript類似，前則后，后則前(符號在前，則使用運算后的值；符號在后，則使用運算前的值；無論在前在后，這個數值一定改變)

例1：

 int a = 1;
 int b = ++a;
 System.out.println(a);//2
 System.out.println(b);//2
 
 int c = 1;
 int d = c++;
 System.out.println(c);//2
 System.out.println(d);//1

注意：
自增和自減運算符只能用于操作變量，不能直接用于操作數值或常量;

例如 : 5++ 、 8-- 等寫法都是錯誤的;

PS：
%用來求余數，也稱為取模運算符;

Java中的比較運算符

• 比較運算符用于判斷兩個數據的大小，例如：大于、等于、不等于;
• 比較的結果是一個布爾值（ true 或 false ）;

Java 中常用的比較運算符如下表所示：

注意：

1. > 、 < 、 >= 、 <= 只支持左右兩邊操作數是數值類型;

2. ==、!= 兩邊的操作數既可以是數值類型，也可以是引用類型;

3. = 是賦值， ==才是等于；

   • 在JavaScript中判斷值相等用==,判斷值與類型相等用===；

Java中的邏輯運算符

邏輯運算符主要用于進行邏輯運算；

Java 中常用的邏輯運算符如下表所示：

我們可以從“投票選舉”的角度理解邏輯運算符：

1、 與：要求所有人都投票同意，才能通過某議題;

2、 或：只要求一個人投票同意就可以通過某議題;

3、 非：某人原本投票同意，通過非運算符，可以使其投票無效;

4、 異或：有且只能有一個人投票同意，才可以通過某議題

• 當使用邏輯運算符時，我們會遇到一種很有趣的“短路”現象;

譬如：( one > two ) && ( one < three ) 中，如果能確定左邊 one > two 運行結果為 false , 則系統就認為已經沒有必要執行右側的 one < three ;

===========

同理，在( one > two ) || ( one < three ) 中，如果能確定左邊表達式的運行結果為 true , 則系統也同樣會認為已經沒有必要再進行右側的 one < three 的執行啦！

對比JavaScript中的邏輯運算：

• 與： 都真才真，有假則假；
• 或： 有真則真，全假才假；
• 非： 真則假，假則真；

對應倆側的條件表達式執行情況：

• 與： 左真，才執行右側條件；左假，右不執行；
• 或： 左為真，右不執行；左為假，右才執行；

Java中的條件運算符

條件運算符（ ? : ）也稱為 “三元運算符”,類似JavaScript中的三目運算（也相當于變相的if...else）;

語法：

布爾表達式 ？ 表達式1 ：表達式2;

解析（與JavaScript同理）：

如果布爾表達式（條件表達式）的值為 true ，則執行并返回 表達式1 的值，否則執行并返回 表達式2 的值;

舉個栗子：

int a = 3;
int b = 4;
String result_test = a > b? "a大于b": "a不大于b"；
System.out.println(result_test);//a不大于b

因為3>4 為false，輸出 "a不大于b";

Java中運算符的優先級

所謂優先級，就是在表達式中的運算順序;

Java 中常用的運算符的優先級如下表所示：

級別為 1 的優先級最高，級別 11 的優先級最低;

對比JavaScript中的優先級：

小括號 > 自增/自減/非 > 算術運算符（ 乘/除/取余 > 加/減；同級之間按從左到右順序執行） > 關系運算符 > 邏輯運算符 > 賦值運算符（=）；

注意：

• 賦值運算符和算術運算符一起使用，會降低算術運算符的優先級，優先級同賦值運算相同；

PS：大家沒必要去死記運算符的優先級順序，實際開發中，一般會使用小括號(能夠更直觀的指明運算優先級)輔助進行優先級管理;

舉個栗子：

    public static void main(String[] args) {
        int m = 5;
        int n = 7;
        int  x = ( m * 8 / ( n + 2 ) ) % m ;
        System.out.println("m:" + m);//5
        System.out.println("n:" + n);//7
        System.out.println("x:" + x);//4
    }

注意：

• int是整型數，所以要取整；
• 兩個整型相除結果為整型；

Java條件語句之 if

if 條件語句:

先判斷條件，條件滿足后才執行的情況;

語法：

if(條件){
    // 條件為真時，執行的代碼；
}

注意：

• 如果 if 條件成立時的執行語句只有一條，是可以省略大括號;
• 但如果執行語句有多條，那么大括號就是不能省略；
• 建議：都不省略大括號；

System.out.println(用雙引號還是用單引號，看字節長度)；

• 單引號--char--2字節；
• 上引號--String；

System.out.println("wo shi shei1");//wo shi shei1
System.out.println('wo shi shei2');//報錯
System.out.println('w');//w

Java中無論是漢字還是英文字母都是用Unicode編碼來表示的;
一個Unicode碼是16位，每字節是8位，所以一個Unicode碼占兩字節。
但是英文字母比較特殊，源自于8位（1字節）的ASCII碼，于是在Unicode碼僅使用了低8位（1字節）就可以表示，高8位的話不使用也無所謂。

====

所以char c='a';System.out.println(c.getBytes().lenth()),得到的是1（字節）但漢字就完整地使用了16位（2字節）的Unicode，所以char c='中';System.out.println(c.getBytes().lenth()),得到的是2（字節）
綜上，c='a'在內存中確實只占1字節，但這不意味著String s="abc"在內存中只占3字節。
應該這么說，String s="abc"至少在內存中占3字節。這是因為char是基本數據類型，而String確是對象類型。對象是一種很復雜的數據類型，你要看一個對象具體占多少字節，可以把這個對象序列化后存入一個文本文件來看它具體占用了多少字節，當然這也不是精確的，因為序列化需要寫入少量系統信息，但大致是對的。

Java條件語句之 if...else

if...else 語句的操作比 if 語句多了一步:

• 當條件成立時，則執行 if 部分的代碼塊；
• 條件不成立時，則執行else部分的代碼塊;

語法：

if(條件的布爾表達式){
    為真，執行代碼塊1；
}else{
    為假，執行代碼塊2；
}

等價于：三目運算(如果限制代碼的精簡性，建議使用三目運算,有的面試題會有這種要求的)；

條件的布爾表達式？(為true，代碼塊1) ：(為false，代碼塊2)；

Java條件語句之多重 if

多重 if 語句，在條件 1 不滿足的情況下，才會進行條件 2 的判斷；
當前面的條件均不成立時，才會執行 else塊內的代碼；

語法：

if(條件1){
    條件1為真，執行代碼塊1；
}else if(條件2){
    條件1為假，條件2為真，執行代碼塊2；
}else if(...){
    .....
}else if(條件n){
    條件1~（n-1）為假，條件n為真，執行代碼塊n；
}else{
    條件1~n都為假，才執行代碼塊（n+1）；
}

注意：條件表達式之間不能有交集，也不能寫的太冗余，防止跳樓事件；

舉個栗子：
假設年齡大于 60 歲，則提示“老年”；如果年齡介于 40 歲至 60 歲之間，則提示“中年”；如果年齡介于 18 歲至 40 歲之間，則提示“少年”； 18 歲以下則提示“童年”

• 條件表達式無冗余：

public static void main(String[] args) {
        int age=25;
        if(age >= 60){
            System.out.println("老年人");
        }else if( age >= 40){
            System.out.println("中年人");
        }else if(age >= 18){
            System.out.println("少年人");
        }else{
            System.out.println("童年人");
        }
    }

• 冗余的表達式(表達式中有無用的表達式，增加了判斷的次數，盡量避免該寫法)：

        if(age >= 60){
            System.out.println("老年人");
        }else if( age >= 40 && age < 60){
            System.out.println("中年人");
        }else if(age >= 18 && age < 40){
            System.out.println("少年人");
        }else{
            System.out.println("童年人");
        }

• 無冗余且 精簡的代碼：

System.out.println(age>60 ? "老年" :age>=40 ? "中年" : age>=18? "少年" : "童年");

Java條件語句之嵌套 if

嵌套 if 語句，只有當外層if的條件成立時，才會判斷內層 if 的條件；

語法：

if(條件1){
    if(條件2){
        在條1為真前提下，條2為真，執行代碼塊1；
    }else{
        在條1為真前提下，條2為假，執行代碼塊2；
    }
}else{
    條1為假，執行代碼塊3；
}

流程圖：

舉個栗子：

注意：判斷字符串內容是否相同不能使用==，要使用equals（）；

equals("字符串內容")用于判斷字符串的內容是否相同，相同返回true，不相同返回false；

這個我印象賊深刻，因為我第一次寫后臺接口，通過判斷傳過來的params上的參數，是否為某個字符串時，怎么怎么樣，當時我寫的==，報錯了，然而我并不知道怎么個回事，哈哈；

if(eiInfo.getString("selected"))后面忘記了

舉個栗子(String的equals())：
預賽成績大于 80 分的可進入決賽，然后根據性別再劃分為男子組決賽和女子組決賽。

public static void main(String[] args) {
    int score = 94;
        String sex = "女";
        if(score > 80){
            if(sex.equals("女")){
               System.out.println("進入女子組決賽");
            }else{
               System.out.println("進入男子組決賽");
            }
        }else{
             System.out.println("你被淘汰了");
        }
}

針對java中if語句的總結：

• if 后小括號里必須是一個條件表達式，結果為布爾值，如果為 true ，則執行后面大括號中的代碼，如果為 false ，則不執行；

• if語句后可跟else語句，也可不跟；

• if語句可實現深層嵌套；

Java條件語句之 switch

當需要對選項進行等值判斷時，使用switch 語句更加簡潔明了;

語法：

switch(){
    case 值1：
        執行代碼塊1;
        break;
    case 值2：
        執行代碼塊2;
        break;
        
        ...
        
    case 值n：
        執行代碼塊n;
        break;
    default:
        默認執行的代碼；
}

執行過程：

1. 當 switch 后表達式的值和 case 語句后的值相同時，

2. 從該位置開始向下執行，直到遇到 break 語句或者 switch 語句塊結束；

3. 如果沒有匹配的 case 語句則執行 default塊的代碼;

注意：

1. switch 后面小括號中表達式的值必須是整型或字符型;

2. case 后面的值可以是常量數值，如1、2；
   也可以是一個常量表達式，如 2+2 ；
   但不能是變量或帶有變量的表達式，如 a * 2;

3. case 匹配后，執行匹配塊里的程序代碼，如果沒有遇見 break 會繼續執行下一個的 case 塊的內容，直到遇到 break 語句或者 switch 語句塊結束,如下：

   
   

4. 可以把功能相同的 case 語句合并起來，舉栗子如下：

   • 通過月份，判斷對應的季節；

int month = 1； 
switch(month){
    case 3:
    case 4:
    case 5:
        System.out.println("春季");
        break;
    case 6:
    case 7:
    case 8:
        System.out.println("夏季");
        break;
    case 9:
    case 10:
    case 11:
        System.out.println("秋季");
        break;
    case 12:
    case 1:
    case 2:
        System.out.println("冬季");
        break;
    default:
        System.out.println("輸入月份有誤！");
}// 冬季

5. default 塊可以出現在任意位置，也可以省略;

Java循環語句之 while

Java 常用的 3 種循環：

• while
• do...while
• for

while語法：

while(判斷條件){
    執行的循環操作;
}

執行過程：

• 第1步： 判斷 while 后面的條件是否成立( true / false )

• 第2步： 當條件成立時，執行循環內的操作代碼 ，然后重復執行步驟1,2， 直到循環條件不成立為止；

特點： 先判斷，后執行，可能循環體一次都不會執行；

舉個栗子：

 public static void main(String[] args) {
        int i = 1; // 代表 1 - 5 之間的數字
        // 當變量小于等于 5 時執行循環
        while (   i<=5    ) {
            // 輸出變量的值，并且對變量加 1，以便于進行下次循環條件判斷
            System.out.println(i);
            // 該變量日益趨近條件為假，否則是死循環
            i++;
        }
        // 輸出結果為：1 2 3 4 5 
}

注意：

• 必須有一個動態變化的變量，日益趨近能夠使while后面的表達式為假，否則程序將進入死循環；

Java循環語句之 do...while

do...while 循環與 while 循環語法有些類似，但執行過程差別比較大;

語法：

do{
    循環操作
}while(判斷條件)

執行過程：

• 1. 先執行一遍循環操作，然后判斷循環條件是否成立；
• 2. 如果條件成立，繼續執行1和2，直到循環條件不成立為止；

特點：

• 先執行，后判斷；

• do...while 語句保證循環至少被執行一次！

Java循環語句之 for

Java 的循環結構中除了 while 和 do...while 外，還有 for 循環，三種循環可以相互替換;

語法：

for(循環變量初始化； 循環條件； 循環變量變化) {
    //  循環體，要重復執行的操作；
}

執行過程：

1、 執行循環變量初始化部分，設置循環的初始狀態，此部分在整個循環中只執行一次；

2、 進行循環條件的判斷，如果條件為 true ，則執行循環體內代碼；如果為 false ，則直接退出循環；

3、 執行循環變量變化部分，改變循環變量的值，以便進行下一次條件判斷；

4、 依次重新執行 2 、 3 、 4 ，直到退出循環；

特點：相比 while 和 do...while 語句結構更加簡潔易讀;

彎彎繞，注意留心的幾個小細節：
1、 for 關鍵字后面括號中的三個表達式必須用; 隔開;
比較膩害的：三個表達式都可以省略，但 “;” 不能省略；

• 省略循環變量初始化，可以在 for 語句之前由賦值語句進行變量初始化操作，如:

int i = 0; // 循環變量i在for語句之前賦值
for( ; i < 10; i++){//省略初始化變量
  System.out.println(i);
}

• 省略循環條件，可能會造成循環將一直執行下去，也就是我們常說的死循環現象，如:

for( int i = 0;  ; i++){//省略循環條件（死循環）
  System.out.println(i);
}

在編程過程中要避免“死循環”的出現，因此，對于上面的代碼可以在循環體中使用break 強制跳出循環；

• 省略循環變量變化，可以在循環體中進行循環變量的變化，如：

for( int i = 0;   i < 10;){//按順序，依次匹配 初始值，判斷條件，變化值
  System.out.println(i);
  i++；//變化值放循環體內部
}

2、 for 循環變量初始化和循環變量變化部分，可以是使用 ,同時初始化或改變多個循環變量的值，如：

for(int i =1, j = 5; i<=5; i++, j--){
     System.out.println(i + "+" + j + "=" + (i + j));
}

代碼中，初始化變量部分同時對兩個變量 i 和 j 賦初值，循環變量變化部分也同時對兩個變量進行變化，運行結果：

for(int i = 1; i <10 && i != 5; i++) {
    System.out.println(i);
}

代碼中，必須同時滿足變量 i 小于 10 ，并且 i 不等于 5 時才會進行循環，輸出變量 i 的值;

其實java中for循環和JavaScript中的for循環沒什么兩樣，區別就在于Java指定了變量類型,其他的地方兩者同樣適用

熬夜有害健康，建議你通宵熬！