# :-: Java基本語法
[TOC]
Java基本語法，包括：
注釋； 關鍵字；標識符；常量；變量；運算符；流程控制語句；函數；數組；
# 1.關鍵字
關鍵字：被Java語言賦予了特定含義的一些字符！關鍵字中所有字母都為小寫。好比漢字中的專有名詞，例如：中國、北京、陜西等。一般我們不能將這些詞用在其他地方，改變其含義。
不用刻意去記每個關鍵字的用法和意義，后面學習中，陸陸續續都會接觸到，自然而然就記住了。
# 2.標識符
可簡單理解為在Java程序中為了增強閱讀性自定義的名稱。比如：類名，方法名，變量名等。
（就是程序員給自己定義的東西起的名字）
標識符組成：
(1) 標識符由字母、數字、下劃線、$組成，不能以數字開頭，注意：此處的字母還可以是中文，日文等；
(2) 標識符大小寫敏感；A a
(3) 標識符不得使用java中的關鍵字和保留字；
(4) 別用Java API里面的類名作為自己的類名。
注意：在起名字的時，只要標識符不是關鍵字就可以了，但為了提高閱讀性，經常用有意義的英文單詞作為標識符。
標識符書寫規范：
包名：多單詞組成時所有字母都小寫。xxxyyyzzz
類名接口名：每一個單詞的首字母都要大寫，其他字母小寫；
變量名和函數名：多單詞組成時，第一個單詞首字母小寫，第二個單詞開始每個單詞首字母大寫。xxxYyyZzz
常量名：所有字母都大寫。多單詞時每個單詞用下劃線連接。XXX_YYY_ZZZ
# 3.常量
在日常生活中，經常使用數據表示事物的某些特性。比如：年齡，身高，日期等等，這些數據都是具體的數值。那么在Java中像這樣的數據如何描述呢？像這樣數值確定的數據，Java中用常量來描述。
## 3.1.常量概念
常量：程序中固定不變化的值。
3.2.常量分類：
1）整數常量。所有整數 三類 正整數 零 負整數
2）浮點數常量（小數常量）。所有帶小數點的數
3）布爾(boolean)型常量。較為特有，只有兩個數值。true false。
4）字符常量。在Java中指的是使用英文的單引號括起來的一個字符；
5）字符串常量。在Java中指的是使用英文的雙引號括起來的不限制數量的字符（可以一個都沒有，也可以是一個，也可以是多個）；
6）null常量。只有一個數值就是:null.
## 3.2.進制（了解）
二進制的由來：
日常生活中，經常使用十進制運算數據，但是也接觸過七進制、十二進制等。那么怎么把生活中的這些數據存放在計算機中，計算機又是如何表示這些數據呢？
任何數據在計算機中都是以二進制的形式存在的。二進制早起由電信號開關演變而來。用開表示某一個數，用關表示某一個數，然后使用不同的開和關組合起來，就可以表示數據了。
一個整數在內存中一樣也是二進制的。
二進制：每一個二進制數位用0，1 ；滿2進1。 0B101 二進制數
八進制：每一個八進制數位用0，1，2，3，4，5，6，7 ；滿8進1。用0開頭表示。 0123 八進制
十進制：每一個十進制數位用0，1，2，3，4，5，6，7 ，8，9 ；滿10進1。 滿10進1。 123
十六進制：每一個十六進制數位用0，1，2，3，4，5，6，7 ，8，9，A，B，C，D，E，F ；滿16進1。 滿16進1.。用0x開頭表示。 0xAF 十六進制
### 3.2.1進制轉換（了解）
既然知道計算機中存儲的都是二進制數據，那么如何將生活中的十進制數據轉換成計算機能夠識別的二進制數數據呢？
十進制轉二進制：十進制轉成二進制--->除以2倒取余數
圖例說明：把一個十進制數轉成二進制數，使用短除法，不停的除以2，直到商值為0，停止，然后倒著把余數寫出來，這個數就是十進制數轉后的二進制數。
二進制數轉十進制數：二進制轉成十進制--->按2的冪數展開并累加
圖例說明：將一個二進制數轉成十進制數，使用按權展開，并求累加和。具體說：對于一個二進制數，從最右側開始，使用當前二進制數位上的數據乘以2的n-1次冪(n為當前這個二進制數從右側開始的第幾位。)，并這將這些數據展開后加起來求和即可得到相應的十進制數。
### 3.2.1.進制規律
計算機中是以二進制數據的形式表示所有數據，并且在計算機中把8個二進制數位當做一組，并用“字節”來表示。即：8bit = 1Byte （八個二進制數位為一個字節）。那么一個字節能表示的數據是多大呢？也就是當八個二進制數位上全部是1時能表達多大一個數據呢？
即當1個字節上全部存放的是1時，這個數據即就是255，0-255之間的任何一個正數都可以在用一個字節表示。
小技巧：對于任意一個十進制數，當要轉成二進制時，也可以從上圖中的128、64、32、16、8、4、2、1這些數據加起來。當有某一個數時，就說明這個二進制數位上一定存放的是1，若沒有這個數，就說明這個二進制數位上一定存放的是0.
# 4.變量
## 4.1.變量的概念
在Java中，變量指的就是內存中的一塊可以重復使用的空間，可以用來存放同一類型的不同常量數據。
理解：變量就如同數學中的未知數，程序中凡是未知的數據，和可以變化的數據，都要使用變量來表示。
## 4.2.變量的數據類型（Java的數據類型）
在生活中，使用的數據有大有小，有整數，也有小數，同時也會使用字母，或者漢字表示特定含義。在Java中根據數據的不同特點，數據也分為不同的類型。
Java語言是強類型語言，對于每一種數據都定義了明確的具體數據類型，在內存中分配了不同大小的內存空間。
字符串不是基本類型，使用標識符String表示；
## 4.3.變量的聲明
### 4.3.1.變量的格式
標準形式：
數據類型 變量名；//聲明一個變量，沒有分配內存空間；
變量名 = 數據值；//分配內存空間，同時將數據值存放到變量空間中；
簡寫形式：
數據類型 變量名 = 數據值；//編譯后，字節碼里面還是和標準形式一樣，分為兩步；
注意：
Java語言的整型常量默認是int型，聲明long型變量后加上‘l’或‘L’
Java浮點型常量默認是double，則要聲明一個常量為float型，則需在常量后加上f 或 F,；
### 4.3.2.變量的起名
語法規則：
變量名是標識符，命名規則和標識符的語法規則相同：
1、只能是大小寫英文字母、數字、美元符號（$）和下劃線組成；
2、不能用數字開頭；
3、不能是關鍵字；
4、嚴格區分大小寫；
書寫規范：
在駝峰法的命名規范中，變量名和方法名一樣，應該遵守以下規范：
1、一個單詞，全部都是小寫；
2、多個單詞，從第二個單詞開始每個單詞的首字母大寫；
推薦原則：
見名知意。
例如：String name ；使用name表示這個空間名字，即說明這個空間存放的姓名
## 4.4.變量的特點
變量必須先聲明在使用：
都需要先賦值才能使用；
都有使用范圍；
都有數據類型，一般不能向不同類型的變量賦值；
## 4.5.Java的類型轉換
### 4.5.1.隱式類型轉換：
在Java中，向數值類型和字符類型的變量中保存數據的時候，如果要保存的數據的大小，沒有超過變量空間的存儲大小，JVM就會自動將要保存的數據的類型轉換為變量的類型，叫做隱式類型轉換。
### 4.5.2.強制類型轉換
在Java中，將占用空間大的數據向取值范圍小的變量中保存時，因為變量空間不足，所以不能直接存放，需要使用強制類型轉換。
注意：強制類型轉換有可能造成數據損失，使用時需要格外注意！
強制轉換格式：(數據類型)(被轉數據);
練習：
以下代碼編譯運行有沒有問題？為什么？
```
class Test
{
public static void main(String[] args)
{
byte a = 100;
byte b = a + 1;//這行編譯出問題，因為a是變量；使用強制類型轉換即可改正；
System.out.println(b);
}
}
```
# 5.運算符
## 5.1.算術運算
Java中的算術運算符和生活中的數學運算基本相似。
### 5.1.1.算術運算符符號
### 5.1.2.自加自減
自加（++）自減（--）運算
++：自增運算
如果運算符在運算的數據左邊，就叫做左自增運算；如果在運算的數據右邊，就叫做右自增運算；
例如：int a = 10;
++a 是左自增；a++ 是右自增；
左自增，直接對原有的數據進行+1；如果這一行代碼沒有結束，接下來參與其它運算的，是加一后的值；
右自增： 右自增運算，首先在內存中開辟一個臨時空間，將原來的數據保存在這個臨時空間中；然后對變量進行加一運算；
如果這一行代碼沒有結束，接下來參與其它運算的，是臨時空間中的值（還沒有加一的值）；
--：自減運算
也分為左自減和右自減，原理和自增運算一模一樣，只是進行的是減一運算；
練習：
下列程序運行輸出的結果是什么？為什么？
```
class Test
{
public static void main(String[] args)
{
int a = 10;
int b = 20;
int c = (a++) + 3*(--a) + 5*(b--) - 4*(--b);
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}
```
### 5.1.3.字符串連接符
如果“+”左右兩邊至少有一邊是一個字符串，他就是一個字符串連接符，可以將左右兩邊的結果拼接成一個大的字符串；
思考：
1、System.out.println("5+5="+5+5);//打印結果是？
2、若要打印出“5+5”=10 ，上述代碼怎么改？
3、下列程序運行輸出的結果是什么？為什么？
```
class Test
{
public static void main(String[] args)
{
System.out.println('A' + 'K' + "|" + 47);
System.out.println('A' + "K" + '|' + 47);
}
}
```
## 5.2.賦值運算符
可以將數據賦值給變量的運算符就是賦值運算符；= , +=, -=, *=, /=, %=
普通賦值運算符：=
作用：表示將符號右邊的數據，保存到符號左邊的變量中；
```
class Demo
{
public static void main(String[] args)
{
int a = 3 ; //將3存儲到左側a空間中
int b , c , d;
b = c = d = a; // 將a空間中的值分別存放到d，c，b 空間中
}
}
```
復合賦值運算符：
+=；-=；*=；/=；%=……
表示：
先將符號左右兩邊進行運算，然后將運算的結果賦值給左邊的變量；
注意：賦值號和算數運算符的混合運算屬于一個運算符，不能拆分。并且這個符號會完成自動強轉動作。
思考：以下代碼有什么區別？
```
class Demo
{
public static void main(String[] args)
{
short s = 3;
s=s+2;
s+=2;
}
}
```
說明：
s=s+2//編譯失敗，因為s會被提升為int類型，運算后的結果還是int類型。無法賦值給short類型。
s+=2//編譯通過，因為+=運算符在給s賦值時，自動完成了強轉操作。
## 5.3.比較運算符
### 5.3.1.運算符介紹
在生活中經常需要判斷數據大小，相等不相等各種操作，在Java中同樣也可以判斷數據的大小。
比較運算符符號：
```
>： 大于
>=： 大于或等于
<： 小于
<=： 小于或等于
==： 恒等于，表示比較左右兩邊是否相等；
!=： 不等于，表示比較左右兩邊不相等；
注1：比較運算符的結果都是boolean型，也就是要么是true，要么是false。
注2：比較運算符“==”不能誤寫成“=” 。
注3：比較運算符不能多個連續一起使用；如 1 < a < 5 非法；
```
### 5.3.2.運算符使用演示
## 5.4.邏輯運算符
當需要判斷某些數據符合某個區間，比如人的年齡符合某一范圍等。發現使用比較運算沒法完成。Java給我們提供另外一直機制，邏輯運算。邏輯運算符用于連接布爾型表達式，在Java中不可以寫成3<x<6，應該寫成x>3 & x<6 。
5.4.1.1.邏輯運算符號：
邏輯運算符：用可于進行邏輯運算（就是對布爾型數據進行運算）的符號就是邏輯運算符；
```
& : 與
| ：或
^ : 異或。
！：非。一元邏輯運算符；
&& 短路與 || 短路或
```
特點：
參與邏輯運算的數據都是布爾型數據；
邏輯運算的結果也都是布爾型數據；
#### 5.4.1.2.運算規律
邏輯運算表：!true = false; !false = true;
```
class Demo
{
public static void main(String[] args)
{
int x = 7;
x>2 & x<5
x<2 | x>5
}
}
```
& ：兩邊都為true，結果是true。否則為false。兩邊只要有一個false。結果必然是false。
```
true & true = true;
true & false = false;
false & true = false;
false & false = false;
```
| ：兩邊都為false，結果是false。否則為true。兩邊只要有一個true。結果必然是true。
```
true | true = true;
true | false = true;
false | true = true;
false | false = false;
```
^ : 異或。兩邊相同為false。兩邊不同為true。
```
true ^ true = false;
true ^ false = true;
false ^ true = true;
false ^ false = false;
```
！：非：非真為假，非假為真
```
!true = false;
```
&和&&的區別：
因為與運算，要求左右兩邊都是true，結果才是true，所以如果左邊已經是false，結果肯定是false；
所以：
```
使用&&計算時，如果左邊是false，就不計算右邊；如果左邊是true，才會計算右邊；
使用&計算時，不管左邊真假，兩邊都會計算；
```
|和||的區別：
```
使用||計算時，如果左邊是true，就不計算右邊；如果左邊是false，才會計算右邊；
使用|計算，不管左邊是什么，兩邊都會計算；
```
問題：什么時候使用 & 和 | ？
如果右邊一定要計算，就應該使用&和|；
## 5.5.三元運算符
三元運算符，也稱為三目運算符或問號冒號運算符。即有三個表達式參與的運算表達式。
### 5.5.1.1.三元運算符的格式：
接受運算結果的變量 = 布爾表達式 ? 表達式1 ：表達式2；
注意：在三元運算符的左邊，一定要有一個變量來接收運算的結果！
### 5.5.1.2.三元運算符舉例：
練習：根據給定的數字，在控制臺輸出奇數或者偶數？
練習二：使用三元運算符，求兩個整數的最大數；
作業：使用三元運算符，求三個整數中最大值、最小值；
## 5.6.位運算符（了解）
位運算：直接對二進制數位（0和1）進行操作的運算 符。
5.6.1.1.運算符符號：
雙元位運算符：
```
<<：左移運算符 將運算數的二進制碼整體左移指定位數，左移之后右邊的空位使用“0”來補充，左邊移出去的二進制數忽略不計。
```
```
>>：右移運算符 將運算數的二進制碼整體右移指定位數，右邊移出去的二進制數忽略不計。 左邊的空位使用“符號位”來補充：若是正數使用“0”補充；若是負數使用“1”補充；
```
```
>>>：無符號右移運算符 將運算數的二進制碼整體右移指定位數，右移之后的左邊的空位使用“0”來補充
```
```
&：按位與 相同二進制數位上數值為1，結果為1，否則結果為0；
```
```
|：按位或運算，運算原則：相同二進制數位上數值為0，結果為0，否則結果為1；
```
```
^：按位異或，運算原則：參與運算的兩個數相應位相同則結果為0，異號則為1；
```
使用按位異或運算，可以方便的實現兩個數字的交換；
```
int a = 5, b = 7;
int c = a ^ b ;
a = c ^ a ; a = 7
b = c ^ a ; b = 5;
```
作業：使用不同的方式實現兩個整數的交換；
一元位運算符：
~：按位取反 ：二進制數位上0變1，1變0；
# 6.流程控制語句
## 6.1.程序執行流程
流程：就指的是一個事情的先后順序；
程序流程： 就是程序中代碼的執行順序；
## 6.2.Java程序的流程
java 中代碼的執行順序，主要有三種基本執行順序：順序執行；選擇執行；重復執行；
其中，Java程序默認就是順序流程；
```
class Demo
{
public static void main(String[] args)
{
int a = 3 ;
int b = 5 ;
int sum ;
sum = a + b;
System.out.println("sum="+sum);
}
}
```
上述代碼當在dos命令行中寫入java Demo 回車之后，首先會啟動JVM，JVM就會去加載當前Demo這個class文件，并執行其中的main方法。當程序執行main方法的時候會從第一行開始往下執行，直到整個代碼全部執行完成。在此過程中程序按照書寫的順序，不會跳過任何一行代碼。像這樣的執行流程就是常見的順序執行結構。
選擇流程和重復流程，都需要特殊的流程控制語句來控制；
# 7.選擇流程控制語句
Java中控制選擇流程的語句，主要有判斷語句和選擇語句兩種；
## 7.1.判斷語句(if語句)
判斷語句就是根據判斷條件的真與假，來選擇執行某些代碼；根據可以選擇執行的代碼分支的數量，可將判斷語句分為單支判斷語句、雙支判斷語句和多支判斷語句；
### 7.1.1.單支判斷
語句格式：
```
if(布爾表達式)
{
選擇執行的代碼分支；
}
```
執行順序：
案例演示：
需求：模擬買票:如果乘客的身高超過1.2m（包含），就輸出“恭喜您的孩子又長高了！請買票！”。
### 7.1.2.雙支判斷：
語句格式：
```
if(布爾表達式)
{
選擇執行的代碼分支一；
}else{
選擇執行的代碼分支二；
}
```
執行順序：
案例演示：
需求：模擬成績顯示；如果考試成績超過60分（包含），就輸出“恭喜你及格了！”，否則就輸出“笨蛋你掛科了！”。
### 7.1.3.雙支判斷語句和三元運算符的異同：
相同點：
```
都有一個布爾表達式；
都要由兩個代碼分支；
都是根據布爾表達式的運算結果來選擇執行一個代碼分支；
```
不同點：
```
三元運算符，是一個運算符，一定有一個運算結果，而雙支判斷語句是一個流程控制語句，沒有返回結果；
三元運算符，必須有一個變量接收返回的結果，雙支判斷語句不需要；
```
案例演示：
分別使用三元運算符和if-else語句求兩個整數的最大值；
### 7.1.4.多支判斷：
語句格式：
```
if(布爾表達式一)
{
選擇執行的代碼分支一；
}else if(布爾表達式二){
選擇執行的代碼分支二；
}else if(布爾表達式三){
選擇執行的代碼分支三；
}
……
else{
選擇執行的代碼分支n；
}
```
執行順序：
案例演示：
需求：模擬一個游戲中的成就顯示系統，根據游戲積分顯示下面不同的稱號：
### 7.1.5.判斷語句的簡寫：省略大括號
if(布爾表達式)
代碼分支；
注意：如果if語句后面沒有大括號，則if語句只能到第一個分號結束；
所以開發中為了避免出現錯誤，最好大括號不要省略；
一般只有在分支代碼只有一行的時候才會省略；
### 7.1.6.嵌套判斷
如果再選擇的代碼分支中也存在判斷語句，就形成了一個嵌套判斷；
格式：
```
if(布爾表達式)｛
if（布爾表達式）｛
代碼分支
｝
｝
```
舉例：
模擬用戶登陸：
后臺判斷，就一般先判斷驗證碼，如果正確，再判斷用戶名是否存在；如果存在，再判斷密碼是否正確；只要有一個判斷錯誤，就登陸失敗；
## 7.2.選擇結構(switch )
### 7.2.1.switch語句格式：
switch(表達式)//注意：這個表達式不是布爾表達式！這個表達式返回的結果只能是：byte，short，int ， char。（java5之前）。還支持 enum(jdk5), String(jdk7)；
```
{
case 取值1:
執行語句；
break；//break可有可無；
case 取值2:
執行語句；
break；
……
default:
執行語句；
break；
}
```
程序執行時，遇到switch關鍵字，首先會計算表達式的值，然后根據計算的值和case后面的值做比較，當case后面的值和switch表達式的值相同時，就執行case身后的所有語句，若case身后沒有和switch表達式匹配的值，程序就會執行default后面的語句。
```
### 7.2.2.代碼演示
class SwitchDemo
{
public static void main(String[] args)
{
int x = 5;
switch(x){
case 5:
System.out.println("a");
break;
case 3:
System.out.println("b");
break;
default:
System.out.println("c");
break;
}
System.out.println("Hello World!");
}
}
```
### 7.2.3.switch語句特點：
switch語句選擇的類型只有四種：byte，short，int ， char。（java5之前）。還支持 enum(jdk5), String(jdk7)；
case之間與default沒有順序。先執行第一個case，沒有匹配的case執行default。
結束switch語句的兩種情況：遇到break，執行到switch語句結束。
如果匹配的case或者default沒有對應的break，那么程序會繼續向下執行，運行可以執行的語句，直到遇到break或者switch結尾結束。
### 7.2.4.switch練習：
根據用戶的給定的數值，顯示該數值對應的星期。如：2，星期二。
### 7.2.5.if和switch的區別：
if可以用于判斷數值，也可以判斷區間，只要運算結果是boolean類型，都可以進行判斷。
switch用于對固定的幾個值，進行判斷。判斷的值的類型有限。
### 7.3.循環結構(while&do-while)
## 7.3.1.循環結構：
根據程序的需求，可以將某些代碼重復執行的操作。Java中的循環結構有如下三種：
* while:事先不需要知道循環執行多少次；
* do-while:同上，只是至少要執行一次(先做，后判斷)；
* for:需要知道循環次數；
### 7.3.2.while循環
格式：
```
while(條件表達式)
{
執行語句；
}
```
while執行順序：當程序遇到while關鍵字時，JVM首先會運算while后面的條件表達式，當條件表達式為true時，就會執行while后面大括號中的語句，當把大括號中的所有語句執行完之后，會又回到while的條件表達式處再次判斷，若還為true，就繼續執行大括號中的語句，若為false就跳過大括號中的所有語句，繼續往下執行。
### 7.3.3.while代碼舉例：
```
class WhileDemo
{
public static void main(String[] args)
{
int i = 1;
while( i < 10 )//這個程序是個死循環
{
System.out.println("i"+i);
}
System.out.println("over");
}
}
```
上述循環是個無限循環（也稱為死循環），主要原因是i變量一直為1，每次判斷i<10都成立，導致選好條件結束不了。程序永遠卡在循環這個地方執行
```
class WhileDemo
{
public static void main(String[] args)
{
int i = 1;
while( i < 10 )
{
System.out.println("i"+i);
i++; // 讓i不斷的更新，最后使循環可以結束
}
System.out.println("over");
}
}
```
### 7.3.4.while練習
需求：運算1-10的和。
分析：
1+2+3+4+...+10
每次加的和是確定的嗎？不確定。需要變量記錄和值。
每次和值需要加的下一個數是確定的嗎？不確定，需要變量。
求和和+下一個數在重復，說明需要執行多次，用循環。
下一個數，是有規律的。自增。
### 7.3.5.while循環注意事項：
1）while循環的括號中的表達式計算結果必須為boolean類型的值。
2）while循環的括號中不能直接寫false常量。
3）while循環的括號后面不要寫分號，循環控制的語句的代碼用大括號擴起來。
4）while循環控制的條件變量一定要更新，保證循環能夠正常結束。
### 7.3.6.do-while循環
格式：
```
do
{
執行語句；
}while(條件表達式);
```
執行順序：先執行do后面的語句，當執行完之后再進入條件表達式進行判斷，若條件表達式結果為true繼續執行do后面的語句，若條件表達式結果為false，則結束循環。
do while特點是無論條件是否滿足，循環體至少被執行一次。
### 7.3.7.while和do-while對比
以下兩個程序的執行結果：
```
int x = 3;
while(x<3)
{
System.out.println("x="+x);
x++;
}
```
```
int y = 3;
do
{
System.out.println("y="+y);
y++;
}while (y<3);
```
### 7.4.循環結構(for)
#### 7.4.1.for循環格式
```
for(初始化表達式（1）；循環條件表達式（2）；循環后的操作表達式（3）)
{
執行語句；（4）
}
```
執行順序： for里面的3個表達式運行的順序，初始化表達式只讀一次，判斷循環條件，為真就執行循環體，然后再執行循環后的操作表達式，接著繼續判斷循環條件，重復找個過程，直到條件不滿足為止。
#### 7.4.2.for循環代碼舉例
```
class ForDemo
{
public static void main(String[] args)
{
for(int x = 1; x<3; x++)
{
System.out.println("x="+x);
}
}
}
```
#### 7.4.4.無限循環
最簡單無限循環格式：while(true){} , for(;;){},無限循環存在的原因是并不知道循環多少次，而是根據某些條件，來控制循環。
#### 7.4.5.for循環練習
需求：獲取1-100之間6的倍數的個數。
分析：
1、個數是未知的，所以定義變量。
2、6的倍數咋表示？只要是對6能整除，也就是沒有余數。
3、需要對1-100之間所以的數都要進行判斷是不是6的倍數。如果是，需要對個數變量進行自增。
4、怎么完成1-100之間呢？使用循環。
### 7.4.6.循環嵌套
循環嵌套：其實就是在循環中還有循環。
#### 7.4.6.1.循環嵌套代碼演示
#### 7.4.6.2.循環嵌套練習
需求：在屏幕上顯示以下圖形。
*
**
***
****
*****
思路：
1、看起圖形，發現是由5行的組成。
2、每一行都有多個星。
3、有點意思，多行，循環就可以搞定。每到一行，里面有多個星。循環內，還需要循環負責每一行的星的個數。
4、外循環控制行數，內循環控制每一個行的個數。
### 7.4.7.流程控制(continue,break)
#### 7.4.7.1.break語句、continue語句；
break：終止該層循環；
continue：跳過該層循環
注：
①：若這兩個語句離開應用范圍，存在是沒有意義的。
②：這個兩個語句單獨存在后面都不能有語句，因為執行不到。
③：continue語句是跳過本次循環，繼續下次循環。
④：標簽的出現，可以讓這兩個語句作用于指定的循環。
#### 7.4.7.2.break語句、 continue語句舉例：
break是終止循環，即在程序中遇到break，那么break所屬的循環將結束。
```
for (int x=0; x<3 ;x++ )
{
if(x==1)
break;
System.out.println("x="+x);
}
```
continue是結束本次循環，繼續下次循環。循環是不會結束的。
```
for (int x=0; x<10 ;x++ )
{
if(x%2==0)
continue;
System.out.println("x="+x);
}
```
#### 7.4.7.3.使用循環標簽；
在多層嵌套循環中，終止/跳過標簽標記的那層循環的執行；break <標簽> 或 continue <標簽>；
```
outer:for (int x=0; x<3 ;x++ )
{
inner:for (int y=0; y<4 ;y++ )
{
System.out.println("x="+x);
break outer;
}
}
```
```
outer:for (int x=0; x<3 ;x++ )
{
inner:for (int y=0; y<4 ;y++ )
{
System.out.println("x="+x);
continue outer;
}
}
```
