1. Java語言的發展史
java是哪家公司哪一年推出的？
sun公司在1995推出的編程語言
java之父是誰？
詹姆斯.高斯林
java的主要發展歷程？
1995由sun公司推出。
2004推出JDK1.5，這是里程碑式的版本。
2009年sun公司被oracle（甲骨文公司）收購。
目前最新版本JDK12。
java的三大技術架構
JavaSE：java標準版，主要用於桌面應用軟件的開發。比如計算器，QQ軟件等。
JavaEE：java企業版，基於JavaSE的企業級應用的開發。比如淘寶，京東，ERP系統等。（大型互聯網）
JavaME：java微型版，應用於移動設備和電子類產品的嵌入式開發。比如手機遊戲，手機軟件等。（安卓，IOS，HTML，微信小程序）
2. Java語言跨平臺原理
java語言的特點
java語言具有簡單易學、面向對象、健壯性、安全性、與平臺無關性等特點。
什麼是平臺？
平臺即操作系統，目前主流的有微軟Windows系統，蘋果Mac系統，Linux系統
什麼是java跨平臺？
通過java語言編寫的應用程序可以在不同的操作系統上直接運行。具有一次編譯，到處運行的特點。
java如何實現跨平臺？
通過JVM虛擬機實現的跨平臺。在不同的操作系統上安裝對應的JVM虛擬機。
java跨平臺的原理
java程序並非是直接運行的， javac編譯器將java源程序（.java文件）編譯成與平臺無關的字節碼文件（.class文件），然後通過java運行工具啓動java虛擬機，由java虛擬機（JVM）對字節碼文件解釋執行。所以在不同的操作系統下， 只需安裝不同的java虛擬機即可實現java程序的跨平臺
3. JVM、JRE、JDK
JVM、JRK、JDK三者之間的關係
JVM：Java虛擬機，保證java程序跨平臺。
//JVM保證java程序的跨平臺性
JRE：Java運行環境，包含JVM和核心類庫。如果只是想運行java程序，只要安裝JRE即可。
//JRE=JVM+核心類庫
核心類庫包括：java.util包中的Random/Scanner/Arrays等
JDK：Java開發工具包，包含JRE和開發工具。如果程序員想要開發java程序，需要安裝JDK環境
//JDK=JRE+開發工具
開發工具包括：編譯工具javac.exe ，運行工具java.exe 等
JVM、JRE、JDK關係圖解
4. 常用的DOS命令
進入DOS命令行窗口
快捷鍵win + R打開運行窗口，輸入cmd，按回車進入。
常用DOS命令
| 操作 | 說明 |
|---|---|
| 盤符名稱 | 盤符切換。E:回車，表示切換到E盤 |
| dir | 查看當前路徑下的內容 |
| cd 目錄 | 進入單級目錄。cd develop，表示進入develop文件夾 |
| cd … | 回退到上一級目錄 |
| cd 目錄1\目錄2… | 進入多級目錄。cd develop\java，表示進入develop下的java文件夾 |
| cd \ | 回退到盤符根目錄 |
| cls | 清屏 |
| exit | 退出命令提示符窗口 |
5. Path環境變量的配置
什麼是環境變量
環境變量：指在操作系統中用來指定操作系統運行環境的一些參數
爲什麼要配置環境變量
開發java程序， 需要使用JDK提供的開發工具（比如javac.exe、java.exe等命令），而這些工具在JDK的安裝目錄的bin目錄下，如果不配置環境變量，那麼這些命令只可以在該目錄下執行。 我們不可能把所有的java文件都放到JDK的bin目錄下， 所以配置環境變量的作用就是可以使bin目錄下的java相關命令可以在任意目錄下使用。
常見配置的環境變量
| 環境變量名 | 作用 |
|---|---|
| JAVA_HOME | 指 JDK 安裝的根目錄，如：C:\develop\Java\jdk-11 |
| PATH | 指 java 開發工具的位置，如：C:\develop\Java\jdk-11\bin |
| CLASSPATH | 指 JVM 在運行時到哪一個目錄去加載字節碼文件 |
6. 註釋
註釋的作用？
對代碼進行解釋說明，便於開發人員理解和維護代碼。
註釋不會被程序編譯和運行。
註釋的分類？
單行註釋 // 註釋內容，單行註釋可以嵌套。
多行註釋 /* 註釋內容 /，多行註釋不能嵌套使用。
文檔註釋 /* 註釋內容 */，文檔註釋不能嵌套使用。
7. 關鍵字
什麼是關鍵字？
在java語言中有特殊意義的英文單詞。
java關鍵字的特點？
單詞全部小寫。
在高級開發工具中，關鍵字會有特殊的顏色標記。
java中的關鍵字/保留字
goto和const是java中的預留關鍵字（goto和const也叫保留字）。
8. 常量
什麼是常量？
在程序運行過程中，其值不可以發生改變的量。
常量的分類
字符串常量：使用雙引號 "" 括起來的0到多個字符。"java" ,"程序員" ， "" ， " "，"A" // 大於等於0個字符
字符常量：使用單引號 '' 括起來的單個字符。 'a' , '0' ,'我' //1個字符
整數常量：正負整數 10 -20
小數常量：帶小數點的數字 -3.14 5.12
布爾常量：表示真或假，只有true或false兩個值
空常量：值爲null，不能使用輸出語句直接輸出。//System.out.println(null),會編譯報錯
定義的final變量
9. 數據類型
java是強類型的語言，每一個數據都有對應的數據類型。
位：計算機計算的基本單位，計算機底層是二進制 0 1
字節：計算機存儲的基本單位，1字節=8位。
java數據類型分類？
基本數據類型：4型8種
整數：byte short int long （整數默認是：int類型）
小數：float double （小數默認是：double類型）
字符：char
布爾：boolean
引用數據類型：字符串，數組，類，接口 ,null
基本數據類型分類
1.定義 long 類型加L
int number = 100L;
2.定義 float 類型加F
int f = 10.0F;
10. 變量
什麼是變量？
變量指程序運行過程中，其值在一定範圍內會發生變化的量。
變量的定義格式
數據類型 變量名 = 初始化值
int a = 12;
變量的分類
成員變量：（也叫全局變量，字段）
直接定義在類中，方法外，默認有初始值
1.類成員變量：使用static修飾符修飾的成員變量
2.實例成員變量：沒有使用static修飾符修飾的成員變量
局部變量：變量除了成員變量之外,其他就是局部變量
分爲：方法形參，方法內變量，代碼塊變量
沒有初始化值，必須先初始化才能使用
變量使用的注意事項
1、變量可以定義時初始化，也可以先定義，使用前進行初始化。
//定義的時候初始化
double d = 3.14;
//先定義，後初始化
double d;
d = 3.14;
2、沒有初始化的變量不能直接使用。
int a ;
System.out.println(a); //編譯報錯，
3、相同範圍內，變量名不能重複。
//第一種:方法的形參上變量名不能相同
public static void sum(int a,int a){ //編譯報錯
}
//第二種:一對 {} 內變量名不能相同
public static void sum(){
int a = 10; //編譯報錯
int a = 20; //編譯報錯
}
4、整數默認是int類型，定義long類型時需要加L 或者l,建議加L。
long num = 10L;
5、小數默認是double類型，定義float類型的時候需要在數字後面加F或者f,建議加F。
float f = 3.14F;
6、一行代碼上可以定義多個變量。（不推薦）
int a=10,b=20;
int a,b =20;
a=10;
變量的生命週期
| 存在位置 | 生命週期開始 | 生命週期結束 | 在內存中的位置 | |
|---|---|---|---|---|
| 類成員變量 | 使用static修飾的成員變量 | 當所在字節碼被加載進JVM | 當JVM停止 | 方法區 |
| 實例成員變量 | 沒有使用static修飾的成員變量 | 當創建所在類的對象的時候 | 當該對象被垃圾回收器回收 | 堆 |
| 局部變量 | 方法形參，代碼塊中，方法內 | 當代碼執行到初始化變量的時候 | 所在的方法/代碼塊結束 | 棧 |
11. 標識符
標識符的作用
給 包，類，方法，變量起名的符號。
標識符的組成規則
大小寫英文字母、數字、下劃線_、美元符$、中文（不推薦）
注意事項：
1、不能是數字開頭
2、不能是關鍵字
3、區分大小寫
標識符的命名規範
小駝峯式命名：變量名、方法名
第一個單詞首字母小寫，從第二個單詞開始每個單詞的首字母大寫。
userName，maxValue等
大駝峯式命名：類名
每個單詞的首字母都大寫。
String， ArrayList等
建議：標識符的起名儘量做到見名知意。
12. 類型轉換
隱式類型轉換（自動類型轉換）
從範圍小的類型到範圍大類型的轉換，系統會自動進行類型提升，稱爲自動類型轉換。
1.boolean不參與類型轉換
2.byte不能自動類型轉換爲char
3.char不能自動類型轉換爲short
4.short不能自動類型轉換爲char
強制類型轉換
從範圍大的類型到範圍小的類型的轉換，需要進行強制類型轉換。
格式：
目標數據類型 變量名 = （目標數據類型）變量值（常量值）；
弊端：會造成數據精度丟失。儘量少用強制轉換。
1.boolean不參與類型轉換
2.char可以強制類型轉換爲byte
3.short可以強制類型轉換爲char
4.char可以強制類型轉換爲short
13. 運算符和表達式
運算符：對常量或者變量進行操作的符號。
表達式：通過運算符連接起來的式子
例如：
+ 是運算符，10 + 20 是表達式
- 是運算符，a - b 是表達式
常用的運算符
算術運算符、賦值運算符、自增自減運算符、關係運算符、邏輯運算符、三元運算符
13.1 算術運算符
| 符號 | 作用 | 說明 |
|---|---|---|
| + | 加 | 對數字進行加法運算，對字符串進行拼接 |
| - | 減 | 進行減法操作 |
| * | 乘 | 進行乘法操作 |
| / | 除 | 整數相除的結果只能是整數，想要得到小數，必須有浮點數參與運算。 a / b ,獲得 a 和 b 的商 |
| % | 取餘 | a%b 獲得 a 和 b 相除的餘數 |
13.1.1 表達式類型提升
byte、short、char變量之間進行運算時，類型自動提升爲int。
變量參與運算時，最終結果以最高類型爲準。
/*
表達式類型提升:
1. byte、short、char變量之間進行運算時，類型自動提升爲int。
2. 變量參與運算時，最終結果以最高類型爲準。
*/
public class OperatorDemo02 {
public static void main(String[] args) {
// 1、byte、short、char變量之間進行運算時，類型自動提升爲int。
byte b = 10;
//編譯報錯，b+5，變量b會自動提升爲int類型，運算結果爲int，賦值給byte需要強轉。
// byte b2 = b + 5;
int b2 = b+5;
System.out.println(b2);
// 2. 變量參與運算時，最終結果以最高類型爲準。
int num1 = 10;
long num2 = 20L;
long num3 = num1 + num2; //int + long --->long
System.out.println(num3);
}
}
13.1.2 字符的 + 運算
字符參與運算的規則：
將字符換算成編碼表裏對應的數值進行運算。
等價於：把char類型數據換成對應的十進制數來參與運算
編碼表：
計算機底層使用二進制運算，所以文字和符號必須轉換成二進制數才能被計算機識別，編碼表就是將文字等符號編成對應的數的表格，因爲二進制記錄起來比較麻煩，所以使用十進制數進行文字編碼。
世界上第一張編碼表ASCII（美國標準信息交換碼）。常用編碼表都兼容ASCII碼錶。
常用的編碼：
ASCII編碼：美國標準信息交換碼，世界上第一張編碼表。
GB2312編碼：簡體中文編碼，對常用漢字進行了編碼，兼容ASCII。
GBK：加強版的中文編碼表，對更多漢字進行了編碼，兼容ASCII
UTF-8編碼：萬國碼表，常作爲瀏覽器上的網頁編碼，可以統一顯示各國文字，兼容ASCII。
常見字符對應的十進制數：
‘ a’ ~ ‘z’ : 97 ~ 122
‘A’ ~ ‘Z’ : 65 ~ 90
‘0’ ~ ‘9’ : 48 ~ 57
基本漢字：19968 ~ 40869
char類型表示的範圍：0~65535
ASCII編碼表
/*
字符參與運算的規則：
將字符換算成編碼表裏對應的數值進行運算。
*/
public class CharDemo2{
public static void main(String[] args){
//a~z 97~122
//A~Z 65-90
//0~9 48~57
//基本漢字：19968 ~ 40869
char c = 'a';
int b = c + 10;
System.out.println(b); //c是char類型，參與運算先轉爲十進制，在參與運算 //107
char c2 = 97;
System.out.println(c2); //c2是char，打印c2就是打印他的char類型數據 //a
//char類型範圍 0~65535
// char c3 = 65536; //報錯，超過了char的範圍
int c3 = '中';
int c4 = '國';
System.out.println(c3); //20013
System.out.println(c4); //22269
char c5 = 20013;
char c6 = 22269;
System.out.println(c5); //中
System.out.println(c6); //國
char c7 = '9'; //9
char c8 = 57; //9
char c9 = 9; //打印的結果不是數字9,而是9對應的編碼表的符號73
}
}
13.1.3 字符串的+運算
與字符串進行 “+” 運算，是進行字符串拼接操作，運算結果還是字符串。
字符串只能進行 + 運算
//字符串的加法運算
public class StringAddDemo{
public static void main(String[] args){
int age = 25;
System.out.println("我的年齡是："+age+"歲"); //輸出結果：我的年齡是：25歲
}
}
13.2 賦值運算符
賦值運算符作用
將表達式或者常量值賦給變量。
賦值運算符分類
| 符號 | 作用 | 說明 |
|---|---|---|
| = | 賦值 | 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 |
注意：擴展的賦值運算符隱含了強制類型轉換。
/*
賦值運算符:
擴展賦值運算符隱含了強制類型轉換
*/
public class FuZhiDemo {
public static void main(String[] args) {
//1. 基本賦值運算符 =
int a = 10;
System.out.println(a);
//2. 擴展賦值運算符
int b = 20;
// b+=5;
// b-=5;
// b*=5;
// b/=5;
b%=5; //b = b%5;
System.out.println(b);//0
// 3. 擴展賦值運算符隱含了強制類型轉換
byte num = 10;
num+=5; // 相當於:num = (byte)(num+5);
// num = num + 5; //報錯
System.out.println(num);
}
}
13.3 自增自減運算符
1、++ 、 – 可以放在變量的前面，也可以放在變量的後面。
單獨進行運算時放在前面或者後面，效果一樣。
2、參與其他運算的時候：
a++ ：先將a的值參與其他運算，運算結束後再自身加1。
++a ：先將a自身加1，再將自增後的值參與其他運算。
自減與自增規則相同。
3、最常見用法：單獨使用。
13.4 關係運算符
| 符號 | 作用 | 說明 |
|---|---|---|
| == | 等於 | a == b，判斷如果a等於b，則爲true，否則爲false |
| != | 不等於 | a!=b，判斷如果a不等於b，則爲true，否則爲false |
| > | 大於 | a>b，如果a大於b，則爲true，否則爲false |
| >= | 大於等於 | a>=b，如果a大於等於b，則爲true，否則爲false |
| < | 小於 | a<b，如果a小於b，則爲true，否則爲false |
| <= | 小於等於 | a<=b，如果a小於等於b，則爲true，否則爲false |
注意：
- 關係運算符的運算結果都是boolean類型，要麼是true，要麼是false。
- = 是賦值符號， == 纔是判斷是否相等的符號。
13.5 邏輯運算符
什麼是邏輯運算符？
1、邏輯運算符用於連接關係表達式，描述更復雜的邏輯關係。
2、邏輯運算符的運算結果是boolean類型。
邏輯運算符有哪些
| 符號 | 說明 | 格式 | 運算結果 |
|---|---|---|---|
| & | 邏輯與 | 表達式1 & 表達式2 | 有false則false |
| | | 邏輯或 | 表達式1 | 表達式2 | 有true則true |
| ！ | 邏輯非 | ! (表達式) | 對錶達式結果取反 |
| ^ | 邏輯異或s | 表達式1 ^ 表達式2 | 不同爲true，相同爲false |
短路邏輯運算符（掌握）
| 符號 | 作用 | 說明 |
|---|---|---|
| && | 短路與 | 作用和&相同，但是有短路效果 |
| || | 短路或 | 作用和|相同，但是有短路效果 |
區別：
- 表達式1 & 表達式2 ：所有表達式都會執行。
- 表達式1 && 表達式2 ：如果表達式1爲false，則右邊表達式不再執行，可以提高效率。
- 表達式1 | 表達式2 ：所有表達式都會執行。
- 表達式1 || 表達式2 ：如果表達式1爲true，則右邊表達式不再執行，可以提高效率。
實際開發中，會使用短路與&&、短路或||來提高運算效率。
13.6 三元運算符（三目運算符）
語法格式：
判斷表達式 ? 表達式1 : 表達式2;
執行流程：
執行判斷表達式，判斷結果是boolean類型，爲true時執行表達式1並返回結果，false執行表達式2並返回結果。
應用場景
/*
需求：(使用三元運算符)把三個整數按從小到大打印。
步驟:
求最小值
求最大值
中間值：三個數的和 - 最小值 - 最大值
*/
public class SanYuanDemo4{
public static void main(String[] args){
int a = 60;
int b = 20;
int c = 30;
//求最小值
int tempMin = a<b? a:b;
int min = tempMin<c? tempMin:c;
//求最大值
int tempMax = a>b?a:b;
int max = tempMax>c?tempMax:c;
//中間值：三個數的和 - 最小值 - 最大值
int mid = a+b+c-min-max;
//按從小到大打印
System.out.println(min);
System.out.println(mid);
System.out.println(max);
}
}
14. 鍵盤錄入：Scanner類
Scanner類的作用是什麼
Scanner是JDK提供的用於獲取鍵盤輸入的數據的工具類。該類位於java.util包下。
Scanner的使用步驟
1、導包 import java.util.Scanner
2、創建Scanner的對象 Scanner sc = new Scanner(System.in);
3、調用方法接收數據 int num = sc.nextInt();
/*
需求：Scanner錄入數據求兩個整數的和
*/
//導包
import java.util.Scanner;
public class ScannerDemo2 {
public static void main(String[] args) {
//創建Scanner對象
Scanner sc = new Scanner(System.in);
//提示用戶輸入
System.out.println("請輸入第一個數字：");
//獲得鍵盤輸入
int a = sc.nextInt();
System.out.println("請輸入第二個數字：");
int b = sc.nextInt();
//求和
int sum = a + b;
//打印求和結果
System.out.println("和爲：" + sum);
}
}
15. 進制
15.1 概念
進制也就是進位制，是人們規定的一種進位方法。 對於任何一種進制—X進制，就表示某一位置上的數運算時是逢X進一位。
十進制是逢十進一，十六進制是逢十六進一，二進制就是逢二進一，以此類推，x進制就是逢x進位。
15.2 常見的進制
二進制:由兩個基本數字0，1組成，運算規律是逢二進一.計算機都使用二進制表示數據.
八進制:由0、1、2、3、4、5、6、7組成,運算規律是逢八進一.
十進制:由0，1，2、3、4、5、6、7、8、9組成.
十六進制:由0～9以及A，B，C，D，E，F組成.
15.3 進制之間的轉換
15.3.1 十進制和二進制之間轉換
十進制—>二進制
對於整數部分，用被除數反覆除以2，除第一次外，每次除以2均取前一次商的整數部分作被除數並依次記下每次的餘數。
另外，所得到的商的最後一位餘數是所求二進制數的最高位。
二進制—>十進制
進制數第1位的權值是2的0次方，第2位的權值是2的1次方，第2位的權值是2的2次方……公式：第N位 * 2的N-1次方,結果再相加.
15.3.2 十進制和十六進制之間轉換
十進制—>十六進制:
10進制數轉換成16進制的方法，和轉換爲2進制的方法類似，唯一變化：除數由2變成16。
十六進制—>十進制:
第0位的權值爲16的0次方，第1位的權值爲16的1次方，第2位的權值爲16的2次方……
16. 原碼、反碼、補碼
16.1 概述
在計算機內，有符號數有3種表示法：原碼、反碼和補碼,所有數據的運算都是採用補碼進行的
16.2 原碼
寫出二進制,正數符號位爲0,負數符號位爲1
16.3 反碼
正數的反碼是本身,負數的反碼是在其原碼的基礎上, 符號位不變,其餘各個位取反
16.4 補碼
正數的補碼就是其本身,負數的補碼是在其原碼的基礎上, 符號位不變, 其餘各位取反, 最後+1. (即在反碼的基礎上+1)
17. 流程控制語句
流程控制語句分爲哪幾類
順序結構、選擇(分支)結構、循環結構
17.1 順序結構
按照代碼書寫順序，從上往下執行。
17.2 選擇結構（if switch）
17.2.1 if結構
if語句格式1
if (關係表達式) {
語句體；
}
執行流程：
1、首先計算關係表達式的值。
2、表達式的值爲 true 時執行語句體，爲 false 時不執行語句體。
3、往下執行 if結構後面的語句內容。
if語句格式2
if(關係表達式){
語句體1；
}else{
語句體2；
}
執行流程：
1、首先計算關係表達式的值。
2、表達式的值爲 true 時執行語句體1，爲 false 時執行語句體2。
3、繼續執行 if-else 結構後面的語句內容。
if語句格式3
if(關係表達式1){
語句體1；
}else if(關係表達式2){
語句體2；
}else{
語句體3；
}
//【注意】 該格式中可以有多個else if結構，可以沒有else結構。
執行流程：
1、首先計算關係表達式1的值。
2、如果爲 true 則執行語句體1，爲 false 時計算關係表達式2的值。
3、如果爲 true 則執行語句體2，爲 false 時計算關係表達式3的值，以此類推。
4、所有關係表達式都爲false時，執行else裏的語句體n+1。
//案例：鍵盤錄入一個1~7的整數，輸出對應的星期一到星期日。
//導包
import java.util.Scanner;
public class IfTest{
public static void main(String[] args){
//創建Scanner對象
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一個整數(1~7)：");
//接收鍵盤錄入的整數
int week = sc.nextInt();
//使用if-elseif結構判斷
if(week==1){
System.out.println("星期一");
}else if(week==2){
System.out.println("星期二");
}else if(week==3){
System.out.println("星期三");
}else if(week==4){
System.out.println("星期四");
}else if(week==5){
System.out.println("星期五");
}else if(week==6){
System.out.println("星期六");
}else if(week==7){
System.out.println("星期日");
}else{
System.out.println("您輸入的數字無效！");
}
}
}
17.2.2 switch結構
switch語句格式
switch(表達式){ //整數 byte short int //char 字符串 //枚舉
case 值1：
語句體1；
break;
case 值2：
語句體2；
break;
...
default
語句體n+1；
break;
}
執行流程：
1、先計算括號中表達式的值。
2、將結果依次和case後面的值比較，匹配上的就執行case對應的語句體，遇到break就結束switch結構。
3、當所有的case值都不匹配時，執行default後面的語句體n+1， default省略break，效果一樣。
/*
需求: 鍵盤輸入1 2 3, 輸出對應的 "冠軍" ,"亞軍", "季軍"
*/
public class SwitchDemo {
public static void main(String[] args) {
//獲取鍵盤錄入
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一個整數(1~3):");
int num = sc.nextInt();
switch(num){
case 1:
System.out.println("冠軍");
break;
case 2:
System.out.println("亞軍");
break;
case 3:
System.out.println("季軍");
break;
default:
System.out.println("無");
}
}
}
switch的注意事項：
1、switch中表達式的值：byte short char int , 枚舉， 字符串
2、case 後面的值不能重複，不能是變量，只能是常量
3、case的值都不匹配的時候，執行default的內容，default可以省略(不建議)，default可以改變位置(不建議)
4、break的作用是結束switch語句
5、break可以省略，但是會有case穿透現象
case穿透現象：不用再判斷case的值，直接執行下面的語句，直到遇到break或者程序結束。
case穿透案例:
/*
春夏秋冬
需求：
一年有12個月，分屬於春夏秋冬4個季節，鍵盤錄入一個月份，
請用程序實現判斷該月份屬於哪個季節，並輸出。
春：3、4、5
夏：6、7、8
秋：9、10、11
冬：12、1、2
*/
import java.util.Scanner;
public class SwitchDemo {
public static void main(String[] args) {
//鍵盤錄入月份數據，使用變量接收
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一個月份：");
int month = sc.nextInt();
//case穿透
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("你輸入的月份有誤");
}
}
}
17.3 循環結構
循環語句可以在滿足循環條件的情況下，反覆執行某一段代碼，這段被重複執行的代碼被稱爲循環體語句，當反覆 執行這個循環體時，需要在合適的時候結束循環，否則循環將一直執行下去，形成死循環。
17.3.1 for循環
for循環格式
for (初始化語句; 條件判斷語句; 條件控制語句) {
循環體語句;
}
//案例：for循環打印5次HelloWorld
for(int i=1; i<=5; i++){
System.out.println("HelloWorld");
}
執行流程
1、執行初始化語句：int i = 1（只會執行一次）。
2、執行條件判斷語句 i<=5，如果爲true，執行循環體語句，如果爲false，則結束循環。
3、執行循環體語句 ： System.out.println(“HelloWorld”);
4、執行條件控制語句 ：i++
5、回到第2步繼續往下執行。
/*
需求:使用for循環統計水仙花數的個數
*/
public class ForDemo5 {
public static void main(String[] args) {
//定義統計變量
int count = 0;
// 1. for循環獲取所有三位數
for(int i=100; i<1000; i++) {
// 2. 得到每個三位數的個,十,百位上的數字
int unit = i/1%10;
int ten = i/10%10;
int hundred = i/100%10;
// 3. 判斷是否是水仙花數 : 個, 十, 百位立方和等於該三位數本身
if(unit*unit*unit + ten*ten*ten + hundred*hundred*hundred == i) {
//4. 統計個數
count++;
}
}
// 5. 循環結束打印個數
System.out.println(count);
}
}
17.3.2 while循環
while循環格式
初始化語句;
while(條件判斷語句){
循環體語句;
條件控制語句;
}
//案例：while循環打印5次HelloWorld
int i = 1;
while(i<=5){
System.out.println("HelloWorld");
i++;
}
執行流程圖
/*
需求:使用while循環求1~100的偶數個數
*/
public class WhileDemo{
public static void main(String[] args){
//定義統計變量
int count = 0;
//初始化循環條件
int i = 1;
//循環獲得1~100的整數
while(i<=100){
//獲得偶數
if(i%2==0){
//統計個數
count++;
}
//控制循環條件
i++;
}
//循環結束,打印偶數個數
System.out.println("1~100的偶數個數爲:"+count);
}
}
17.3.3 do while循環
do-while循環格式
初始化語句;
do {
循環體語句;
條件控制語句;
}while(條件判斷語句);
//案例：while循環打印5次HelloWorld
int i = 1;
do{
System.out.println("HelloWorld");
i++;
}while(i<=5);
執行流程
1、執行初始化語句。（只執行一次）
2、執行循環體語句。
3、執行條件控制語句。
4、執行條件判斷語句，如果爲false則結束循環，如果爲true則回到第2步繼續執行。
注意：do-while循環至少會執行一次循環體語句。
17.3.4 三種循環的區別
| for | while | do-while | |
|---|---|---|---|
| 特點 | 先判斷，再執行 | 先判斷，再執行 | 先執行，後判斷（至少執行一次） |
| 初始化變量 | for循環外無法使用初始化變量 | 循環結束後，初始化變量能繼續使用 | 循環結束後，初始化變量能繼續使用 |
| 適用場景 | 循環次數確定的情況 | 循環次數不確定的情況 | 循環至少需要執行一次 |
依次推薦使用：for循環 、while循環 、do-while循環
三種循環的死循環簡單寫法：
//1、for循環
for(;;){
}
//2、while循環(建議)
while(true){
}
//3、do-while循環
do{
}while(true);
17.4 跳轉控制語句
17.4.1 break關鍵字
break使用場景:
1、在switch中，用於結束switch結構。
2、在循環中，用於結束break所在循環。
3、當有循環嵌套時，可以爲循環加上標籤，讓break結束指定循環。
注意：
break語句後面不能直接跟其他語句，否則會編譯報錯。
17.4.2 continue關鍵字
continue使用場景:
1. continue只能在循環中使用，用於跳過一次循環，開始下一次循環。
2. 當有循環嵌套時，可以配合標籤,跳到指定循環繼續執行。
注意：
continue後面不能直接跟其他語句，否則會編譯報錯。
17.4.3 break和continue的區別
break：結束整個循環。
continue：跳過本次循環，繼續下一次循環。
public class ControlDemo{
public static void main(String[] args){
for(int i=1; i<=5; i++){
if( i%2==0 ){
continue; //遇到continue開始下次循環：打印奇數
// break; //遇到break結束整個循環
}
}
System.out.println(i);
}
}
/*
模擬一個用戶系統
控制檯顯示一個用戶菜單：
輸入數字選擇您要的操作：
1.新增用戶 2.修改用戶 3.刪除用戶 4.查看信息 5.退出系統
工作人員輸入對應的編號進行操作，當輸入5時退出系統。
*/
import java.util.Scanner;
public class BreakDemo{
public static void main(String[] args){
//創建鍵盤錄入對象
Scanner sc = new Scanner(System.in);
//死循環
loop:while(true){
System.out.println("輸入數字選擇您要的操作：");
System.out.println("1.新增用戶 2.修改用戶 3.刪除用戶 4.查看信息 5.退出系統");
int num = sc.nextInt();
switch(num){
case 1:
System.out.println("新增成功");
break;
case 2:
System.out.println("修改成功");
break;
case 3:
System.out.println("刪除成功");
break;
case 4:
System.out.println("當前用戶數1000");
break;
case 5:
System.out.println("歡迎使用本軟件");
//結束指定循環：loop
break loop; //結束loop標誌的的循環
default:
System.out.println("您的輸入有誤,請重新輸入！");
}
}
}
}
18. 隨機數：Random類
認識Rondom類
Random是java提供的工具類，位於【 java.util 】包下，用於產生隨機數。
Random類的使用步驟
1.導包
import java.util.Random;
2.創建對象
Random r = new Random();
3.產生隨機數
int num = r.nextInt(100);//獲取0~99的隨機數
注意:r.nextInt(100); 獲取0~99的隨機數
r.nextInt(200); 獲取0~199的隨機數
說明：
nextInt( 數值 )：代表隨機生成並返回一個整數，如果括號數值爲10，表示生成0-9的整數，數值20，表示生成0~19的整數
產生範圍65~90之間的整數 int num = r.nextInt(26)+65; 0~25 + 65
產生範圍97~122之間的整數 int num = r.nextInt(26)+97; 0~25 + 97
/*
需求:隨機生成一個1~100之間的整數.
*/
//1.導包
import java.util.Random;
public class RandomDemo{
public static void main(String[] args){
//2.創建Random對象
Random r = new Random();
//3.調用方法產生隨機數
int num = r.nextInt(100)+1;
System.out.println(num);
}
}
19. 數組
19.1 數組的作用和特點
作用：數組可用於存儲同一類型的多個數據，是一個java的數據容器。
特點：數組長度固定，所存數據類型一致。
19.2 數組的定義格式
//【格式1】（掌握）
數據類型[] 數組名
//示例
int[] arr
boolean[] arr
double[] arr
//【格式2】（瞭解）
數據類型 數組名[]
//示例
double arr[]
什麼是數組初始化
java中變量使用前必須完成初始化，數組也一樣，需要完成初始化才能使用。
數組初始化就是爲數組分配內存空間，併爲數組中每個元素賦值。
數組的初始化分爲:
動態初始化
靜態初始化
19.3 數組的動態初始化
什麼是動態初始化
只給定數組的長度，由系統給出默認初始化值。
動態初始化的格式
數據類型[] 數組名 = new 數據類型[數組長度];
double[] arr = new double[50];
格式說明
int[] arr = new int[5];
等號左邊：
int:數組的數據類型
[]:代表這是一個數組
arr:代表數組的名稱
等號右邊：
new:爲數組開闢內存空間
int:數組的數據類型
[]:代表這是一個數組
5:代表數組的長度
19.4 數組元素訪問
數組變量存儲的是什麼
數組在堆內存中的地址值
什麼是索引
數組索引：數組元素的編號，從0開始，最大值爲數組長度-1。
可以通過索引操作數組元素。
數組元素訪問的格式
數組名[索引]
public class ArrayDemo {
public static void main(String[] args) {
//定義並初始化長度爲3的int數組
int[] arr = new int[3];
//輸出數組名，得到一個地址值
System.out.println(arr); //[I@880ec60
//輸出數組中的元素
System.out.println(arr[0]); //默認值0
System.out.println(arr[1]); //默認值0
System.out.println(arr[2]); //默認值0
}
}
19.5 電腦內存分配（指運行內存，非硬盤）
19.6 JVM的內存分配
各個內存區的作用
| 區域名稱 | 作用 |
|---|---|
| 棧內存（Stack） | 方法運行時使用的內存，存放方法中的變量和參數 |
| 堆內存（Heap） | 存儲對象或數組，new出來的數據，都存儲在堆內存 |
| 堆內存（Heap） | 存儲對象或數組，new出來的數據，都存儲在堆內存 |
| 寄存器 | 給CPU使用，和我們開發無關 |
| 本地方法棧 | JVM在使用操作系統功能的時候使用，和我們開發無關 |
| 方法區 | 存儲已加載的class文件信息 |
棧內存：棧中存放局部變量，方法執行完畢，內存釋放。
堆內存：堆中存放的是new出來的數據( 數組，對象等 )。數據使用完畢後，等待垃圾回收器回收。
new出來的數據, 都有一個對應的地址
19.7 數組的內存圖
數組元素的默認初始化值
整數類型 0
浮點類型 0.0
字符類型 空字符 ' '
布爾類型 false
引用類型 null
19.7.1 一個數組的內存圖
19.7.2 多個數組的內存圖
19.7.3 多個數組指向相同的內存地址
其中任意一個數組改變了堆中元素的值，其他的數組都會受到影響
19.8 數組的靜態初始化
什麼是靜態初始化
在創建數組時，直接確定元素的值。
靜態初始化的格式
數據類型[] 數組名 = new 數據類型[]{元素1, 元素2, 元素3...}
//示例
int[] arr = new int[]{1,2,3};
靜態初始化簡化格式
數據類型[] 數組名 = {元素1, 元素2， 元素3...}；
//示例
int[] arr = {1,2,3};
19.9 數組的遍歷
獲取數組長度
數組名.length
遍歷數組
//for循環進行數組遍歷
public class ArrayDemo2 {
public static void main(String[] args) {
//定義數組
int[] arr = {11, 22, 33, 44, 55};
//使用for循環遍歷並打印
for(int i=0; i <arr.length; i++) {
System.out.println(arr[x]);
}
}
}
求最值
/*
* 需求：求出數組的最大值、最小值
*/
public class ArrayDemo3 {
public static void main(String[] args) {
//定義數組
int[] arr = {45,12,98,73,60};
//------------求數組最大值------------
//定義變量存放數組最大值，並假設第一個元素爲最大值
int max = arr[0];
//從第二個元素開始，依次和max變量比較
for(int i=1; i<arr.length; i++){
//如果比max大的，就替換max的值
if( arr[i]>max ){
max = arr[i];
}
}
//循環結束後max存放的就是最大的值
System.out.println("最大值爲："+ max);
//------------求數組最小值------------
//假設第一個元素是最小的
int min = arr[0];
//從第二個元素開始，依次和min變量比較
for(int i=1; i<arr.length; i++){
//如果比min小的，就替換min的值
if( arr[i]<min ){
min = arr[i];
}
}
//循環結束後，打印最小值
System.out.println("最小值爲：" + min);
}
}
19.10 多維數組
數組元素類型[] 數組名;
int[][] arr = new int[][] {
arr1 ,arr2,arr3
};
int[][] arr = new int[][] {
{1,2,3} ,
{4,5},
{6}
};
一維數組:數組中的每一個元素都是一個值(基本類型和引用類型的值).
二維數組:數組中的每一個元素又是一個一維數組.
三維數組:數組中的每一個元素又是一個二維數組.
二維數組的初始化操作:
靜態初始化:
int[][] arr = new int[][] {
{1,2,3} ,
{4,5},
{6}
};
動態初始化:
int[][] arr = new int[3][5] ;創建一個長度爲3的二維數組,每一個元素(一維數組)的長度爲5.
int[][] arr = new int[0][5]
-------------------------------------
針對於N維數組,需要N個循環嵌套.
20. 方法
20.1 方法的概述
什麼是方法
方法是將具有獨立功能的代碼組成一個整體，使其成爲具有特殊功能的代碼塊。
方法的兩個注意
1、方法必須先定義才能使用。（方法定義）
2、方法定義後不會自動運行，需要手動調用才能執行方法的功能。（方法調用）
20.2 方法的定義和調用
20.2.1方法的定義格式1：無參數無返回值
public static void 方法名(){
方法體代碼; //需要在方法內完成的代碼
}
//調用格式
方法名（）
/*
需求:
1. 定義一個方法,方法名爲: printHelloWorld
2. 在方法中使用循環打印5次hello world.
3. 在main方法中調用執行 printHelloWorld 方法.
*/
public class MethodDemo {
public static void main(String[] args){
printHelloWorld();
}
public static void printHelloWorld(){
for(int i=1;i<=5;i++){
System.out.println("hello world");
}
}
}
方法在棧中的調用執行過程
1、棧是方法運行的內存區域。
2、先調用的方法先入棧，後調用的方法後入棧，後入棧的方法先執行完畢，並在棧內存中消失。
3、main方法是最先開始執行，最晚從內存中消失的。
20.2.2 方法的定義格式2：有參數無返回值
public static void 方法名( 參數類型1 參數名1, 參數類型2 參數名2, ...){
方法體代碼;
}
注意：
方法的參數，可以是一個，也可以是多個，如果是多個參數，中間需要以逗號分隔。
//調用格式
方法名（參數值1/變量1，參數值2/變量2，...）
調用帶參方法的注意事項
1、調用帶參方法，傳入方法括號裏的參數，無論個數和類型，都必須和方法定義時的個數和類型匹配。
2、傳入方法的參數，可以是變量，也可以是常量。
20.2.3 形參和實參
形參，也叫形式參數，指的是定義方法的時候，方法小括號中定義的參數。
實參，也叫實際參數，指的是調用方法的時候，傳入小括號中的常量或變量。
20.2.4 方法的定義格式3：有、無參數有返回值
//有參數有返回值
public static 數據類型 方法名(參數列表){
方法體代碼;
return 數據值;
}
//無參數有返回值
public static void 方法名（參數列表）{
方法體代碼；
return 數據值；
}
1、格式要求
有返回值類型，就必須要有return語句。
返回值必須和返回值類型相匹配。
2、return語句的作用
return語句用於將方法的運算結果返回給調用者。
return語句一旦執行，方法的調用就結束了。
return語句後面不能直接跟其他代碼
3、有返回值的方法是否一定要接收返回結果
調用有返回值的方法時，方法的返回值可以接收也可以不接收，根據實際需要確定。如果不接收，該返回值就會丟失。大部分情況下，需要接收返回結果的。
4、有返回值的方法調用方式
1. 直接調用：該方式會丟失返回值數據。
方法名(參數值);
2. 輸出調用：在輸出語句中調用，直接使用結果。
System.out.println( 方法名(參數值) );
3. 賦值調用：調用方法，並定義變量接收返回值。 （使用最多的方式）
數據類型 變量名 = 方法名(參數值);
20.2.5 方法使用注意事項
1、方法與方法之間是平級關係，不允許嵌套定義。
2、方法有明確返回值類型時，必須要有return語句返回對應的數據。
3、返回值類型爲void，則代表無返回值，可以省略return語句，也可以單獨使用return關鍵字，用於結束方法，但是return後面不能跟任何數值。
4、方法有形參時，調用時必須傳遞實參，傳遞的實參個數和類型必須和形參匹配。
5、return語句後面不能直接跟其他代碼。
20.2.6 方法的通用格式
public static 返回值類型 方法名(參數類型 參數名1, 參數類型 參數名2, ...){
方法體代碼;
return 返回值;
}
格式說明：
public static：public和static都是關鍵字，具有特殊的含義。（先這樣寫着，後續講解）
返回值類型：方法有返回值時寫返回值類型（基本數據類型、引用數據類型），沒有返回值時寫void。
方法名：用於方法調用時使用。
( )：括號裏面寫參數列表，多個參數使用逗號隔開，沒有參數時直接寫 ( ) 即可。
參數類型：限定傳入方法的參數的數據類型。（基本數據類型、引用數據類型）
參數名：用於接收傳入方法的數據。
{ }：大括號和裏面的代碼稱爲方法體。
return：方法有返回值時需要使用return關鍵字，返回對應的類型的數據。 沒有返回值（void）時不用寫return語句。
定義方法的兩個明確：
1、明確返回值類型：確定方法是否需要返回值，以及返回值的類型。
2、明確參數：明確參數的類型和個數。
調用方法注意：
1、void類型的方法，直接調用即可。
2、非void類型的方法，推薦使用變量接收調用。
3、方法有參數時，調用時需要傳參。
20.3 方法重載
20.3.1 什麼是方法重載
同一個類中，出現了多個同名的方法，叫做方法重載。
20.3.2 構成方法重載的條件
1. 多個方法在同一個類中。
2. 多個方法名稱相同。
3. 多個方法的參數列表不同（個數或者類型不同）。
注意：
方法重載與返回值和參數名稱無關。
簡單總結：
同一類中，方法名稱相同，參數列表不同，即構成方法重載。
20.3.3 方法重載的作用
方便程序員對參數不同，但是功能相同或相似的方法進行統一的命名和調用。
20.3.4 調用重載的方法
調用時，虛擬機會根據參數列表的不同來區分調用對應的重載方法。
20.4 方法參數傳遞
20.4.1 方法參數傳遞基本類型
結論：
方法參數爲基本數據類型時，參數爲值傳遞，形式參數的改變不會影響實際參數
代碼：
/*
參數傳遞爲基本數據類型
*/
public class MethodDemo4 {
public static void main(String[] args) {
int num = 5;
add(num);
System.out.println(num);
}
//方法形參爲基本數據類型
public static void add(int num){
num+=10; //num = 15;
}
}
20.4.2 方法參數傳遞引用類型
什麼是引用類型數據？
在堆內存中創建，併產生了一個地址值的數據。（數組、對象，接口）
結論：
方法參數爲引用數據類型時，參數爲地址傳遞，形式參數的改變會直接影響實際參數。
代碼：
/*
參數傳遞爲引用類型
*/
public class MethodDemo5 {
public static void main(String[] args) {
int[] arr = {10,20,30};
System.out.println("調用前："+arr[0]); //10
change(arr);
System.out.println("調用後："+arr[0]); //100
}
//方法形參爲引用類型
public static void change(int[] arr) {
arr[0] = 100;
}
}
