數據類型
標識符
【1】標識符：讀音 biao zhi fu
【2】什么是標識符？
包，類，變量，方法.....等等,只要是起名字的地方,那個名字就是標識符
【3】標識符定義規則：
1.四個可以（組成部分）：數字，字母，下划線_，美元符號$
注意：字母概念比較寬泛，指的是英文字母，漢字，日語，俄語......
但是我們一般起名字盡量使用英文字母
2.兩個不可以：不可以以數字開頭，不可以使用java中的關鍵字
3.見名知意：增加可讀性
4.大小寫敏感： int a ; int A;
5.遵照駝峰命名：
類名：首字母大寫，其余遵循駝峰命名
方法名，變量名：首字母小寫，其余遵循駝峰命名
包名：全部小寫，不遵循駝峰命名
6.長度無限制，但是不建議太長 asdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasfd
關鍵字
關鍵字：被JAVA語言賦予了特殊含義，用作專門用途的單詞
特點：JAVA中所有關鍵字都為小寫
官網：https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
變量和常量
常量：
常量分為兩種：
常量通常指的是一個固定的值，例如：1、2、3、’a’、’b’、true、false、”helloWorld”等。
在Java語言中，主要是利用關鍵字final來定義一個常量。 常量一旦被初始化后不能再更改其值。
為了更好的區分和表述，一般將1、2、3、’a’、’b’、true、false、”helloWorld”等稱為字面常量，而使用final修飾的PI等稱為符號常量（字符常量）。
字面常量的類型：
注意：邏輯常量就兩個值，一個是true，一個是false
變量：
變量本質上就是代表一個”可操作的存儲空間”，空間位置是確定的，但是里面放置什么值不確定。我們可通過變量名來訪問“對應的存儲空間”，從而操縱這個“存儲空間”存儲的值。Java是一種強類型語言，每個變量都必須聲明其數據類型。變量的數據類型決定了變量占據存儲空間的大小。 比如，int a=3; 表示a變量的空間大小為4個字節。變量作為程序中最基本的存儲單元，其要素包括變量名，變量類型和作用域。變量在使用前必須對其聲明, 只有在變量聲明以后，才能為其分配相應長度的存儲空間。
【1】變量聲明格式：
type varName [=value][,varName[=value]...]; //[ ]中的內容為可選項，即可有可無
數據類型 變量名 [=初始值] [,變量名 [=初始值]…];
案例：
int age = 19 , age2 = 90 ;
int age,age2;
【2】變量的聲明：
（1）如果你只定義一個變量，沒有給變量進行賦值的話，那么其實這個變量相當於沒有定義：
（2）變量如果沒有進行賦值的話，那么使用的時候會出錯，告訴你：尚未初始化變量：
【3】變量的賦值：
我們自己定義的時候直接就可以用一句話定義：
int age = 10;
public class TestVar01{
public static void main(String[] args){
//變量的聲明（定義變量）（以年齡為案例講解）
//java是一個強類型的語言，只要聲明變量就必須定義類型：定義整數類型
int age ; //定義一個整數類型的變量，變量名字為age
//對變量進行賦值操作：
age = 10; //變量名字為age，具體的值為10
age = 12;
age = 20;
age = age + 4;
age = 9;
age = 9;
System.out.println(age);
}
}
變量不可以重復定義
【4】變量的使用：
public class TestVar01{
public static void main(String[] args){
//變量的聲明（定義變量）（以年齡為案例講解）
//java是一個強類型的語言，只要聲明變量就必須定義類型：定義整數類型
int age ; //定義一個整數類型的變量，變量名字為age
//對變量進行賦值操作：
age = 10; //變量名字為age，具體的值為10
age = 12;
age = 20;
age = age + 4;
age = 9;
age = 9;
System.out.println(age);
System.out.println(age-2);
System.out.println(age+10);
int num = age + 66;
System.out.println(num);
}
}
擴展：
public class TestVar02{
public static void main(String[] args){
int a = 10;
int b = 20;
int c = a + b ;
}
}
現在對上述代碼進行“反編譯過程”“反匯編過程”
【5】變量的內存：
【6】習題：
public class TestVar03{
public static void main(String[] args){
int num1 = 10;
int num2 = 20;
num1 = num2;
num2 = num2 + 10;
num1 = num2 - 10;
num2 = num1;
System.out.println("num1="+num1);
System.out.println("num2="+num2);
}
}
內存分析：
結果：
【7】變量的作用域：
作用域指的就是作用范圍，變量在什么范圍中有效
作用范圍就是離它最近的{}
備注：一會我們寫的代碼，不要去運行，會出錯
/*
局部變量：定義在方法中
成員變量：定義在類中，方法外
*/
public class TestVar04{
int b = 20;
public static void main(String[] args){
System.out.println(a);//no
int a = 10;
System.out.println(a);//yes
System.out.println(b);//yes
{
int c = 40;
System.out.println(c);//yes
int a = 50;//屬於變量的重復定義
}
System.out.println(c);//no
}
public void eat(){
System.out.println(b);//yes
System.out.println(a);//no
int a = 30;//不是變量的重復定義
System.out.println(a);//yes
}
}
基本數據類型
Java是一種強類型語言，每個變量都必須聲明其數據類型。
Java的數據類型可分為兩大類：基本數據類型（primitive data type）和引用數據類型（reference data type）。
PS:巧妙記憶：除了基本數據類型以外的所有類型都屬於引用數據類型，本章重點：基本數據類型
1.整數類型
基本數據類型常量
十進制整數，如：99, -500, 0
八進制整數，要求以 0 開頭，如：015
十六進制數，要求 0x 或 0X 開頭，如：0x15
二進制：要求0b或者0B開頭，如：0b11
幾進制：就是逢幾進1的問題：
平時實際生活中用的最多的是：十進制
計算機用二進制最多
【1】二進制轉換為十進制：
二進制： 1101
12^3 + 12^2 + 02^1 + 12^0
= 8 + 4 + 0 + 1
= 13
【2】十進制轉換為二進制：
十進制 13
【3】八進制轉換十進制：
八進制： 16
18^1 + 68^0
= 8 + 6
=14
【4】十進制轉換為八進制：
十進制14：
【5】八進制轉換為十六進制：
把十進制當做一個中轉站：
八進制---》十進制---》十六進制
實際上根本不用自己轉換這么麻煩：我們可以直接用系統中提供給我們的計算器：
整型數據類型：
比如：byte的右側表數范圍127怎么算出來的？
byte: 1字節 = 8位
二進制：01111111
12^6 + 12^5 + 12^4 + 12^3 + 12^2 + 12^1 + 1*2^0
= 64 + 32 + 16 +8 +4 + 2 +1
= 127
public class TestVar05{
public static void main(String[] args){
//定義整數類型的變量：
//給變量賦值的時候，值可以為不同進制的：
int num1 = 12 ;//默認情況下賦值就是十進制的情況
System.out.println(num1);
int num2 = 012;//前面加上0，這個值就是八進制的
System.out.println(num2);
int num3 = 0x12;//前面加上0x或者0X，這個值就是十六進制的
System.out.println(num3);
int num4 = 0b10;//前面加上0b或者0B,這個值就是二進制的
System.out.println(num4);
//定義byte類型的變量：
byte b = 126;//定義了一個byte類型的變量，名字叫b，賦值為12
System.out.println(b);
//注意：超范圍的賦值會報錯。
short s = 30000;
System.out.println(s);
int i = 1234;
System.out.println(i);
//整數類型默認就是int類型的，所以12345678910是一個int類型的數，對於int類型來說，它超出范圍了
//要想把一個數給long類型變量，那么后面加上L(推薦)或者l就可以了
long num5 = 12345678910L;
System.out.println(num5);
//注意：只有這個數超出int類型的范圍了后面才需要加上L，否則無需加L也可以賦值給long類型：
long num6 = 12;
System.out.println(num6);
}
}
2.浮點類型
浮點類型常量
（1）十進制數形式，例如:
3.14 314.0 0.314
（2）科學記數法形式，如
314e2 314E2 (E的大小寫沒有區分) 314E-2
double f = 314e2; //31410^2-->31400.0
double f2 = 314e-2; //31410^(-2)-->3.14
浮點類型變量
float類型又被稱作單精度類型，尾數可以精確到7位有效數字，在很多情況下，float類型的精度很難滿足需求。
而double表示這種類型的數值精度約是float類型的兩倍，又被稱作雙精度類型，絕大部分應用程序都采用double類型。
float類型的數值有一個后綴F或者f ，沒有后綴F/f的浮點數值默認為double類型。
也可以在浮點數值后添加后綴D或者d， 以明確其為double類型。
PS：有效數字指的是從左開始第一個不為0的數到最后一個數
代碼：
public class TestVar06{
public static void main(String[] args){
//浮點類型的常量有兩種形式：
//十進制形式：
double num1 = 3.14;
System.out.println(num1);
//科學計數法形式：
double num2 = 314E-2;
System.out.println(num2);
//浮點類型的變量：
//注意：浮點型默認是double類型的，要想將一個double類型的數賦給float類型，必須后面加上F或者f
float f1 = 3.14234567898623F;
System.out.println(f1);
//注意：double類型后面可以加D或者d，但是一般我們都省略不寫
double d1 = 3.14234567898623D;
System.out.println(d1);
//注意：我們最好不要進行浮點類型的比較：
float f2 = 0.3F;
double d2 = 0.3;
System.out.println(f2==d2);
/*
區別：
= 賦值運算： 將等號右側的值賦給等號左側
== 判斷==左右兩側的值是否相等 ：結果要么相等 要么不相等
==運算符的結果就是要么是true，要么是false
*/
}
}
3.字符類型
（1）編碼和字符集
【1】什么是編碼？
【2】通過生活案例：
【3】由權威機構形成的編碼表才可以稱之為：字符集
ASCII
英文字符集
用一個字節的7位表示
IOS8859-1
西歐字符集
用一個字節的8位表示
GB2312
簡體中文字符集
最多使用兩個字節編碼
PS：中文：2個字節
GB2312兼容了ASCII中的字符：
GBK
GB2312的升級，加入了繁體字
最多使用兩個字節編碼
疑問：
首位如果是0：一個字節代碼代表一個字符
首位如果是1：那么一個字節不夠，要加上后面的字節才能完整的表示一個字符。
Unicode
國際通用字符集，融合了目前人類使用的所有字符。為每個字符分配唯一的字符碼。
退出了UTF標准：
三種編碼方案： UTF-8，UTF-16,UTF-32
以UTF-8為案例講解：
中文： 珊 ---》Unicode ： 29642
以后我們用的最多的就是UTF-8.
（2）布爾類型：
boolean類型有兩個常量值，true和false，在內存中占一位（不是一個字節），不可以使用 0 或非 0 的整數替代 true 和 false ，這點和C語言不同。 boolean 類型用來判斷邏輯條件，一般用於程序流程控制 。
public class TestVar09{
public static void main(String[] args){
//創建一個布爾類型的變量：
boolean flag1 = true;
System.out.println(flag1);
boolean flag2 = false;
System.out.println(flag2);
boolean flag3 = 5==9;
System.out.println(flag3);
boolean flag4 = 5<9;
System.out.println(flag4);
}
}
（3）基本數據類型的轉換：
【1】什么是類型轉換：
在賦值運算或者算數運算的時候，要求數據類型一致，就要進行類型的轉換。
【2】類型轉換的種類：
自動轉換，強制轉換
public class TestVar10{ public static void main(String[] args){ //類型轉換的兩種形式： double d = 6;//int-->double 自動類型轉換 System.out.println(d); int i = (int)6.5;//double--->int 強制類型轉換 （強轉） System.out.println(i); //在同一個表達式中，有多個數據類型的時候，應該如何處理： //多種數據類型參與運算的時候，整數類型，浮點類型，字符類型都可以參與運算，唯獨布爾類型不可以參與運算。 //double d2 = 12+1294L+8.5F+3.81+'a'+true; double d2 = 12+1294L+8.5F+3.81+'a'; System.out.println(d2); /* 類型級別：(從低到高的) byte,short,char-->int--->long--->float--->double 級別用來做什么？當一個表達式中有多種數據類型的時候，要找出當前表達式中級別最高的那個類型，然后 其余的類型都轉換為當前表達式中級別最高的類型進行計算。 double d2 = 12+1294L+8.5F+3.81+'a'; = 12.0+1294.0+8.5+3.81+97.0 */ int i2 = (int)(12+1294L+8.5F+3.81+'a'); System.out.println(i2); /* 在進行運算的時候： 左=右 : 直接賦值 左<右 ：強轉 左>右 ：直接自動轉換 */ //以下情況屬於特殊情形：對於byte，short，char類型來說，只要在他們的表數范圍中，賦值的時候就不需要進行 //強轉了直接賦值即可。 byte b = 12; System.out.println(b); byte b2 = (byte)270; System.out.println(b2); }}
（4）練習：final，字符常量，Scanner的使用：
import java.util.Scanner;//形象理解：在java.util下將Scanner拿過來用public class TestVar11{ public static void main(String[] args){ //實現功能：求圓的周長和面積 //【1】提取變量：提取變量，就是為了一勞永逸，以后只要改變變量的值，下面只要用到這個變量的地方，取值也都發生變化了 //【2】一個變量被final修飾，這個變量就變成了一個常量，這個常量的值就不可變了 // 這個常量就是我們所說的 字符常量 ---》pi // 約定俗成的規定：字符常量的名字全部大寫 //【3】使用掃描器：Scanner的使用--》注意通過形象的理解去使用 final double PI = 3.14; //拿來一個掃描器： Scanner sc = new Scanner(System.in); //給一個友好性的提示： System.out.print("請錄入一個半徑："); //讓掃描器掃描鍵盤錄入的int類型的數據： int r = sc.nextInt(); //求周長： double c = 2*PI*r; System.out.println("周長為："+c); //求面積： //PI = 9.29;報錯：TestVar11.java:12: 錯誤: 無法為最終變量pi分配值 double s = PI*r*r; System.out.println("面積為："+s); }}
（5）練習：加深對Scanner的使用：
import java.util.Scanner;public class TestVar12{ public static void main(String[] args){ //鍵盤錄入學生的信息：年齡，身高，姓名，性別： //鍵盤錄入年齡：(接收int類型數據) Scanner sc = new Scanner(System.in); System.out.print("請錄入年齡："); int age = sc.nextInt(); //鍵盤錄入身高：（接收double類型數據） System.out.print("請錄入身高："); double height = sc.nextDouble(); //鍵盤錄入姓名：(接收String類型數據--》字符串) System.out.print("請錄入姓名："); String name = sc.next(); //鍵盤錄入性別：(接受char類型) System.out.print("請錄入性別："); String sexStr = sc.next(); char sex = sexStr.charAt(0); //上面兩句可以合為一句表示：char sex = sc.next().charAt(0); System.out.println("該學生的信息為:姓名是："+name+",年齡是："+age+",身高為："+height+",性別是："+sex); }}
運算符
【1】Java 語言支持如下運算符：
算術運算符
+，-，*，/，%，++（自增），--（自減）
賦值運算符
擴展賦值運算符
+=，-=，*=，/=
關系運算符
>，<，>=，<=，==，!=
邏輯運算符
&，|， &&，||，!，^
位運算符
&，|，^，~ ， >>，<<，>>> (了解！！！)
條件運算符
？：
1 算術運算符
1.1 運算符和表達式（了解）
運算符：對常量或者變量進行操作的符號
表達式：用運算符把常量或者變量連接起來符合java語法的式子就可以稱為表達式。
不同運算符連接的表達式體現的是不同類型的表達式。
舉例說明：
int a = 10;int b = 20;int c = a + b;
+：是運算符，並且是算術運算符。
a + b：是表達式，由於+是算術運算符，所以這個表達式叫算術表達式。
1.2 算術運算符(應用)
符號 作用 說明+ 加 參看小學一年級- 減 參看小學一年級* 乘 參看小學二年級，與“×”相同/ 除 參看小學二年級，與“÷”相同% 取余 獲取的是兩個數據做除法的余數
注意：
\1. /和%的區別：兩個數據做除法，/取結果的商，%取結果的余數。
\2. 整數操作只能得到整數，要想得到小數，必須有浮點數參與運算。
int a = 10;int b = 3;System.out.println(a / b); // 輸出結果3System.out.println(a % b); // 輸出結果1
1.3 字符的“+”操作（理解）
char類型參與算術運算，使用的是計算機底層對應的十進制數值。需要我們記住三個字符對應的數值：
'a' -- 97 a-z是連續的，所以'b'對應的數值是98，'c'是99，依次遞加'A' -- 65 A-Z是連續的，所以'B'對應的數值是66，'C'是67，依次遞加'0' -- 48 0-9是連續的，所以'1'對應的數值是49，'2'是50，依次遞加
// 可以通過使用字符與整數做算術運算，得出字符對應的數值是多少char ch1 = 'a';System.out.println(ch1 + 1); // 輸出98，97 + 1 = 98char ch2 = 'A';System.out.println(ch2 + 1); // 輸出66，65 + 1 = 66char ch3 = '0';System.out.println(ch3 + 1); // 輸出49，48 + 1 = 49
算術表達式中包含不同的基本數據類型的值的時候，整個算術表達式的類型會自動進行提升。
提升規則：
byte類型，short類型和char類型將被提升到int類型，不管是否有其他類型參與運算。
整個表達式的類型自動提升到與表達式中最高等級的操作數相同的類型
等級順序：byte,short,char --> int --> long --> float --> double
例如：
byte b1 = 10;byte b2 = 20;// byte b3 = b1 + b2; // 該行報錯，因為byte類型參與算術運算會自動提示為int，int賦值給byte可能損失精度int i3 = b1 + b2; // 應該使用int接收byte b3 = (byte) (b1 + b2); // 或者將結果強制轉換為byte類型-------------------------------int num1 = 10;double num2 = 20.0;double num3 = num1 + num2; // 使用double接收，因為num1會自動提升為double類型
1.4 字符串的“+”操作（理解）
當“+”操作中出現字符串時，這個”+”是字符串連接符，而不是算術運算。
System.out.println("itheima"+ 666); // 輸出：itheima666
在”+”操作中，如果出現了字符串，就是連接運算符，否則就是算術運算。當連續進行“+”操作時，從左到右逐個執
行。
System.out.println(1 + 99 + "年黑馬"); // 輸出：100年黑馬System.out.println(1 + 2 + "itheima" + 3 + 4); // 輸出：3itheima34// 可以使用小括號改變運算的優先級System.out.println(1 + 2 + "itheima" + (3 + 4)); // 輸出：3itheima7
1.5 數值拆分（應用）
需求：
鍵盤錄入一個三位數，將其拆分為個位，十位，百位，打印在控制台
示例代碼：
import java.util.Scanner;public class Test {public static void main(String[] args) {// 1：使用Scanner鍵盤錄入一個三位數Scanner sc = new Scanner(System.in);System.out.println("請輸入一個三位數");int num = sc.nextInt();// 2：個位的計算：數值 % 10int ge = num % 10;// 3：十位的計算：數值 / 10 % 10int shi = num / 10 % 10;// 4：百位的計算：數值 / 100int bai = num / 100;// 5：將個位, 十位, 百位拼接上正確的字符串, 打印即可System.out.println("整數"+num+"個位為:" + ge);System.out.println("整數"+num+"十位為:" + shi);System.out.println("整數"+num+"百位為:" + bai);}
2 自增自減運算符（理解）
符號 作用 說明++ 自增 變量的值加1-- 自減 變量的值減1
注意事項：
++和-- 既可以放在變量的后邊，也可以放在變量的前邊。
單獨使用的時候， ++和-- 無論是放在變量的前邊還是后邊，結果是一樣的。
參與操作的時候，如果放在變量的后邊，先拿變量參與操作，后拿變量做++或者--。
參與操作的時候，如果放在變量的前邊，先拿變量做++或者--，后拿變量參與操作。
最常見的用法：單獨使用。
int i = 10;i++; // 單獨使用System.out.println("i:" + i); // i:11int j = 10;++j; // 單獨使用System.out.println("j:" + j); // j:11int x = 10;int y = x++; // 賦值運算，++在后邊，所以是使用x原來的值賦值給y，x本身自增1System.out.println("x:" + x + ", y:" + y); // x:11，y:10int m = 10;int n = ++m; // 賦值運算，++在前邊，所以是使用m自增后的值賦值給n，m本身自增1System.out.println("m:" + m + ", m:" + m); // m:11，m:11
練習：
int x = 10;int y = x++ + x++ + x++;System.out.println(y); // y的值是多少？/*解析，三個表達式都是++在后，所以每次使用的都是自增前的值，但程序自左至右執行，所以第一次自增時，使用的是10進行計算，但第二次自增時，x的值已經自增到11了，所以第二次使用的是11，然后再次自增。。。所以整個式子應該是：int y = 10 + 11 + 12;輸出結果為33。*/注意：通過此練習深刻理解自增和自減的規律，但實際開發中強烈建議不要寫這樣的代碼！小心挨打！
3 賦值運算符（應用）
符號 作用 說明= 賦值 a=10，將10賦值給變量a+= 加后賦值 a+=b，將a+b的值給a-= 減后賦值 a-=b，將a-b的值給a*= 乘后賦值 a*=b，將a×b的值給a/= 除后賦值 a/=b，將a÷b的商給a%= 取余后賦值 a%=b，將a÷b的余數給a.
注意：
擴展的賦值運算符隱含了強制類型轉換。
short s = 10;s = s + 10; // 此行代碼報出，因為運算中s提升為int類型，運算結果int賦值給short可能損失精度s += 10; // 此行代碼沒有問題，隱含了強制類型轉換，相當於 s = (short) (s + 10);
4 關系運算符（應用）
關系運算符有6種關系，分別為小於、小於等於、大於、等於、大於等於、不等於。
注意事項：
關系運算符的結果都是boolean類型，要么是true，要么是false。
千萬不要把“”誤寫成“=”，""是判斷是否相等的關系，"="是賦值。
int a = 10;int b = 20;System.out.println(a == b); // falseSystem.out.println(a != b); // trueSystem.out.println(a > b); // falseSystem.out.println(a >= b); // falseSystem.out.println(a < b); // trueSystem.out.println(a <= b); // true// 關系運算的結果肯定是boolean類型，所以也可以將運算結果賦值給boolean類型的變量boolean flag = a > b;System.out.println(flag); // 輸出false
5 邏輯運算符（應用）
邏輯運算符把各個運算的關系表達式連接起來組成一個復雜的邏輯表達式，以判斷程序中的表達式是否成立，判斷
的結果是 true 或 false。
//定義變量int i = 10;int j = 20;int k = 30;//& “與”，並且的關系，只要表達式中有一個值為false，結果即為falseSystem.out.println((i > j) & (i > k)); //false & false,輸出falseSystem.out.println((i < j) & (i > k)); //true & false,輸出falseSystem.out.println((i > j) & (i < k)); //false & true,輸出falseSystem.out.println((i < j) & (i < k)); //true & true,輸出trueSystem.out.println("--------");//| “或”，或者的關系，只要表達式中有一個值為true，結果即為trueSystem.out.println((i > j) | (i > k)); //false | false,輸出falseSystem.out.println((i < j) | (i > k)); //true | false,輸出trueSystem.out.println((i > j) | (i < k)); //false | true,輸出trueSystem.out.println((i < j) | (i < k)); //true | true,輸出trueSystem.out.println("--------");//^ “異或”，相同為false，不同為trueSystem.out.println((i > j) ^ (i > k)); //false ^ false,輸出falseSystem.out.println((i < j) ^ (i > k)); //true ^ false,輸出trueSystem.out.println((i > j) ^ (i < k)); //false ^ true,輸出trueSystem.out.println((i < j) ^ (i < k)); //true ^ true,輸出false
6 短路邏輯運算符（理解）
在邏輯與運算中，只要有一個表達式的值為false，那么結果就可以判定為false了，沒有必要將所有表達式的值都
計算出來，短路與操作就有這樣的效果，可以提高效率。同理在邏輯或運算中，一旦發現值為true，右邊的表達式
將不再參與運算。
邏輯與&，無論左邊真假，右邊都要執行。
短路與&&，如果左邊為真，右邊執行；如果左邊為假，右邊不執行。邏輯或|，無論左邊真假，右邊都要執行。短路或||，如果左邊為假，右邊執行；如果左邊為真，右邊不執行。
int x = 3;int y = 4;System.out.println((x++ > 4) & (y++ > 5)); // 兩個表達都會運算System.out.println(x); // 4System.out.println(y); // 5System.out.println((x++ > 4) && (y++ > 5)); // 左邊已經可以確定結果為false，右邊不參與運算System.out.println(x); // 4System.out.println(y); // 4
7 三元運算符（理解）
三元運算符語法格式：
關系表達式 ? 表達式1 : 表達式2;
解釋：問號前面的位置是判斷的條件，判斷結果為boolean型，為true時調用表達式1，為false時調用表達式2。其
邏輯為：如果條件表達式成立或者滿足則執行表達式1，否則執行第二個。
舉例：
int a = 10;int b = 20;int c = a > b ? a : b; // 判斷 a>b 是否為真，如果為真取a的值，如果為假，取b的值
8 三元運算符案例(應用)
需求：
一座寺廟里住着三個和尚，已知他們的身高分別為150cm、210cm、165cm，請用程序實現獲取這三個和尚的最
高身高。
public class OperatorTest02 {public static void main(String[] args) {//1：定義三個變量用於保存和尚的身高，單位為cm，這里僅僅體現數值即可。int height1 = 150;int height2 = 210;int height3 = 165;//2：用三元運算符獲取前兩個和尚的較高身高值，並用臨時身高變量保存起來。int tempHeight = height1 > height2 ? height1 : height2;//3：用三元運算符獲取臨時身高值和第三個和尚身高較高值，並用最大身高變量保存。int maxHeight = tempHeight > height3 ? tempHeight : height3;//4：輸出結果System.out.println("maxHeight:" + maxHeight);}}
流程控制
【1】流程控制的作用：
流程控制語句是用來控制程序中各語句執行順序的語句，可以把語句組合成能完成一定功能的小邏輯模塊。
【2】控制語句的分類：
控制語句分為三類：順序、選擇和循環。
“順序結構”代表“先執行a，再執行b”的邏輯。
“條件判斷結構”代表“如果…，則…”的邏輯。
“循環結構”代表“如果…，則再繼續…”的邏輯。
三種流程控制語句就能表示所有的事情！不信，你可以試試拆分你遇到的各種事情。這三種基本邏輯結構是相互支撐的，它們共同構成了算法的基本結構，無論怎樣復雜的邏輯結構，都可以通過它們來表達。所以任何一種高級語言都具備上述兩種結構。
本章是大家真正進入編程界的“門票”。
【3】流程控制的流程：
分支結構(選擇結構)
if：
（1）單分支
【1】語法結構:
if(布爾表達式){語句塊}
if語句對布爾表達式進行一次判定，若判定為真，則執行{}中的語句塊，否則跳過該語句塊。流程圖如圖所示：
public class TestIf01{ public static void main(String[] args){ //實現一個功能：給出三個數（1-6），對三個數求和計算，根據和的大小來分配不同的獎品 //1.給出三個數： int num1 = 6; int num2 = 2; int num3 = 3; //2.求和 int sum = 0; sum += num1; sum += num2; sum += num3; System.out.println("和為："+sum); //3.根據和判斷獎品： //如果和大於等於14，那么就是一等獎 if(sum>=14){ System.out.println("一等獎"); System.out.println("恭喜你很幸運，中了一等獎"); } if(sum>=10&&sum<14){ System.out.println("二等獎"); } if(sum>=6&&sum<10){ System.out.println("三等獎"); } if(sum<6){ System.out.println("四等獎"); } /* if-單分支： （1）結構： if(條件表達式，這個表達式的結果是布爾值：要么是false，要么是true){ //如果上面()中的表達式返回結果是true，那么執行{}中代碼 //如果上面()中的表達式返回結果是false ，那么不執行{}中代碼 //PS:{}中的代碼是否執行，取決於()中表達式的返回結果 } （2）上面的代碼中，我用四個單分支拼湊出四個選擇，每個選擇是獨立的，依次判斷執行的 （3）if后面的()中的條件，要按照自己需求盡量完善 （4）{}可以省略不寫,但是一旦省略，這個if就只負責后面的一句話，所以我們不建議初學者省略 */ }}
（2）多分支
【1】語法結構：
if(布爾表達式1) {語句塊1;} else if(布爾表達式2) {語句塊2;}……else if(布爾表達式n){語句塊n;} else {語句塊n+1;}
當布爾表達式1為真時，執行語句塊1；否則，判斷布爾表達式2，當布爾表達式2為真時，執行語句塊2；否則，繼續判斷布爾表達式3······；如果1~n個布爾表達式均判定為假時，則執行語句塊n+1，也就是else部分。
public class TestIf02{ public static void main(String[] args){ //實現一個功能：給出三個數（1-6），對三個數求和計算，根據和的大小來分配不同的獎品 //1.給出三個數： int num1 = 6; int num2 = 4; int num3 = 2; //2.求和 int sum = 0; sum += num1; sum += num2; sum += num3; System.out.println("和為："+sum); //3.根據和判斷獎品： /* 利用一個多分支 【1】結構： if(){ }else if(){ }else if(){ }... else{ } 【2】else:隱藏了一個條件，跟上面分支條件表達式相反的功能 (詳見數軸分析) 【3】多分支：好處：只要滿足一個 分支以后，后面的分支就不需要判斷了 --》效率高 【4】我們寫代碼的時候，盡量保證else的存在--》else分支相當於“兜底”“備胎”的作用，別的分支都不走，就會走這個分支了 */ if(sum>=14){ System.out.println("一等獎"); }else if(sum>=10){//隱藏了sum<14 System.out.println("二等獎"); }else if(sum>=6){//隱藏了sum<10 System.out.println("三等獎"); }else{//隱藏了sum<6 System.out.println("四等獎"); } }}
（3）雙分支
【1】語法結構:
if(布爾表達式){語句塊1}else{語句塊2}
當布爾表達式為真時，執行語句塊1，否則，執行語句塊2。也就是else部分。流程圖如圖所示：
Switch：
【1】switch多分支結構(多值情況)
語法結構：
switch (表達式) {case 值1:語句序列1;[break];case 值2:語句序列2;[break];… … … … …[default:默認語句;]}
switch語句會根據表達式的值從相匹配的case標簽處開始執行，一直執行到break語句處或者是switch語句的末尾。如果表達式的值與任一case值不匹配，則進入default語句（如果存在default語句的情況）。根據表達式值的不同可以執行許多不同的操作。switch語句中case標簽在JDK1.5之前必須是整數（long類型除外）或者枚舉，不能是字符串，在JDK1.7之后允許使用字符串(String)。大家要注意，當布爾表達式是等值判斷的情況，可以使用if-else if-else多分支結構或者switch結構，如果布爾表達式區間判斷的情況，則只能使用if-else if-else多分支結構。
public class TestSwitch{ public static void main(String[] args){ /* 實現一個功能： 根據給出的學生分數，判斷學生的等級： >=90 -----A >=80 -----B >=70 -----C >=60 -----D <60 -----E 用if分支： if(score>=90){ }else if(score>=80){ } */ //1.給出學生的成績： int score = 167; //2.根據成績判斷學生的等級： switch(score/10){ case 10 : case 9 : System.out.println("A級");break; case 8 : System.out.println("B級");break; case 7 : System.out.println("C級");break; case 6 : System.out.println("D級");break; default:System.out.println("成績錯誤");break; case 5 : case 4 : case 3 : case 2 : case 1 : case 0 : System.out.println("E級");break; } /* 【1】語法結構： switch(){ case * : case * : ....... } 【2】switch后面是一個()，()中表達式返回的結果是一個等值，這個等值的類型可以為： int,byte,short,char,String,枚舉類型 【3】這個()中的等值會依次跟case后面的值進行比較，如果匹配成功，就執行:后面的代碼 【4】為了防止代碼的“穿透”效果：在每個分支后面加上一個關鍵詞break，遇到break這個分支就結束了 【5】類似else的“兜底”“備胎”的分支：default分支 【6】default分支可以寫在任意的位置上，但是如果沒有在最后一行，后面必須加上break關鍵字， 如果在最后一行的話，break可以省略 【7】相鄰分支邏輯是一樣的，那么就可以只保留最后一個分支，上面的都可以省去不寫了 【8】switch分支和if分支區別： 表達式是等值判斷的話--》if ，switch都可以 如果表達式是區間判斷的情況---》if最好 【9】switch應用場合：就是等值判斷，等值的情況比較少的情況下 */ }}
循環結構
（1）while
【1】語法結構：
while (布爾表達式) {循環體;}
在循環剛開始時，會計算一次“布爾表達式”的值，若條件為真，執行循環體。而對於后來每一次額外的循環，都會在開始前重新計算一次。
語句中應有使循環趨向於結束的語句，否則會出現無限循環–––"死"循環。
public class TestWhile{ public static void main(String[] args){ //功能：1+2+3+4+5 //1.定義變量： int num = 1;[1]條件初始化 //2.定義一個求和變量，用來接收和： int sum = 0; while(num<=5){[2]條件判斷 sum += num;[3]循環體 num++;[4]迭代 } //3.輸出和 System.out.println(sum); }}
（2）do-while
【1】語法結構：
do {循環體;} while(布爾表達式) ;
do-while循環結構會先執行循環體，然后再判斷布爾表達式的值，若條件為真，執行循環體，當條件為假時結束循環。do-while循環的循環體至少執行一次。
public class TestDoWhile{ public static void main(String[] args){ //1+2+3+4+...100 //while方式: /* int i = 101; int sum = 0; while(i<=100){ sum += i; i++; } System.out.println(i);//101 System.out.println(sum);//0 */ //do-while方式： int i = 101; int sum = 0; do{ sum += i; i++; }while(i<=100);//一定要注意寫這個分號，否則編譯出錯 System.out.println(i);//102 System.out.println(sum);//101 /* 【1】while和do-while的區別: while:先判斷，再執行 do-while:先執行，再判斷---》至少被執行一次，從第二次開始才進行判斷 【2】什么場合使用do-while: while(考試是否通過){ 考試； } ---》不合適 do{ 考試； }while(考試是否通過); ---》合適 */ }}
（3）for
【1】語法結構：
for (初始表達式; 布爾表達式; 迭代因子) {循環體;}
for循環語句是支持迭代的一種通用結構，是最有效、最靈活的循環結構。for循環在第一次反復之前要進行初始化，即執行初始表達式；隨后，對布爾表達式進行判定，若判定結果為true，則執行循環體，否則，終止循環；最后在每一次反復的時候，進行某種形式的“步進”，即執行迭代因子。
初始化部分設置循環變量的初值
條件判斷部分為任意布爾表達式
迭代因子控制循環變量的增減
for循環在執行條件判定后，先執行的循環體部分，再執行步進。
public class TestFor01{ public static void main(String[] args){ //1+2+3+..+100 //while: /*int i = 1; int sum = 0; while(i<=100){ sum += i; i++; } System.out.println(sum); */ //for: int sum = 0; int i; for(i = 1;i<=100;i++){ sum += i; } System.out.println(sum); System.out.println(i); /* 【1】for的結構： for(條件初始化;條件判斷;迭代){ 循環體； } 【2】i的作用域：作用范圍：離變量最近{} --->可以自己去控制 【3】for循環格式特別靈活：格式雖然很靈活，但是我們自己寫代碼的時候不建議靈活着寫。 for(;;){} -->死循環 int i = 1; for(;i<=100;){ sum += i; i++; } 【4】死循環： for(;;){} while(true){} do{ }while(true); 【5】循環分為兩大類： 第一類：當型 while(){} for(;;){} 第二類：直到型 do{}while(); 【6】以后常用：for循環 【7】do-while,while,for循環誰的效率高？ 一樣高 */ }}
關鍵字
（1）break
【1】通過練習感受break的作用：作用：停止循環：
public class TestFor02{ public static void main(String[] args){ //功能：求1-100的和，當和第一次超過300的時候，停止程序 int sum = 0; for(int i=1;i<=100;i++){ sum += i; if(sum>300){//當和第一次超過300的時候 //停止循環 break;//停止循環 } System.out.println(sum); } }}
【2】加深理解：
public class TestFor03{ public static void main(String[] args){ //break的作用：停止最近的循環 /* for(int i=1;i<=100;i++){ System.out.println(i); if(i==36){ break;//1-36 } } */ for(int i=1;i<=100;i++){ System.out.println(i); while(i==36){ break; //1-100 ---》break停止的是while循環，而不是外面的for循環 } } }}
【3】break帶標簽的使用：
public class TestFor04{ public static void main(String[] args){ outer: ----》定義標簽結束的位置 for(int i=1;i<=100;i++){ System.out.println(i); while(i==36){ break outer; ----》根據標簽來結束循環 } } }}
多層循環也可以使用標簽，按照自己的需求去設定即可：
（2）continue
【1】通過案例感受continue的作用：結束本次循環，繼續下一次循環
public class TestFor05{ public static void main(String[] args){ //功能：輸出1-100中被6整除的數： //方式1： /* for(int i=1;i<=100;i++){ if(i%6==0){//被6整除 System.out.println(i); } } */ //方式2： for(int i=1;i<=100;i++){ if(i%6!=0){//不被6整除 continue;//停止本次循環，繼續下一次循環 } System.out.println(i); } }}
【2】加深理解：
public class TestFor06{ public static void main(String[] args){ //continue:結束本次離它近的循環，繼續下一次循環 /* for(int i=1;i<=100;i++){ if(i==36){ continue;//1-100中間沒有36 } System.out.println(i); } */ for(int i=1;i<=100;i++){ while(i==36){ System.out.println("------"); continue; //1-35+死循環 } System.out.println(i); } }}
【3】continue帶標簽的使用：
public class TestFor07{ public static void main(String[] args){ outer: for(int i=1;i<=100;i++){ while(i==36){ continue outer; //1-100沒有36 } System.out.println(i); } }}
（3）return
return的作用：跟循環無關，就是程序中遇到return那么return所在的那個方法就停止執行了：
public class TestFor08{ public static void main(String[] args){ //return:遇到return結束當前正在執行的方法 for(int i=1;i<=100;i++){ while(i==36){ return; } System.out.println(i); } System.out.println("-----"); }}
練習：
public class TestFor09{ public static void main(String[] args){ /* 輸出1-100中被5整除的數,每行輸出6個*/ //引入一個計數器： int count = 0;//初始值為0 for(int i=1;i<=100;i++){ if(i%5==0){//被5整除的數 System.out.print(i+"\t"); count++;//每在控制台輸出一個數，count就加1操作 if(count%6==0){ System.out.println();//換行 } } } }}import java.util.Scanner;public class TestFor10{ public static void main(String[] args){ /* 實現一個功能： 【1】請錄入10個整數，當輸入的數是666的時候，退出程序。 【2】判斷其中錄入正數的個數並輸出。 【3】判斷系統的退出狀態：是正常退出還是被迫退出。 */ //引入一個計數器： int count = 0; //引入一個布爾類型的變量： boolean flag = true; //---》理解為一個“開關”，默認情況下開關是開着的 Scanner sc = new Scanner(System.in); for(int i=1;i<=10;i++){//i:循環次數 System.out.println("請錄入第"+i+"個數："); int num = sc.nextInt(); if(num>0){//錄入的正數 count++; } if(num==666){ flag = false;//當遇到666的時候，“開關”被關上了 //退出循環： break; } } System.out.println("你錄入的正數的個數為："+count); if(flag){//flag==true System.out.println("正常退出！"); }else{//flag==false System.out.println("被迫退出！"); } }}
多重循環
乘法口訣：
public class TestFor11{ public static void main(String[] args){ //1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 /* System.out.print("1*6=6"+"\t"); System.out.print("2*6=12"+"\t"); System.out.print("3*6=18"+"\t"); System.out.print("4*6=24"+"\t"); System.out.print("5*6=30"+"\t"); System.out.print("6*6=36"+"\t"); for(int i=1;i<=6;i++){ System.out.print(i+"*6="+i*6+"\t"); } //換行 System.out.println(); //1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 for(int i=1;i<=7;i++){ System.out.print(i+"*7="+i*7+"\t"); } //換行 System.out.println(); //1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 for(int i=1;i<=8;i++){ System.out.print(i+"*8="+i*8+"\t"); } //換行 System.out.println(); */ for(int j=1;j<=9;j++){ for(int i=1;i<=j;i++){ System.out.print(i+"*"+j+"="+i*j+"\t"); } //換行 System.out.println(); } }}
打印各種形狀：
【1】長方形：
for(int j=1;j<=4;j++){//j:控制行數 //********* for(int i=1;i<=9;i++){//i:控制*的個數 System.out.print("*"); } //換行： System.out.println(); }
【2】距離前面有一定空隙的長方形：
for(int j=1;j<=4;j++){//j:控制行數 //加入空格： for(int i=1;i<=5;i++){//i:控制空格的個數 System.out.print(" "); } //********* for(int i=1;i<=9;i++){//i:控制*的個數 System.out.print("*"); } //換行： System.out.println(); }
【3】平行四邊形：
for(int j=1;j<=4;j++){//j:控制行數 //加入空格： for(int i=1;i<=(9-j);i++){//i:控制空格的個數 System.out.print(" "); } //********* for(int i=1;i<=9;i++){//i:控制*的個數 System.out.print("*"); } //換行： System.out.println(); }
【4】三角形：
for(int j=1;j<=4;j++){//j:控制行數 //加入空格： for(int i=1;i<=(9-j);i++){//i:控制空格的個數 System.out.print(" "); } //********* for(int i=1;i<=(2*j-1);i++){//i:控制*的個數 System.out.print("*"); } //換行： System.out.println(); }
【5】菱形：
//上面三角形： for(int j=1;j<=4;j++){//j:控制行數 //加入空格： for(int i=1;i<=(9-j);i++){//i:控制空格的個數 System.out.print(" "); } //********* for(int i=1;i<=(2*j-1);i++){//i:控制*的個數 System.out.print("*"); } //換行： System.out.println(); } //下面三角形： for(int j=1;j<=3;j++){//j:控制行數 //加入空格： for(int i=1;i<=(j+5);i++){//i:控制空格的個數 System.out.print(" "); } //********* for(int i=1;i<=(7-2*j);i++){//i:控制*的個數 System.out.print("*"); } //換行： System.out.println(); }
【6】空心菱形：
//上面三角形：
for(int j=1;j<=4;j++){//j:控制行數
//加入空格：
for(int i=1;i<=(9-j);i++){//i:控制空格的個數
System.out.print(" ");
}
//*********
for(int i=1;i<=(2*j-1);i++){//i:控制*的個數
if(i==1||i==(2*j-1)){
System.out.print("*");
}else{
System.out.print(" ");
}
}
//換行：
System.out.println();
}
//下面三角形：
for(int j=1;j<=3;j++){//j:控制行數
//加入空格：
for(int i=1;i<=(j+5);i++){//i:控制空格的個數
System.out.print(" ");
}
//*********
for(int i=1;i<=(7-2*j);i++){//i:控制*的個數
if(i==1||i==(7-2*j)){
System.out.print("*");
}else{
System.out.print(" ");
}
}
//換行：
System.out.println();
}